From 872a312af040cc9ccc744cd1c75d781db2162f13 Mon Sep 17 00:00:00 2001 From: GregF Date: Thu, 10 Sep 2015 10:13:46 -0600 Subject: [PATCH] Use Vulkan layer to generate trace file --- renderdoc/Makefile | 4 +- .../build/layers/vk_dispatch_table_helper.h | 206 ++ .../include/vk_debug_marker_layer.h | 45 + .../include/vk_debug_marker_lunarg.h | 98 + .../include/vk_debug_report_lunarg.h | 256 ++ .../vulkan/LoaderAndTools/include/vk_icd.h | 32 + .../vulkan/LoaderAndTools/include/vk_layer.h | 217 ++ .../LoaderAndTools/include/vk_platform.h | 99 + .../include/vk_wsi_device_swapchain.h | 249 ++ .../LoaderAndTools/include/vk_wsi_lunarg.h | 175 + .../LoaderAndTools/include/vk_wsi_swapchain.h | 133 + .../vulkan/LoaderAndTools/include/vulkan.h | 3054 +++++++++++++++++ .../layers/vk_layer_extension_utils.h | 54 + .../LoaderAndTools/layers/vk_layer_table.cpp | 198 ++ .../LoaderAndTools/layers/vk_layer_table.h | 51 + .../loader/vk_loader_platform.h | 423 +++ renderdoc/driver/vulkan/Makefile | 40 +- renderdoc/driver/vulkan/rdtrace.cpp | 241 ++ renderdoc/driver/vulkan/renderdoc.json | 11 + renderdoc/driver/vulkan/vk_core.cpp | 685 ++-- renderdoc/driver/vulkan/vk_core.h | 11 +- renderdoc/driver/vulkan/vk_hookset_defs.h | 12 +- renderdoc/driver/vulkan/vk_replay.cpp | 289 +- renderdoc/driver/vulkan/vk_replay.h | 8 +- renderdoc/os/linux/linux_process.cpp | 58 +- 25 files changed, 6143 insertions(+), 506 deletions(-) create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/build/layers/vk_dispatch_table_helper.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_marker_layer.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_marker_lunarg.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_report_lunarg.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/include/vk_icd.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/include/vk_layer.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/include/vk_platform.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_device_swapchain.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_lunarg.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_swapchain.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/include/vulkan.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_extension_utils.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.cpp create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.h create mode 100644 renderdoc/driver/vulkan/LoaderAndTools/loader/vk_loader_platform.h create mode 100644 renderdoc/driver/vulkan/rdtrace.cpp create mode 100644 renderdoc/driver/vulkan/renderdoc.json diff --git a/renderdoc/Makefile b/renderdoc/Makefile index eb16d15a0..685cdf54c 100644 --- a/renderdoc/Makefile +++ b/renderdoc/Makefile @@ -8,7 +8,7 @@ MACROS=-DLINUX \ CFLAGS=-c -Wall -Werror -Wno-unused -Wno-unknown-pragmas -fPIC $(MACROS) -I. -I3rdparty/ CPPFLAGS=-std=c++11 -g -Wno-reorder -fvisibility=hidden -fvisibility-inlines-hidden LDFLAGS=-lpthread -lrt -shared -ldl -lX11 -LIBS=driver/gl/rdoc_gl.a driver/vulkan/rdoc_vulkan.a driver/shaders/spirv/rdoc_spirv.a +LIBS=driver/gl/rdoc_gl.a driver/vulkan/rdoc_vulkan.a driver/shaders/spirv/rdoc_spirv.a driver/vulkan/lib/vulkan/liblayer_utils.so OBJDIR=.obj OBJECTS=replay/replay_output.o \ replay/replay_renderer.o \ @@ -130,7 +130,7 @@ force_look: true librenderdoc.so: $(OBJDIR_OBJECTS) $(OBJDIR_DATA) $(LIBS) - $(CPP) -o librenderdoc.so $(OBJDIR_DATA) -Wl,--whole-archive $(LIBS) -Wl,--no-whole-archive $(OBJDIR_OBJECTS) $(LDFLAGS) + $(CPP) -o librenderdoc.so $(OBJDIR_DATA) -Wl,--whole-archive $(LIBS) -Wl,--no-whole-archive $(OBJDIR_OBJECTS) $(LDFLAGS) -Wl,-rpath,/home/greg/renderdoc/vulkan/renderdoc/driver/vulkan/lib/vulkan/ .PHONY: clean clean: diff --git a/renderdoc/driver/vulkan/LoaderAndTools/build/layers/vk_dispatch_table_helper.h b/renderdoc/driver/vulkan/LoaderAndTools/build/layers/vk_dispatch_table_helper.h new file mode 100644 index 000000000..7e76d1a14 --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/build/layers/vk_dispatch_table_helper.h @@ -0,0 +1,206 @@ +/* THIS FILE IS GENERATED. DO NOT EDIT. */ + +/* + * Vulkan + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include +#include + +static inline void layer_initialize_dispatch_table(VkLayerDispatchTable *table, + const VkBaseLayerObject *devw) +{ + VkDevice device = (VkDevice) devw->nextObject; + PFN_vkGetDeviceProcAddr gpa = (PFN_vkGetDeviceProcAddr) devw->pGPA; + VkDevice baseDevice = (VkDevice) devw->baseObject; + // GPA has to be first entry inited and uses wrapped object since it triggers init + memset(table, 0, sizeof(*table)); + table->GetDeviceProcAddr =(PFN_vkGetDeviceProcAddr) gpa(device,"vkGetDeviceProcAddr"); + table->CreateDevice = (PFN_vkCreateDevice) gpa(baseDevice, "vkCreateDevice"); + table->DestroyDevice = (PFN_vkDestroyDevice) gpa(baseDevice, "vkDestroyDevice"); + table->GetDeviceQueue = (PFN_vkGetDeviceQueue) gpa(baseDevice, "vkGetDeviceQueue"); + table->QueueSubmit = (PFN_vkQueueSubmit) gpa(baseDevice, "vkQueueSubmit"); + table->QueueWaitIdle = (PFN_vkQueueWaitIdle) gpa(baseDevice, "vkQueueWaitIdle"); + table->DeviceWaitIdle = (PFN_vkDeviceWaitIdle) gpa(baseDevice, "vkDeviceWaitIdle"); + table->AllocMemory = (PFN_vkAllocMemory) gpa(baseDevice, "vkAllocMemory"); + table->FreeMemory = (PFN_vkFreeMemory) gpa(baseDevice, "vkFreeMemory"); + table->MapMemory = (PFN_vkMapMemory) gpa(baseDevice, "vkMapMemory"); + table->UnmapMemory = (PFN_vkUnmapMemory) gpa(baseDevice, "vkUnmapMemory"); + table->FlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges) gpa(baseDevice, "vkFlushMappedMemoryRanges"); + table->InvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges) gpa(baseDevice, "vkInvalidateMappedMemoryRanges"); + table->GetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment) gpa(baseDevice, "vkGetDeviceMemoryCommitment"); + table->BindBufferMemory = (PFN_vkBindBufferMemory) gpa(baseDevice, "vkBindBufferMemory"); + table->BindImageMemory = (PFN_vkBindImageMemory) gpa(baseDevice, "vkBindImageMemory"); + table->GetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements) gpa(baseDevice, "vkGetBufferMemoryRequirements"); + table->GetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements) gpa(baseDevice, "vkGetImageMemoryRequirements"); + table->GetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements) gpa(baseDevice, "vkGetImageSparseMemoryRequirements"); + table->QueueBindSparseBufferMemory = (PFN_vkQueueBindSparseBufferMemory) gpa(baseDevice, "vkQueueBindSparseBufferMemory"); + table->QueueBindSparseImageOpaqueMemory = (PFN_vkQueueBindSparseImageOpaqueMemory) gpa(baseDevice, "vkQueueBindSparseImageOpaqueMemory"); + table->QueueBindSparseImageMemory = (PFN_vkQueueBindSparseImageMemory) gpa(baseDevice, "vkQueueBindSparseImageMemory"); + table->CreateFence = (PFN_vkCreateFence) gpa(baseDevice, "vkCreateFence"); + table->DestroyFence = (PFN_vkDestroyFence) gpa(baseDevice, "vkDestroyFence"); + table->ResetFences = (PFN_vkResetFences) gpa(baseDevice, "vkResetFences"); + table->GetFenceStatus = (PFN_vkGetFenceStatus) gpa(baseDevice, "vkGetFenceStatus"); + table->WaitForFences = (PFN_vkWaitForFences) gpa(baseDevice, "vkWaitForFences"); + table->CreateSemaphore = (PFN_vkCreateSemaphore) gpa(baseDevice, "vkCreateSemaphore"); + table->DestroySemaphore = (PFN_vkDestroySemaphore) gpa(baseDevice, "vkDestroySemaphore"); + table->QueueSignalSemaphore = (PFN_vkQueueSignalSemaphore) gpa(baseDevice, "vkQueueSignalSemaphore"); + table->QueueWaitSemaphore = (PFN_vkQueueWaitSemaphore) gpa(baseDevice, "vkQueueWaitSemaphore"); + table->CreateEvent = (PFN_vkCreateEvent) gpa(baseDevice, "vkCreateEvent"); + table->DestroyEvent = (PFN_vkDestroyEvent) gpa(baseDevice, "vkDestroyEvent"); + table->GetEventStatus = (PFN_vkGetEventStatus) gpa(baseDevice, "vkGetEventStatus"); + table->SetEvent = (PFN_vkSetEvent) gpa(baseDevice, "vkSetEvent"); + table->ResetEvent = (PFN_vkResetEvent) gpa(baseDevice, "vkResetEvent"); + table->CreateQueryPool = (PFN_vkCreateQueryPool) gpa(baseDevice, "vkCreateQueryPool"); + table->DestroyQueryPool = (PFN_vkDestroyQueryPool) gpa(baseDevice, "vkDestroyQueryPool"); + table->GetQueryPoolResults = (PFN_vkGetQueryPoolResults) gpa(baseDevice, "vkGetQueryPoolResults"); + table->CreateBuffer = (PFN_vkCreateBuffer) gpa(baseDevice, "vkCreateBuffer"); + table->DestroyBuffer = (PFN_vkDestroyBuffer) gpa(baseDevice, "vkDestroyBuffer"); + table->CreateBufferView = (PFN_vkCreateBufferView) gpa(baseDevice, "vkCreateBufferView"); + table->DestroyBufferView = (PFN_vkDestroyBufferView) gpa(baseDevice, "vkDestroyBufferView"); + table->CreateImage = (PFN_vkCreateImage) gpa(baseDevice, "vkCreateImage"); + table->DestroyImage = (PFN_vkDestroyImage) gpa(baseDevice, "vkDestroyImage"); + table->GetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout) gpa(baseDevice, "vkGetImageSubresourceLayout"); + table->CreateImageView = (PFN_vkCreateImageView) gpa(baseDevice, "vkCreateImageView"); + table->DestroyImageView = (PFN_vkDestroyImageView) gpa(baseDevice, "vkDestroyImageView"); + table->CreateAttachmentView = (PFN_vkCreateAttachmentView) gpa(baseDevice, "vkCreateAttachmentView"); + table->DestroyAttachmentView = (PFN_vkDestroyAttachmentView) gpa(baseDevice, "vkDestroyAttachmentView"); + table->CreateShaderModule = (PFN_vkCreateShaderModule) gpa(baseDevice, "vkCreateShaderModule"); + table->DestroyShaderModule = (PFN_vkDestroyShaderModule) gpa(baseDevice, "vkDestroyShaderModule"); + table->CreateShader = (PFN_vkCreateShader) gpa(baseDevice, "vkCreateShader"); + table->DestroyShader = (PFN_vkDestroyShader) gpa(baseDevice, "vkDestroyShader"); + table->CreatePipelineCache = (PFN_vkCreatePipelineCache) gpa(baseDevice, "vkCreatePipelineCache"); + table->DestroyPipelineCache = (PFN_vkDestroyPipelineCache) gpa(baseDevice, "vkDestroyPipelineCache"); + table->GetPipelineCacheSize = (PFN_vkGetPipelineCacheSize) gpa(baseDevice, "vkGetPipelineCacheSize"); + table->GetPipelineCacheData = (PFN_vkGetPipelineCacheData) gpa(baseDevice, "vkGetPipelineCacheData"); + table->MergePipelineCaches = (PFN_vkMergePipelineCaches) gpa(baseDevice, "vkMergePipelineCaches"); + table->CreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines) gpa(baseDevice, "vkCreateGraphicsPipelines"); + table->CreateComputePipelines = (PFN_vkCreateComputePipelines) gpa(baseDevice, "vkCreateComputePipelines"); + table->DestroyPipeline = (PFN_vkDestroyPipeline) gpa(baseDevice, "vkDestroyPipeline"); + table->CreatePipelineLayout = (PFN_vkCreatePipelineLayout) gpa(baseDevice, "vkCreatePipelineLayout"); + table->DestroyPipelineLayout = (PFN_vkDestroyPipelineLayout) gpa(baseDevice, "vkDestroyPipelineLayout"); + table->CreateSampler = (PFN_vkCreateSampler) gpa(baseDevice, "vkCreateSampler"); + table->DestroySampler = (PFN_vkDestroySampler) gpa(baseDevice, "vkDestroySampler"); + table->CreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout) gpa(baseDevice, "vkCreateDescriptorSetLayout"); + table->DestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout) gpa(baseDevice, "vkDestroyDescriptorSetLayout"); + table->CreateDescriptorPool = (PFN_vkCreateDescriptorPool) gpa(baseDevice, "vkCreateDescriptorPool"); + table->DestroyDescriptorPool = (PFN_vkDestroyDescriptorPool) gpa(baseDevice, "vkDestroyDescriptorPool"); + table->ResetDescriptorPool = (PFN_vkResetDescriptorPool) gpa(baseDevice, "vkResetDescriptorPool"); + table->AllocDescriptorSets = (PFN_vkAllocDescriptorSets) gpa(baseDevice, "vkAllocDescriptorSets"); + table->FreeDescriptorSets = (PFN_vkFreeDescriptorSets) gpa(baseDevice, "vkFreeDescriptorSets"); + table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) gpa(baseDevice, "vkUpdateDescriptorSets"); + table->CreateDynamicViewportState = (PFN_vkCreateDynamicViewportState) gpa(baseDevice, "vkCreateDynamicViewportState"); + table->DestroyDynamicViewportState = (PFN_vkDestroyDynamicViewportState) gpa(baseDevice, "vkDestroyDynamicViewportState"); + table->CreateDynamicRasterState = (PFN_vkCreateDynamicRasterState) gpa(baseDevice, "vkCreateDynamicRasterState"); + table->DestroyDynamicRasterState = (PFN_vkDestroyDynamicRasterState) gpa(baseDevice, "vkDestroyDynamicRasterState"); + table->CreateDynamicColorBlendState = (PFN_vkCreateDynamicColorBlendState) gpa(baseDevice, "vkCreateDynamicColorBlendState"); + table->DestroyDynamicColorBlendState = (PFN_vkDestroyDynamicColorBlendState) gpa(baseDevice, "vkDestroyDynamicColorBlendState"); + table->CreateDynamicDepthStencilState = (PFN_vkCreateDynamicDepthStencilState) gpa(baseDevice, "vkCreateDynamicDepthStencilState"); + table->DestroyDynamicDepthStencilState = (PFN_vkDestroyDynamicDepthStencilState) gpa(baseDevice, "vkDestroyDynamicDepthStencilState"); + table->CreateCommandPool = (PFN_vkCreateCommandPool) gpa(baseDevice, "vkCreateCommandPool"); + table->DestroyCommandPool = (PFN_vkDestroyCommandPool) gpa(baseDevice, "vkDestroyCommandPool"); + table->ResetCommandPool = (PFN_vkResetCommandPool) gpa(baseDevice, "vkResetCommandPool"); + table->CreateCommandBuffer = (PFN_vkCreateCommandBuffer) gpa(baseDevice, "vkCreateCommandBuffer"); + table->DestroyCommandBuffer = (PFN_vkDestroyCommandBuffer) gpa(baseDevice, "vkDestroyCommandBuffer"); + table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer) gpa(baseDevice, "vkBeginCommandBuffer"); + table->EndCommandBuffer = (PFN_vkEndCommandBuffer) gpa(baseDevice, "vkEndCommandBuffer"); + table->ResetCommandBuffer = (PFN_vkResetCommandBuffer) gpa(baseDevice, "vkResetCommandBuffer"); + table->CmdBindPipeline = (PFN_vkCmdBindPipeline) gpa(baseDevice, "vkCmdBindPipeline"); + table->CmdBindDynamicViewportState = (PFN_vkCmdBindDynamicViewportState) gpa(baseDevice, "vkCmdBindDynamicViewportState"); + table->CmdBindDynamicRasterState = (PFN_vkCmdBindDynamicRasterState) gpa(baseDevice, "vkCmdBindDynamicRasterState"); + table->CmdBindDynamicColorBlendState = (PFN_vkCmdBindDynamicColorBlendState) gpa(baseDevice, "vkCmdBindDynamicColorBlendState"); + table->CmdBindDynamicDepthStencilState = (PFN_vkCmdBindDynamicDepthStencilState) gpa(baseDevice, "vkCmdBindDynamicDepthStencilState"); + table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) gpa(baseDevice, "vkCmdBindDescriptorSets"); + table->CmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer) gpa(baseDevice, "vkCmdBindIndexBuffer"); + table->CmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers) gpa(baseDevice, "vkCmdBindVertexBuffers"); + table->CmdDraw = (PFN_vkCmdDraw) gpa(baseDevice, "vkCmdDraw"); + table->CmdDrawIndexed = (PFN_vkCmdDrawIndexed) gpa(baseDevice, "vkCmdDrawIndexed"); + table->CmdDrawIndirect = (PFN_vkCmdDrawIndirect) gpa(baseDevice, "vkCmdDrawIndirect"); + table->CmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect) gpa(baseDevice, "vkCmdDrawIndexedIndirect"); + table->CmdDispatch = (PFN_vkCmdDispatch) gpa(baseDevice, "vkCmdDispatch"); + table->CmdDispatchIndirect = (PFN_vkCmdDispatchIndirect) gpa(baseDevice, "vkCmdDispatchIndirect"); + table->CmdCopyBuffer = (PFN_vkCmdCopyBuffer) gpa(baseDevice, "vkCmdCopyBuffer"); + table->CmdCopyImage = (PFN_vkCmdCopyImage) gpa(baseDevice, "vkCmdCopyImage"); + table->CmdBlitImage = (PFN_vkCmdBlitImage) gpa(baseDevice, "vkCmdBlitImage"); + table->CmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage) gpa(baseDevice, "vkCmdCopyBufferToImage"); + table->CmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer) gpa(baseDevice, "vkCmdCopyImageToBuffer"); + table->CmdUpdateBuffer = (PFN_vkCmdUpdateBuffer) gpa(baseDevice, "vkCmdUpdateBuffer"); + table->CmdFillBuffer = (PFN_vkCmdFillBuffer) gpa(baseDevice, "vkCmdFillBuffer"); + table->CmdClearColorImage = (PFN_vkCmdClearColorImage) gpa(baseDevice, "vkCmdClearColorImage"); + table->CmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage) gpa(baseDevice, "vkCmdClearDepthStencilImage"); + table->CmdClearColorAttachment = (PFN_vkCmdClearColorAttachment) gpa(baseDevice, "vkCmdClearColorAttachment"); + table->CmdClearDepthStencilAttachment = (PFN_vkCmdClearDepthStencilAttachment) gpa(baseDevice, "vkCmdClearDepthStencilAttachment"); + table->CmdResolveImage = (PFN_vkCmdResolveImage) gpa(baseDevice, "vkCmdResolveImage"); + table->CmdSetEvent = (PFN_vkCmdSetEvent) gpa(baseDevice, "vkCmdSetEvent"); + table->CmdResetEvent = (PFN_vkCmdResetEvent) gpa(baseDevice, "vkCmdResetEvent"); + table->CmdWaitEvents = (PFN_vkCmdWaitEvents) gpa(baseDevice, "vkCmdWaitEvents"); + table->CmdPipelineBarrier = (PFN_vkCmdPipelineBarrier) gpa(baseDevice, "vkCmdPipelineBarrier"); + table->CmdBeginQuery = (PFN_vkCmdBeginQuery) gpa(baseDevice, "vkCmdBeginQuery"); + table->CmdEndQuery = (PFN_vkCmdEndQuery) gpa(baseDevice, "vkCmdEndQuery"); + table->CmdResetQueryPool = (PFN_vkCmdResetQueryPool) gpa(baseDevice, "vkCmdResetQueryPool"); + table->CmdWriteTimestamp = (PFN_vkCmdWriteTimestamp) gpa(baseDevice, "vkCmdWriteTimestamp"); + table->CmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults) gpa(baseDevice, "vkCmdCopyQueryPoolResults"); + table->CreateFramebuffer = (PFN_vkCreateFramebuffer) gpa(baseDevice, "vkCreateFramebuffer"); + table->DestroyFramebuffer = (PFN_vkDestroyFramebuffer) gpa(baseDevice, "vkDestroyFramebuffer"); + table->CreateRenderPass = (PFN_vkCreateRenderPass) gpa(baseDevice, "vkCreateRenderPass"); + table->DestroyRenderPass = (PFN_vkDestroyRenderPass) gpa(baseDevice, "vkDestroyRenderPass"); + table->GetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity) gpa(baseDevice, "vkGetRenderAreaGranularity"); + table->CmdBeginRenderPass = (PFN_vkCmdBeginRenderPass) gpa(baseDevice, "vkCmdBeginRenderPass"); + table->CmdNextSubpass = (PFN_vkCmdNextSubpass) gpa(baseDevice, "vkCmdNextSubpass"); + table->CmdPushConstants = (PFN_vkCmdPushConstants) gpa(baseDevice, "vkCmdPushConstants"); + table->CmdEndRenderPass = (PFN_vkCmdEndRenderPass) gpa(baseDevice, "vkCmdEndRenderPass"); + table->CmdExecuteCommands = (PFN_vkCmdExecuteCommands) gpa(baseDevice, "vkCmdExecuteCommands"); + table->GetSurfaceInfoWSI = (PFN_vkGetSurfaceInfoWSI) gpa(baseDevice, "vkGetSurfaceInfoWSI"); + table->CreateSwapChainWSI = (PFN_vkCreateSwapChainWSI) gpa(baseDevice, "vkCreateSwapChainWSI"); + table->DestroySwapChainWSI = (PFN_vkDestroySwapChainWSI) gpa(baseDevice, "vkDestroySwapChainWSI"); + table->GetSwapChainInfoWSI = (PFN_vkGetSwapChainInfoWSI) gpa(baseDevice, "vkGetSwapChainInfoWSI"); + table->AcquireNextImageWSI = (PFN_vkAcquireNextImageWSI) gpa(baseDevice, "vkAcquireNextImageWSI"); + table->QueuePresentWSI = (PFN_vkQueuePresentWSI) gpa(baseDevice, "vkQueuePresentWSI"); +} + +static inline void layer_init_instance_dispatch_table(VkLayerInstanceDispatchTable *table, + const VkBaseLayerObject *instw) +{ + VkInstance instance = (VkInstance) instw->nextObject; + PFN_vkGetInstanceProcAddr gpa = (PFN_vkGetInstanceProcAddr) instw->pGPA; + VkInstance baseInstance = (VkInstance) instw->baseObject; + // GPA has to be first entry inited and uses wrapped object since it triggers init + memset(table, 0, sizeof(*table)); + table->GetInstanceProcAddr =(PFN_vkGetInstanceProcAddr) gpa(instance,"vkGetInstanceProcAddr"); + table->CreateInstance = (PFN_vkCreateInstance) gpa(baseInstance, "vkCreateInstance"); + table->DestroyInstance = (PFN_vkDestroyInstance) gpa(baseInstance, "vkDestroyInstance"); + table->EnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices) gpa(baseInstance, "vkEnumeratePhysicalDevices"); + table->GetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures) gpa(baseInstance, "vkGetPhysicalDeviceFeatures"); + table->GetPhysicalDeviceFormatProperties = (PFN_vkGetPhysicalDeviceFormatProperties) gpa(baseInstance, "vkGetPhysicalDeviceFormatProperties"); + table->GetPhysicalDeviceImageFormatProperties = (PFN_vkGetPhysicalDeviceImageFormatProperties) gpa(baseInstance, "vkGetPhysicalDeviceImageFormatProperties"); + table->GetPhysicalDeviceLimits = (PFN_vkGetPhysicalDeviceLimits) gpa(baseInstance, "vkGetPhysicalDeviceLimits"); + table->GetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties) gpa(baseInstance, "vkGetPhysicalDeviceProperties"); + table->GetPhysicalDeviceQueueCount = (PFN_vkGetPhysicalDeviceQueueCount) gpa(baseInstance, "vkGetPhysicalDeviceQueueCount"); + table->GetPhysicalDeviceQueueProperties = (PFN_vkGetPhysicalDeviceQueueProperties) gpa(baseInstance, "vkGetPhysicalDeviceQueueProperties"); + table->GetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties) gpa(baseInstance, "vkGetPhysicalDeviceMemoryProperties"); + table->GetPhysicalDeviceExtensionProperties = (PFN_vkGetPhysicalDeviceExtensionProperties) gpa(baseInstance, "vkGetPhysicalDeviceExtensionProperties"); + table->GetPhysicalDeviceLayerProperties = (PFN_vkGetPhysicalDeviceLayerProperties) gpa(baseInstance, "vkGetPhysicalDeviceLayerProperties"); + table->GetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties) gpa(baseInstance, "vkGetPhysicalDeviceSparseImageFormatProperties"); + table->GetPhysicalDeviceSurfaceSupportWSI = (PFN_vkGetPhysicalDeviceSurfaceSupportWSI) gpa(baseInstance, "vkGetPhysicalDeviceSurfaceSupportWSI"); +} diff --git a/renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_marker_layer.h b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_marker_layer.h new file mode 100644 index 000000000..d9b1d7da5 --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_marker_layer.h @@ -0,0 +1,45 @@ +// +// File: vk_debug_marker_lunarg.h +// +/* +** Copyright (c) 2015 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +** +** Authors: +** Jon Ashburn +** Courtney Goeltzenleuchter +*/ + +#pragma once + +#include "vulkan.h" +#include "vk_debug_marker_lunarg.h" +#include "vk_layer.h" + + +typedef struct VkLayerDebugMarkerDispatchTable_ +{ + + PFN_vkCmdDbgMarkerBegin CmdDbgMarkerBegin; + PFN_vkCmdDbgMarkerEnd CmdDbgMarkerEnd; + PFN_vkDbgSetObjectTag DbgSetObjectTag; + PFN_vkDbgSetObjectName DbgSetObjectName; +} VkLayerDebugMarkerDispatchTable; diff --git a/renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_marker_lunarg.h b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_marker_lunarg.h new file mode 100644 index 000000000..526778f5e --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_marker_lunarg.h @@ -0,0 +1,98 @@ +// +// File: vk_debug_marker_lunarg.h +// +/* +** Copyright (c) 2015 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +** +** Authors: +** Jon Ashburn +** Courtney Goeltzenleuchter +*/ + +#ifndef __VK_DEBUG_MARKER_H__ +#define __VK_DEBUG_MARKER_H__ + +#include "vulkan.h" +#include "vk_debug_report_lunarg.h" + +#define VK_DEBUG_MARKER_EXTENSION_NUMBER 3 +#define VK_DEBUG_MARKER_EXTENSION_VERSION VK_MAKE_VERSION(0, 1, 0) +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +/* +*************************************************************************************************** +* DebugMarker Vulkan Extension API +*************************************************************************************************** +*/ + +#define DEBUG_MARKER_EXTENSION_NAME "DEBUG_MARKER" + +// ------------------------------------------------------------------------------------------------ +// Enumerations + +#define VK_DEBUG_MARKER_ENUM_EXTEND(type, id) ((type)(VK_DEBUG_MARKER_EXTENSION_NUMBER * -1000 + (id))) + +#define VK_OBJECT_INFO_TYPE_DBG_OBJECT_TAG VK_DEBUG_MARKER_ENUM_EXTEND(VkDbgObjectInfoType, 0) +#define VK_OBJECT_INFO_TYPE_DBG_OBJECT_NAME VK_DEBUG_MARKER_ENUM_EXTEND(VkDbgObjectInfoType, 1) + +// ------------------------------------------------------------------------------------------------ +// API functions + +typedef void (VKAPI *PFN_vkCmdDbgMarkerBegin)(VkCmdBuffer cmdBuffer, const char* pMarker); +typedef void (VKAPI *PFN_vkCmdDbgMarkerEnd)(VkCmdBuffer cmdBuffer); +typedef VkResult (VKAPI *PFN_vkDbgSetObjectTag)(VkDevice device, VkDbgObjectType objType, uint64_t object, size_t tagSize, const void* pTag); +typedef VkResult (VKAPI *PFN_vkDbgSetObjectName)(VkDevice device, VkDbgObjectType objType, uint64_t object, size_t nameSize, const char* pName); + +#ifdef VK_PROTOTYPES + +// DebugMarker extension entrypoints +void VKAPI vkCmdDbgMarkerBegin( + VkCmdBuffer cmdBuffer, + const char* pMarker); + +void VKAPI vkCmdDbgMarkerEnd( + VkCmdBuffer cmdBuffer); + +VkResult VKAPI vkDbgSetObjectTag( + VkDevice device, + VkDbgObjectType objType, + uint64_t object, + size_t tagSize, + const void* pTag); + +VkResult VKAPI vkDbgSetObjectName( + VkDevice device, + VkDbgObjectType objType, + uint64_t object, + size_t nameSize, + const char* pName); + +#endif // VK_PROTOTYPES + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif // __VK_DEBUG_MARKER_H__ diff --git a/renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_report_lunarg.h b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_report_lunarg.h new file mode 100644 index 000000000..633b50da9 --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_debug_report_lunarg.h @@ -0,0 +1,256 @@ +// +// File: vk_debug_report_lunarg.h +// +/* + * Vulkan + * + * Copyright (C) 2015 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Jon Ashburn + * Courtney Goeltzenleuchter + */ + +#ifndef __VK_DEBUG_REPORT_LUNARG_H__ +#define __VK_DEBUG_REPORT_LUNARG_H__ + +#include "vulkan.h" + +#define VK_DEBUG_REPORT_EXTENSION_NUMBER 2 +#define VK_DEBUG_REPORT_EXTENSION_VERSION VK_MAKE_VERSION(0, 1, 0) +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +/* +*************************************************************************************************** +* DebugReport Vulkan Extension API +*************************************************************************************************** +*/ +typedef enum { + VK_OBJECT_TYPE_INSTANCE = 0, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 1, + VK_OBJECT_TYPE_DEVICE = 2, + VK_OBJECT_TYPE_QUEUE = 3, + VK_OBJECT_TYPE_COMMAND_BUFFER = 4, + VK_OBJECT_TYPE_DEVICE_MEMORY = 5, + VK_OBJECT_TYPE_BUFFER = 6, + VK_OBJECT_TYPE_BUFFER_VIEW = 7, + VK_OBJECT_TYPE_IMAGE = 8, + VK_OBJECT_TYPE_IMAGE_VIEW = 9, + VK_OBJECT_TYPE_ATTACHMENT_VIEW = 10, + VK_OBJECT_TYPE_SHADER_MODULE = 12, + VK_OBJECT_TYPE_SHADER = 13, + VK_OBJECT_TYPE_PIPELINE = 14, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 15, + VK_OBJECT_TYPE_SAMPLER = 16, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 17, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 18, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 19, + VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE = 20, + VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE = 21, + VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE = 22, + VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE = 23, + VK_OBJECT_TYPE_FENCE = 24, + VK_OBJECT_TYPE_SEMAPHORE = 25, + VK_OBJECT_TYPE_EVENT = 26, + VK_OBJECT_TYPE_QUERY_POOL = 27, + VK_OBJECT_TYPE_FRAMEBUFFER = 28, + VK_OBJECT_TYPE_RENDER_PASS = 29, + VK_OBJECT_TYPE_PIPELINE_CACHE = 30, + VK_OBJECT_TYPE_SWAP_CHAIN_WSI = 31, + VK_OBJECT_TYPE_CMD_POOL = 32, + VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_INSTANCE, + VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_CMD_POOL, + VK_OBJECT_TYPE_NUM = (VK_OBJECT_TYPE_CMD_POOL - VK_OBJECT_TYPE_INSTANCE + 1), + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDbgObjectType; + +static inline const char* string_VkDbgObjectType(VkDbgObjectType input_value) +{ + switch ((VkDbgObjectType)input_value) + { + case VK_OBJECT_TYPE_CMD_POOL: + return "VK_OBJECT_TYPE_CMD_POOL"; + case VK_OBJECT_TYPE_BUFFER: + return "VK_OBJECT_TYPE_BUFFER"; + case VK_OBJECT_TYPE_BUFFER_VIEW: + return "VK_OBJECT_TYPE_BUFFER_VIEW"; + case VK_OBJECT_TYPE_ATTACHMENT_VIEW: + return "VK_OBJECT_TYPE_ATTACHMENT_VIEW"; + case VK_OBJECT_TYPE_COMMAND_BUFFER: + return "VK_OBJECT_TYPE_COMMAND_BUFFER"; + case VK_OBJECT_TYPE_DESCRIPTOR_POOL: + return "VK_OBJECT_TYPE_DESCRIPTOR_POOL"; + case VK_OBJECT_TYPE_DESCRIPTOR_SET: + return "VK_OBJECT_TYPE_DESCRIPTOR_SET"; + case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: + return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT"; + case VK_OBJECT_TYPE_DEVICE: + return "VK_OBJECT_TYPE_DEVICE"; + case VK_OBJECT_TYPE_DEVICE_MEMORY: + return "VK_OBJECT_TYPE_DEVICE_MEMORY"; + case VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE: + return "VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE"; + case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE: + return "VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE"; + case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE: + return "VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE"; + case VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE: + return "VK_OBJECT_TYPE_DYNAMIC_VIEPORT_STATE"; + case VK_OBJECT_TYPE_EVENT: + return "VK_OBJECT_TYPE_EVENT"; + case VK_OBJECT_TYPE_FENCE: + return "VK_OBJECT_TYPE_FENCE"; + case VK_OBJECT_TYPE_FRAMEBUFFER: + return "VK_OBJECT_TYPE_FRAMEBUFFER"; + case VK_OBJECT_TYPE_IMAGE: + return "VK_OBJECT_TYPE_IMAGE"; + case VK_OBJECT_TYPE_IMAGE_VIEW: + return "VK_OBJECT_TYPE_IMAGE_VIEW"; + case VK_OBJECT_TYPE_INSTANCE: + return "VK_OBJECT_TYPE_INSTANCE"; + case VK_OBJECT_TYPE_PHYSICAL_DEVICE: + return "VK_OBJECT_TYPE_PHYSICAL_DEVICE"; + case VK_OBJECT_TYPE_PIPELINE: + return "VK_OBJECT_TYPE_PIPELINE"; + case VK_OBJECT_TYPE_PIPELINE_LAYOUT: + return "VK_OBJECT_TYPE_PIPELINE_LAYOUT"; + case VK_OBJECT_TYPE_PIPELINE_CACHE: + return "VK_OBJECT_TYPE_PIPELINE_CACHE"; + case VK_OBJECT_TYPE_QUERY_POOL: + return "VK_OBJECT_TYPE_QUERY_POOL"; + case VK_OBJECT_TYPE_QUEUE: + return "VK_OBJECT_TYPE_QUEUE"; + case VK_OBJECT_TYPE_RENDER_PASS: + return "VK_OBJECT_TYPE_RENDER_PASS"; + case VK_OBJECT_TYPE_SAMPLER: + return "VK_OBJECT_TYPE_SAMPLER"; + case VK_OBJECT_TYPE_SEMAPHORE: + return "VK_OBJECT_TYPE_SEMAPHORE"; + case VK_OBJECT_TYPE_SHADER: + return "VK_OBJECT_TYPE_SHADER"; + case VK_OBJECT_TYPE_SHADER_MODULE: + return "VK_OBJECT_TYPE_SHADER_MODULE"; + case VK_OBJECT_TYPE_SWAP_CHAIN_WSI: + return "VK_OBJECT_TYPE_SWAP_CHAIN_WSI"; + default: + return "Unhandled VkObjectType"; + } +} +#define VK_DEBUG_REPORT_EXTENSION_NAME "DEBUG_REPORT" + +VK_DEFINE_NONDISP_HANDLE(VkDbgMsgCallback) + +// ------------------------------------------------------------------------------------------------ +// Enumerations + +typedef enum VkDbgReportFlags_ +{ + VK_DBG_REPORT_INFO_BIT = 0x0001, + VK_DBG_REPORT_WARN_BIT = 0x0002, + VK_DBG_REPORT_PERF_WARN_BIT = 0x0004, + VK_DBG_REPORT_ERROR_BIT = 0x0008, + VK_DBG_REPORT_DEBUG_BIT = 0x0010, +} VkDbgReportFlags; + +// Debug Report ERROR codes +typedef enum _DEBUG_REPORT_ERROR +{ + DEBUG_REPORT_NONE, // Used for INFO & other non-error messages + DEBUG_REPORT_CALLBACK_REF, // Callbacks were not destroyed prior to calling DestroyInstance +} DEBUG_REPORT_ERROR; + +#define VK_DEBUG_REPORT_ENUM_EXTEND(type, id) ((type)(VK_DEBUG_REPORT_EXTENSION_NUMBER * -1000 + (id))) + +#define VK_OBJECT_TYPE_MSG_CALLBACK VK_DEBUG_REPORT_ENUM_EXTEND(VkDbgObjectType, 0) +// ------------------------------------------------------------------------------------------------ +// Vulkan function pointers + +typedef void (*PFN_vkDbgMsgCallback)( + VkFlags msgFlags, + VkDbgObjectType objType, + uint64_t srcObject, + size_t location, + int32_t msgCode, + const char* pLayerPrefix, + const char* pMsg, + void* pUserData); + +// ------------------------------------------------------------------------------------------------ +// API functions + +typedef VkResult (VKAPI *PFN_vkDbgCreateMsgCallback)(VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, const void* pUserData, VkDbgMsgCallback* pMsgCallback); +typedef VkResult (VKAPI *PFN_vkDbgDestroyMsgCallback)(VkInstance instance, VkDbgMsgCallback msgCallback); + +#ifdef VK_PROTOTYPES + +// DebugReport extension entrypoints +VkResult VKAPI vkDbgCreateMsgCallback( + VkInstance instance, + VkFlags msgFlags, + const PFN_vkDbgMsgCallback pfnMsgCallback, + void* pUserData, + VkDbgMsgCallback* pMsgCallback); + +VkResult VKAPI vkDbgDestroyMsgCallback( + VkInstance instance, + VkDbgMsgCallback msgCallback); + +// DebugReport utility callback functions +void VKAPI vkDbgStringCallback( + VkFlags msgFlags, + VkDbgObjectType objType, + uint64_t srcObject, + size_t location, + int32_t msgCode, + const char* pLayerPrefix, + const char* pMsg, + void* pUserData); + +void VKAPI vkDbgStdioCallback( + VkFlags msgFlags, + VkDbgObjectType objType, + uint64_t srcObject, + size_t location, + int32_t msgCode, + const char* pLayerPrefix, + const char* pMsg, + void* pUserData); + +void VKAPI vkDbgBreakCallback( + VkFlags msgFlags, + VkDbgObjectType objType, + uint64_t srcObject, + size_t location, + int32_t msgCode, + const char* pLayerPrefix, + const char* pMsg, + void* pUserData); + +#endif // VK_PROTOTYPES + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif // __VK_DEBUG_REPORT_LUNARG_H__ diff --git a/renderdoc/driver/vulkan/LoaderAndTools/include/vk_icd.h b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_icd.h new file mode 100644 index 000000000..cea46be78 --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_icd.h @@ -0,0 +1,32 @@ +#ifndef VKICD_H +#define VKICD_H + +#include +#include +#include "vk_platform.h" + +/* + * The ICD must reserve space for a pointer for the loader's dispatch + * table, at the start of . + * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro. + */ + +#define ICD_LOADER_MAGIC 0x01CDC0DE + +typedef union _VK_LOADER_DATA { + uintptr_t loaderMagic; + void *loaderData; +} VK_LOADER_DATA; + +static inline void set_loader_magic_value(void* pNewObject) { + VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *) pNewObject; + loader_info->loaderMagic = ICD_LOADER_MAGIC; +} + +static inline bool valid_loader_magic_value(void* pNewObject) { + const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *) pNewObject; + return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC; +} + +#endif // VKICD_H + diff --git a/renderdoc/driver/vulkan/LoaderAndTools/include/vk_layer.h b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_layer.h new file mode 100644 index 000000000..30cc07fab --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_layer.h @@ -0,0 +1,217 @@ +/* Need to define dispatch table + * Core struct can then have ptr to dispatch table at the top + * Along with object ptrs for current and next OBJ + */ +#pragma once + +#include "vulkan.h" +#include "vk_debug_report_lunarg.h" +#include "vk_debug_marker_lunarg.h" +#include "vk_wsi_swapchain.h" +#include "vk_wsi_device_swapchain.h" +#if defined(__GNUC__) && __GNUC__ >= 4 +# define VK_LAYER_EXPORT __attribute__((visibility("default"))) +#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) +# define VK_LAYER_EXPORT __attribute__((visibility("default"))) +#else +# define VK_LAYER_EXPORT +#endif + +typedef void * (*PFN_vkGPA)(void* obj, const char * pName); + +typedef struct VkBaseLayerObject_ +{ + PFN_vkGPA pGPA; + void* nextObject; + void* baseObject; +} VkBaseLayerObject; + +typedef struct VkLayerDispatchTable_ +{ + PFN_vkGetDeviceProcAddr GetDeviceProcAddr; + PFN_vkCreateDevice CreateDevice; + PFN_vkDestroyDevice DestroyDevice; + PFN_vkGetDeviceQueue GetDeviceQueue; + PFN_vkQueueSubmit QueueSubmit; + PFN_vkQueueWaitIdle QueueWaitIdle; + PFN_vkDeviceWaitIdle DeviceWaitIdle; + PFN_vkAllocMemory AllocMemory; + PFN_vkFreeMemory FreeMemory; + PFN_vkMapMemory MapMemory; + PFN_vkUnmapMemory UnmapMemory; + PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges; + PFN_vkInvalidateMappedMemoryRanges InvalidateMappedMemoryRanges; + PFN_vkGetDeviceMemoryCommitment GetDeviceMemoryCommitment; + PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements; + PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements; + PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements; + PFN_vkBindImageMemory BindImageMemory; + PFN_vkBindBufferMemory BindBufferMemory; + PFN_vkQueueBindSparseBufferMemory QueueBindSparseBufferMemory; + PFN_vkQueueBindSparseImageOpaqueMemory QueueBindSparseImageOpaqueMemory; + PFN_vkQueueBindSparseImageMemory QueueBindSparseImageMemory; + PFN_vkCreateFence CreateFence; + PFN_vkDestroyFence DestroyFence; + PFN_vkGetFenceStatus GetFenceStatus; + PFN_vkResetFences ResetFences; + PFN_vkWaitForFences WaitForFences; + PFN_vkCreateSemaphore CreateSemaphore; + PFN_vkDestroySemaphore DestroySemaphore; + PFN_vkQueueSignalSemaphore QueueSignalSemaphore; + PFN_vkQueueWaitSemaphore QueueWaitSemaphore; + PFN_vkCreateEvent CreateEvent; + PFN_vkDestroyEvent DestroyEvent; + PFN_vkGetEventStatus GetEventStatus; + PFN_vkSetEvent SetEvent; + PFN_vkResetEvent ResetEvent; + PFN_vkCreateQueryPool CreateQueryPool; + PFN_vkDestroyQueryPool DestroyQueryPool; + PFN_vkGetQueryPoolResults GetQueryPoolResults; + PFN_vkCreateBuffer CreateBuffer; + PFN_vkDestroyBuffer DestroyBuffer; + PFN_vkCreateBufferView CreateBufferView; + PFN_vkDestroyBufferView DestroyBufferView; + PFN_vkCreateImage CreateImage; + PFN_vkDestroyImage DestroyImage; + PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout; + PFN_vkCreateImageView CreateImageView; + PFN_vkDestroyImageView DestroyImageView; + PFN_vkCreateAttachmentView CreateAttachmentView; + PFN_vkDestroyAttachmentView DestroyAttachmentView; + PFN_vkCreateShaderModule CreateShaderModule; + PFN_vkDestroyShaderModule DestroyShaderModule; + PFN_vkCreateShader CreateShader; + PFN_vkDestroyShader DestroyShader; + PFN_vkCreatePipelineCache CreatePipelineCache; + PFN_vkDestroyPipelineCache DestroyPipelineCache; + PFN_vkGetPipelineCacheSize GetPipelineCacheSize; + PFN_vkGetPipelineCacheData GetPipelineCacheData; + PFN_vkMergePipelineCaches MergePipelineCaches; + PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines; + PFN_vkCreateComputePipelines CreateComputePipelines; + PFN_vkDestroyPipeline DestroyPipeline; + PFN_vkCreatePipelineLayout CreatePipelineLayout; + PFN_vkDestroyPipelineLayout DestroyPipelineLayout; + PFN_vkCreateSampler CreateSampler; + PFN_vkDestroySampler DestroySampler; + PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout; + PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout; + PFN_vkCreateDescriptorPool CreateDescriptorPool; + PFN_vkDestroyDescriptorPool DestroyDescriptorPool; + PFN_vkResetDescriptorPool ResetDescriptorPool; + PFN_vkAllocDescriptorSets AllocDescriptorSets; + PFN_vkFreeDescriptorSets FreeDescriptorSets; + PFN_vkUpdateDescriptorSets UpdateDescriptorSets; + PFN_vkCreateDynamicViewportState CreateDynamicViewportState; + PFN_vkDestroyDynamicViewportState DestroyDynamicViewportState; + PFN_vkCreateDynamicRasterState CreateDynamicRasterState; + PFN_vkDestroyDynamicRasterState DestroyDynamicRasterState; + PFN_vkCreateDynamicColorBlendState CreateDynamicColorBlendState; + PFN_vkDestroyDynamicColorBlendState DestroyDynamicColorBlendState; + PFN_vkCreateDynamicDepthStencilState CreateDynamicDepthStencilState; + PFN_vkDestroyDynamicDepthStencilState DestroyDynamicDepthStencilState; + PFN_vkCreateFramebuffer CreateFramebuffer; + PFN_vkDestroyFramebuffer DestroyFramebuffer; + PFN_vkCreateRenderPass CreateRenderPass; + PFN_vkDestroyRenderPass DestroyRenderPass; + PFN_vkGetRenderAreaGranularity GetRenderAreaGranularity; + PFN_vkCreateCommandPool CreateCommandPool; + PFN_vkDestroyCommandPool DestroyCommandPool; + PFN_vkResetCommandPool ResetCommandPool; + PFN_vkCreateCommandBuffer CreateCommandBuffer; + PFN_vkDestroyCommandBuffer DestroyCommandBuffer; + PFN_vkBeginCommandBuffer BeginCommandBuffer; + PFN_vkEndCommandBuffer EndCommandBuffer; + PFN_vkResetCommandBuffer ResetCommandBuffer; + PFN_vkCmdBindPipeline CmdBindPipeline; + PFN_vkCmdBindDynamicViewportState CmdBindDynamicViewportState; + PFN_vkCmdBindDynamicRasterState CmdBindDynamicRasterState; + PFN_vkCmdBindDynamicColorBlendState CmdBindDynamicColorBlendState; + PFN_vkCmdBindDynamicDepthStencilState CmdBindDynamicDepthStencilState; + PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets; + PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers; + PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer; + PFN_vkCmdDraw CmdDraw; + PFN_vkCmdDrawIndexed CmdDrawIndexed; + PFN_vkCmdDrawIndirect CmdDrawIndirect; + PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect; + PFN_vkCmdDispatch CmdDispatch; + PFN_vkCmdDispatchIndirect CmdDispatchIndirect; + PFN_vkCmdCopyBuffer CmdCopyBuffer; + PFN_vkCmdCopyImage CmdCopyImage; + PFN_vkCmdBlitImage CmdBlitImage; + PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage; + PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer; + PFN_vkCmdUpdateBuffer CmdUpdateBuffer; + PFN_vkCmdFillBuffer CmdFillBuffer; + PFN_vkCmdClearColorImage CmdClearColorImage; + PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage; + PFN_vkCmdClearColorAttachment CmdClearColorAttachment; + PFN_vkCmdClearDepthStencilAttachment CmdClearDepthStencilAttachment; + PFN_vkCmdResolveImage CmdResolveImage; + PFN_vkCmdSetEvent CmdSetEvent; + PFN_vkCmdResetEvent CmdResetEvent; + PFN_vkCmdWaitEvents CmdWaitEvents; + PFN_vkCmdPipelineBarrier CmdPipelineBarrier; + PFN_vkCmdBeginQuery CmdBeginQuery; + PFN_vkCmdEndQuery CmdEndQuery; + PFN_vkCmdResetQueryPool CmdResetQueryPool; + PFN_vkCmdWriteTimestamp CmdWriteTimestamp; + PFN_vkCmdCopyQueryPoolResults CmdCopyQueryPoolResults; + PFN_vkCmdPushConstants CmdPushConstants; + PFN_vkCmdBeginRenderPass CmdBeginRenderPass; + PFN_vkCmdNextSubpass CmdNextSubpass; + PFN_vkCmdEndRenderPass CmdEndRenderPass; + PFN_vkCmdExecuteCommands CmdExecuteCommands; + PFN_vkGetSurfaceInfoWSI GetSurfaceInfoWSI; + PFN_vkCreateSwapChainWSI CreateSwapChainWSI; + PFN_vkDestroySwapChainWSI DestroySwapChainWSI; + PFN_vkGetSwapChainInfoWSI GetSwapChainInfoWSI; + PFN_vkAcquireNextImageWSI AcquireNextImageWSI; + PFN_vkQueuePresentWSI QueuePresentWSI; + PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback; + PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback; +} VkLayerDispatchTable; + +typedef struct VkLayerInstanceDispatchTable_ +{ + PFN_vkGetInstanceProcAddr GetInstanceProcAddr; + PFN_vkCreateInstance CreateInstance; + PFN_vkDestroyInstance DestroyInstance; + PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices; + PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures; + PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties; + PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties; + PFN_vkGetPhysicalDeviceLimits GetPhysicalDeviceLimits; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties; + PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties; + PFN_vkGetPhysicalDeviceQueueCount GetPhysicalDeviceQueueCount; + PFN_vkGetPhysicalDeviceQueueProperties GetPhysicalDeviceQueueProperties; + PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties; + PFN_vkGetPhysicalDeviceExtensionProperties GetPhysicalDeviceExtensionProperties; + PFN_vkGetPhysicalDeviceLayerProperties GetPhysicalDeviceLayerProperties; + PFN_vkGetPhysicalDeviceSurfaceSupportWSI GetPhysicalDeviceSurfaceSupportWSI; + PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback; + PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback; +} VkLayerInstanceDispatchTable; + +// LL node for tree of dbg callback functions +typedef struct VkLayerDbgFunctionNode_ +{ + VkDbgMsgCallback msgCallback; + PFN_vkDbgMsgCallback pfnMsgCallback; + VkFlags msgFlags; + const void *pUserData; + struct VkLayerDbgFunctionNode_ *pNext; +} VkLayerDbgFunctionNode; + +typedef enum VkLayerDbgAction_ +{ + VK_DBG_LAYER_ACTION_IGNORE = 0x0, + VK_DBG_LAYER_ACTION_CALLBACK = 0x1, + VK_DBG_LAYER_ACTION_LOG_MSG = 0x2, + VK_DBG_LAYER_ACTION_BREAK = 0x4 +} VkLayerDbgAction; + +// ------------------------------------------------------------------------------------------------ +// API functions diff --git a/renderdoc/driver/vulkan/LoaderAndTools/include/vk_platform.h b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_platform.h new file mode 100644 index 000000000..8832097ac --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_platform.h @@ -0,0 +1,99 @@ +// +// File: vk_platform.h +// +/* +** Copyright (c) 2014-2015 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + + +#ifndef __VK_PLATFORM_H__ +#define __VK_PLATFORM_H__ + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +/* +*************************************************************************************************** +* Platform-specific directives and type declarations +*************************************************************************************************** +*/ + +#if defined(_WIN32) + // Ensure we don't pick up min/max macros from Winddef.h + #define NOMINMAX + + // On Windows, VKAPI should equate to the __stdcall convention + #define VKAPI __stdcall + + // C99: +#ifndef __cplusplus + #undef inline + #define inline __inline +#endif // __cplusplus +#elif defined(__GNUC__) + // On other platforms using GCC, VKAPI stays undefined + #define VKAPI +#else + // Unsupported Platform! + #error "Unsupported OS Platform detected!" +#endif + +#include + +#if !defined(VK_NO_STDINT_H) + #if defined(_MSC_VER) && (_MSC_VER < 1600) + typedef signed __int8 int8_t; + typedef unsigned __int8 uint8_t; + typedef signed __int16 int16_t; + typedef unsigned __int16 uint16_t; + typedef signed __int32 int32_t; + typedef unsigned __int32 uint32_t; + typedef signed __int64 int64_t; + typedef unsigned __int64 uint64_t; + #else + #include + #endif +#endif // !defined(VK_NO_STDINT_H) + +typedef uint64_t VkDeviceSize; +typedef uint32_t VkBool32; + +typedef uint32_t VkSampleMask; +typedef uint32_t VkFlags; + +#if (UINTPTR_MAX >= UINT64_MAX) + #define VK_UINTPTRLEAST64_MAX UINTPTR_MAX + + typedef uintptr_t VkUintPtrLeast64; +#else + #define VK_UINTPTRLEAST64_MAX UINT64_MAX + + typedef uint64_t VkUintPtrLeast64; +#endif + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif // __VK_PLATFORM_H__ diff --git a/renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_device_swapchain.h b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_device_swapchain.h new file mode 100644 index 000000000..c6e4db278 --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_device_swapchain.h @@ -0,0 +1,249 @@ +// +// File: vk_wsi_device_swapchain.h +// +/* +** Copyright (c) 2014 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __VK_WSI_DEVICE_SWAPCHAIN_H__ +#define __VK_WSI_DEVICE_SWAPCHAIN_H__ + +#include "vulkan.h" + +#define VK_WSI_DEVICE_SWAPCHAIN_REVISION 40 +#define VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NUMBER 2 +#define VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NAME "VK_WSI_device_swapchain" + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +// ------------------------------------------------------------------------------------------------ +// Objects + +VK_DEFINE_NONDISP_HANDLE(VkSwapChainWSI); + +// ------------------------------------------------------------------------------------------------ +// Enumeration constants + +#define VK_WSI_DEVICE_SWAPCHAIN_ENUM(type,id) ((type)((int)0xc0000000 - VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NUMBER * -1024 + (id))) +#define VK_WSI_DEVICE_SWAPCHAIN_ENUM_POSITIVE(type,id) ((type)((int)0x40000000 + (VK_WSI_DEVICE_SWAPCHAIN_EXTENSION_NUMBER - 1) * 1024 + (id))) + +// Extend VkStructureType enum with extension specific constants +#define VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI VK_WSI_DEVICE_SWAPCHAIN_ENUM(VkStructureType, 0) +#define VK_STRUCTURE_TYPE_QUEUE_PRESENT_INFO_WSI VK_WSI_DEVICE_SWAPCHAIN_ENUM(VkStructureType, 1) + +// Extend VkImageLayout enum with extension specific constants +#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_WSI VK_WSI_DEVICE_SWAPCHAIN_ENUM(VkImageLayout, 2) + +// Extend VkResult enum with extension specific constants +// Return codes for successful operation execution +#define VK_SUBOPTIMAL_WSI VK_WSI_DEVICE_SWAPCHAIN_ENUM_POSITIVE(VkResult, 3) +// Error codes +#define VK_ERROR_OUT_OF_DATE_WSI VK_WSI_DEVICE_SWAPCHAIN_ENUM(VkResult, 4) + +// ------------------------------------------------------------------------------------------------ +// Enumerations + +typedef enum VkSurfaceTransformWSI_ +{ + VK_SURFACE_TRANSFORM_NONE_WSI = 0, + VK_SURFACE_TRANSFORM_ROT90_WSI = 1, + VK_SURFACE_TRANSFORM_ROT180_WSI = 2, + VK_SURFACE_TRANSFORM_ROT270_WSI = 3, + VK_SURFACE_TRANSFORM_HMIRROR_WSI = 4, + VK_SURFACE_TRANSFORM_HMIRROR_ROT90_WSI = 5, + VK_SURFACE_TRANSFORM_HMIRROR_ROT180_WSI = 6, + VK_SURFACE_TRANSFORM_HMIRROR_ROT270_WSI = 7, + VK_SURFACE_TRANSFORM_INHERIT_WSI = 8, +} VkSurfaceTransformWSI; + +typedef enum VkSurfaceTransformFlagBitsWSI_ +{ + VK_SURFACE_TRANSFORM_NONE_BIT_WSI = 0x00000001, + VK_SURFACE_TRANSFORM_ROT90_BIT_WSI = 0x00000002, + VK_SURFACE_TRANSFORM_ROT180_BIT_WSI = 0x00000004, + VK_SURFACE_TRANSFORM_ROT270_BIT_WSI = 0x00000008, + VK_SURFACE_TRANSFORM_HMIRROR_BIT_WSI = 0x00000010, + VK_SURFACE_TRANSFORM_HMIRROR_ROT90_BIT_WSI = 0x00000020, + VK_SURFACE_TRANSFORM_HMIRROR_ROT180_BIT_WSI = 0x00000040, + VK_SURFACE_TRANSFORM_HMIRROR_ROT270_BIT_WSI = 0x00000080, + VK_SURFACE_TRANSFORM_INHERIT_BIT_WSI = 0x00000100, +} VkSurfaceTransformFlagBitsWSI; +typedef VkFlags VkSurfaceTransformFlagsWSI; + +typedef enum VkSurfaceInfoTypeWSI_ +{ + VK_SURFACE_INFO_TYPE_PROPERTIES_WSI = 0, + VK_SURFACE_INFO_TYPE_FORMATS_WSI = 1, + VK_SURFACE_INFO_TYPE_PRESENT_MODES_WSI = 2, + VK_SURFACE_INFO_TYPE_BEGIN_RANGE_WSI = VK_SURFACE_INFO_TYPE_PROPERTIES_WSI, + VK_SURFACE_INFO_TYPE_END_RANGE_WSI = VK_SURFACE_INFO_TYPE_PRESENT_MODES_WSI, + VK_SURFACE_INFO_TYPE_NUM_WSI = (VK_SURFACE_INFO_TYPE_PRESENT_MODES_WSI - VK_SURFACE_INFO_TYPE_PROPERTIES_WSI + 1), + VK_SURFACE_INFO_TYPE_MAX_ENUM_WSI = 0x7FFFFFFF +} VkSurfaceInfoTypeWSI; + +typedef enum VkSwapChainInfoTypeWSI_ +{ + VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI = 0, + VK_SWAP_CHAIN_INFO_TYPE_BEGIN_RANGE_WSI = VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, + VK_SWAP_CHAIN_INFO_TYPE_END_RANGE_WSI = VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, + VK_SWAP_CHAIN_INFO_TYPE_NUM_WSI = (VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI - VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI + 1), + VK_SWAP_CHAIN_INFO_TYPE_MAX_ENUM_WSI = 0x7FFFFFFF +} VkSwapChainInfoTypeWSI; + +typedef enum VkPresentModeWSI_ +{ + VK_PRESENT_MODE_IMMEDIATE_WSI = 0, + VK_PRESENT_MODE_MAILBOX_WSI = 1, + VK_PRESENT_MODE_FIFO_WSI = 2, + VK_PRESENT_MODE_BEGIN_RANGE_WSI = VK_PRESENT_MODE_IMMEDIATE_WSI, + VK_PRESENT_MODE_END_RANGE_WSI = VK_PRESENT_MODE_FIFO_WSI, + VK_PRESENT_MODE_NUM = (VK_PRESENT_MODE_FIFO_WSI - VK_PRESENT_MODE_IMMEDIATE_WSI + 1), + VK_PRESENT_MODE_MAX_ENUM_WSI = 0x7FFFFFFF +} VkPresentModeWSI; + +// ------------------------------------------------------------------------------------------------ +// Flags + +// ------------------------------------------------------------------------------------------------ +// Structures + +typedef struct VkSurfacePropertiesWSI_ +{ + uint32_t minImageCount; // Supported minimum number of images for the surface + uint32_t maxImageCount; // Supported maximum number of images for the surface, 0 for unlimited + + VkExtent2D currentExtent; // Current image width and height for the surface, (-1, -1) if undefined. + VkExtent2D minImageExtent; // Supported minimum image width and height for the surface + VkExtent2D maxImageExtent; // Supported maximum image width and height for the surface + + VkSurfaceTransformFlagsWSI supportedTransforms;// 1 or more bits representing the transforms supported + VkSurfaceTransformWSI currentTransform; // The surface's current transform relative to the device's natural orientation. + + uint32_t maxImageArraySize; // Supported maximum number of image layers for the surface + + VkImageUsageFlags supportedUsageFlags;// Supported image usage flags for the surface +} VkSurfacePropertiesWSI; + +typedef struct VkSurfaceFormatPropertiesWSI_ +{ + VkFormat format; // Supported rendering format for the surface +} VkSurfaceFormatPropertiesWSI; + +typedef struct VkSurfacePresentModePropertiesWSI_ +{ + VkPresentModeWSI presentMode; // Supported presention mode for the surface +} VkSurfacePresentModePropertiesWSI; + +typedef struct VkSwapChainCreateInfoWSI_ +{ + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI + const void* pNext; // Pointer to next structure + + const VkSurfaceDescriptionWSI* pSurfaceDescription;// describes the swap chain's target surface + + uint32_t minImageCount; // Minimum number of presentation images the application needs + VkFormat imageFormat; // Format of the presentation images + VkExtent2D imageExtent; // Dimensions of the presentation images + VkImageUsageFlags imageUsageFlags; // Bits indicating how the presentation images will be used + VkSurfaceTransformWSI preTransform; // The transform, relative to the device's natural orientation, applied to the image content prior to presentation + uint32_t imageArraySize; // Determines the number of views for multiview/stereo presentation + + VkPresentModeWSI presentMode; // Which presentation mode to use for presents on this swap chain. + + VkSwapChainWSI oldSwapChain; // Existing swap chain to replace, if any. + + VkBool32 clipped; // Specifies whether presentable images may be affected by window clip regions. +} VkSwapChainCreateInfoWSI; + +typedef struct VkSwapChainImagePropertiesWSI_ +{ + VkImage image; // Persistent swap chain image handle +} VkSwapChainImagePropertiesWSI; + +typedef struct VkPresentInfoWSI_ +{ + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_QUEUE_PRESENT_INFO_WSI + const void* pNext; // Pointer to next structure + uint32_t swapChainCount; // Number of swap chains to present in this call + const VkSwapChainWSI* swapChains; // Swap chains to present an image from. + const uint32_t* imageIndices; // Indices of which swapChain images to present +} VkPresentInfoWSI; + +// ------------------------------------------------------------------------------------------------ +// Function types + +typedef VkResult (VKAPI *PFN_vkGetSurfaceInfoWSI)(VkDevice device, const VkSurfaceDescriptionWSI* pSurfaceDescription, VkSurfaceInfoTypeWSI infoType, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI *PFN_vkCreateSwapChainWSI)(VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain); +typedef VkResult (VKAPI *PFN_vkDestroySwapChainWSI)(VkDevice device, VkSwapChainWSI swapChain); +typedef VkResult (VKAPI *PFN_vkGetSwapChainInfoWSI)(VkDevice device, VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI *PFN_vkAcquireNextImageWSI)(VkDevice device, VkSwapChainWSI swapChain, uint64_t timeout, VkSemaphore semaphore, uint32_t* pImageIndex); +typedef VkResult (VKAPI *PFN_vkQueuePresentWSI)(VkQueue queue, VkPresentInfoWSI* pPresentInfo); + +// ------------------------------------------------------------------------------------------------ +// Function prototypes + +#ifdef VK_PROTOTYPES + +VkResult VKAPI vkGetSurfaceInfoWSI( + VkDevice device, + const VkSurfaceDescriptionWSI* pSurfaceDescription, + VkSurfaceInfoTypeWSI infoType, + size_t* pDataSize, + void* pData); + +VkResult VKAPI vkCreateSwapChainWSI( + VkDevice device, + const VkSwapChainCreateInfoWSI* pCreateInfo, + VkSwapChainWSI* pSwapChain); + +VkResult VKAPI vkDestroySwapChainWSI( + VkDevice device, + VkSwapChainWSI swapChain); + +VkResult VKAPI vkGetSwapChainInfoWSI( + VkDevice device, + VkSwapChainWSI swapChain, + VkSwapChainInfoTypeWSI infoType, + size_t* pDataSize, + void* pData); + +VkResult VKAPI vkAcquireNextImageWSI( + VkDevice device, + VkSwapChainWSI swapChain, + uint64_t timeout, + VkSemaphore semaphore, + uint32_t* pImageIndex); + +VkResult VKAPI vkQueuePresentWSI( + VkQueue queue, + VkPresentInfoWSI* pPresentInfo); + +#endif // VK_PROTOTYPES + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif // __VK_WSI_SWAPCHAIN_H__ diff --git a/renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_lunarg.h b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_lunarg.h new file mode 100644 index 000000000..a986301d1 --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_lunarg.h @@ -0,0 +1,175 @@ +// +// File: vk_wsi_display.h +// +/* +** Copyright (c) 2014 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __VK_WSI_LUNARG_H__ +#define __VK_WSI_LUNARG_H__ + +#include "vulkan.h" + +#define VK_WSI_LUNARG_REVISION VK_MAKE_VERSION(0, 3, 0) +#define VK_WSI_LUNARG_EXTENSION_NUMBER 1 +#define VK_WSI_LUNARG_EXTENSION_NAME "VK_WSI_LunarG" + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +// ------------------------------------------------------------------------------------------------ +// Objects + +VK_DEFINE_HANDLE(VkDisplayWSI) +VK_DEFINE_HANDLE(VkSwapChainWSI) + +// ------------------------------------------------------------------------------------------------ +// Enumeration constants + +#define VK_WSI_LUNARG_ENUM(type,id) ((type)(VK_WSI_LUNARG_EXTENSION_NUMBER * -1000 + (id))) + +// Extend VkPhysicalDeviceInfoType enum with extension specific constants +#define VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PRESENT_PROPERTIES_WSI VK_WSI_LUNARG_ENUM(VkPhysicalDeviceInfoType, 1) + +// Extend VkStructureType enum with extension specific constants +#define VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI VK_WSI_LUNARG_ENUM(VkStructureType, 0) +#define VK_STRUCTURE_TYPE_PRESENT_INFO_WSI VK_WSI_LUNARG_ENUM(VkStructureType, 1) + +// Extend VkImageLayout enum with extension specific constants +#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_WSI VK_WSI_LUNARG_ENUM(VkImageLayout, 0) + +typedef enum VkSwapChainInfoTypeWSI_ +{ + // Info type for vkGetSwapChainInfo() + VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI = 0x00000000, // Return information about the persistent images of the swapchain + +} VkSwapChainInfoTypeWSI; + +// ------------------------------------------------------------------------------------------------ +// Flags + +typedef VkFlags VkSwapModeFlagsWSI; +typedef enum VkSwapModeFlagBitsWSI_ +{ + VK_SWAP_MODE_FLIP_BIT_WSI = 0x1, + VK_SWAP_MODE_BLIT_BIT_WSI = 0x2 +} VkSwapModeFlagBitsWSI; + +// ------------------------------------------------------------------------------------------------ +// Structures + +typedef struct VkDisplayPropertiesWSI_ +{ + VkDisplayWSI display; // Handle of the display object + VkExtent2D physicalResolution; // Max resolution for CRT? +} VkDisplayPropertiesWSI; + +typedef struct VkDisplayFormatPropertiesWSI_ +{ + VkFormat swapChainFormat; // Format of the images of the swap chain +} VkDisplayFormatPropertiesWSI; + +typedef struct VkSwapChainCreateInfoWSI_ +{ + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI + const void* pNext; // Pointer to next structure + + // TBD: It is not yet clear what the use will be for the following two + // values. It seems to be needed for more-global window-system handles + // (e.g. X11 display). If not needed for the SDK, we will drop it from + // this extension, and from a future version of this header. + const void* pNativeWindowSystemHandle; // Pointer to native window system handle + const void* pNativeWindowHandle; // Pointer to native window handle + + uint32_t displayCount; // Number of displays the swap chain is created for + const VkDisplayWSI* pDisplays; // displayCount number of display objects the swap chain is created for + + uint32_t imageCount; // Number of images in the swap chain + + VkFormat imageFormat; // Format of the images of the swap chain + VkExtent2D imageExtent; // Width and height of the images of the swap chain + uint32_t imageArraySize; // Number of layers of the images of the swap chain (needed for multi-view rendering) + VkFlags imageUsageFlags; // Usage flags for the images of the swap chain (see VkImageUsageFlags) + + VkFlags swapModeFlags; // Allowed swap modes (see VkSwapModeFlagsWSI) +} VkSwapChainCreateInfoWSI; + +typedef struct VkSwapChainImageInfoWSI_ +{ + VkImage image; // Persistent swap chain image handle + VkDeviceMemory memory; // Persistent swap chain image's memory handle +} VkSwapChainImageInfoWSI; + +typedef struct VkPhysicalDeviceQueuePresentPropertiesWSI_ +{ + VkBool32 supportsPresent; // Tells whether the queue supports presenting +} VkPhysicalDeviceQueuePresentPropertiesWSI; + +typedef struct VkPresentInfoWSI_ +{ + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_PRESENT_INFO_WSI + const void* pNext; // Pointer to next structure + VkImage image; // Image to present + uint32_t flipInterval; // Flip interval +} VkPresentInfoWSI; + +// ------------------------------------------------------------------------------------------------ +// Function types + +typedef VkResult (VKAPI *PFN_vkCreateSwapChainWSI)(VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain); +typedef VkResult (VKAPI *PFN_vkDestroySwapChainWSI)(VkSwapChainWSI swapChain); +typedef VkResult (VKAPI *PFN_vkGetSwapChainInfoWSI)(VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI *PFN_vkQueuePresentWSI)(VkQueue queue, const VkPresentInfoWSI* pPresentInfo); + +// ------------------------------------------------------------------------------------------------ +// Function prototypes + +#ifdef VK_PROTOTYPES + + +VkResult VKAPI vkCreateSwapChainWSI( + VkDevice device, + const VkSwapChainCreateInfoWSI* pCreateInfo, + VkSwapChainWSI* pSwapChain); + +VkResult VKAPI vkDestroySwapChainWSI( + VkSwapChainWSI swapChain); + +VkResult VKAPI vkGetSwapChainInfoWSI( + VkSwapChainWSI swapChain, + VkSwapChainInfoTypeWSI infoType, + size_t* pDataSize, + void* pData); + +VkResult VKAPI vkQueuePresentWSI( + VkQueue queue, + const VkPresentInfoWSI* pPresentInfo); + +#endif // VK_PROTOTYPES + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif // __VK_WSI_LUNARG_H__ diff --git a/renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_swapchain.h b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_swapchain.h new file mode 100644 index 000000000..64704d473 --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/include/vk_wsi_swapchain.h @@ -0,0 +1,133 @@ +// +// File: vk_wsi_swapchain.h +// +/* +** Copyright (c) 2014 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __VK_WSI_SWAPCHAIN_H__ +#define __VK_WSI_SWAPCHAIN_H__ + +#include "vulkan.h" + +#define VK_WSI_SWAPCHAIN_REVISION 12 +#define VK_WSI_SWAPCHAIN_EXTENSION_NUMBER 1 +#define VK_WSI_SWAPCHAIN_EXTENSION_NAME "VK_WSI_swapchain" + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +// ------------------------------------------------------------------------------------------------ +// Objects + +// ------------------------------------------------------------------------------------------------ +// Enumeration constants + +#define VK_WSI_SWAPCHAIN_ENUM(type,id) ((type)((int)0xc0000000 - VK_WSI_SWAPCHAIN_EXTENSION_NUMBER * -1024 + (id))) +#define VK_WSI_SWAPCHAIN_ENUM_POSITIVE(type,id) ((type)((int)0x40000000 + (VK_WSI_SWAPCHAIN_EXTENSION_NUMBER - 1) * 1024 + (id))) + +// Extend VkStructureType enum with extension specific constants +#define VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI VK_WSI_SWAPCHAIN_ENUM(VkStructureType, 0) + +// ------------------------------------------------------------------------------------------------ +// Enumerations + +typedef enum VkPlatformWSI_ +{ + VK_PLATFORM_WIN32_WSI = 0, + VK_PLATFORM_X11_WSI = 1, + VK_PLATFORM_XCB_WSI = 2, + VK_PLATFORM_ANDROID_WSI = 3, + VK_PLATFORM_WAYLAND_WSI = 4, + VK_PLATFORM_MIR_WSI = 5, + VK_PLATFORM_BEGIN_RANGE_WSI = VK_PLATFORM_WIN32_WSI, + VK_PLATFORM_END_RANGE_WSI = VK_PLATFORM_MIR_WSI, + VK_PLATFORM_NUM_WSI = (VK_PLATFORM_MIR_WSI - VK_PLATFORM_WIN32_WSI + 1), + VK_PLATFORM_MAX_ENUM_WSI = 0x7FFFFFFF +} VkPlatformWSI; + +// ------------------------------------------------------------------------------------------------ +// Flags + +// ------------------------------------------------------------------------------------------------ +// Structures + +// pPlatformHandle points to this struct when platform is VK_PLATFORM_X11_WSI +#ifdef _X11_XLIB_H_ +typedef struct VkPlatformHandleX11WSI_ +{ + Display* dpy; // Display connection to an X server + Window root; // To identify the X screen +} VkPlatformHandleX11WSI; +#endif /* _X11_XLIB_H_ */ + +// pPlatformHandle points to this struct when platform is VK_PLATFORM_XCB_WSI +#ifdef __XCB_H__ +typedef struct VkPlatformHandleXcbWSI_ +{ + xcb_connection_t* connection; // XCB connection to an X server + xcb_window_t root; // To identify the X screen +} VkPlatformHandleXcbWSI; +#endif /* __XCB_H__ */ + +// Placeholder structure header for the different types of surface description structures +typedef struct VkSurfaceDescriptionWSI_ +{ + VkStructureType sType; // Can be any of the VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_XXX_WSI constants + const void* pNext; // Pointer to next structure +} VkSurfaceDescriptionWSI; + +// Surface description structure for a native platform window surface +typedef struct VkSurfaceDescriptionWindowWSI_ +{ + VkStructureType sType; // Must be VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_WSI + const void* pNext; // Pointer to next structure + VkPlatformWSI platform; // e.g. VK_PLATFORM_*_WSI + void* pPlatformHandle; + void* pPlatformWindow; +} VkSurfaceDescriptionWindowWSI; + +// ------------------------------------------------------------------------------------------------ +// Function types + +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSurfaceSupportWSI)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkSurfaceDescriptionWSI* pSurfaceDescription, VkBool32* pSupported); + +// ------------------------------------------------------------------------------------------------ +// Function prototypes + +#ifdef VK_PROTOTYPES + +VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportWSI( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + const VkSurfaceDescriptionWSI* pSurfaceDescription, + VkBool32* pSupported); + +#endif // VK_PROTOTYPES + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif // __VK_WSI_SWAPCHAIN_H__ diff --git a/renderdoc/driver/vulkan/LoaderAndTools/include/vulkan.h b/renderdoc/driver/vulkan/LoaderAndTools/include/vulkan.h new file mode 100644 index 000000000..9877233bf --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/include/vulkan.h @@ -0,0 +1,3054 @@ +#ifndef __vulkan_h_ +#define __vulkan_h_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_VERSION_1_0 1 +#include "vk_platform.h" + +#define VK_MAKE_VERSION(major, minor, patch) \ + ((major << 22) | (minor << 12) | patch) + +// Vulkan API version supported by this file +#define VK_API_VERSION VK_MAKE_VERSION(0, 138, 2) + + +#define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj; + + +#if defined(__cplusplus) + #if (_MSC_VER >= 1800 || __cplusplus >= 201103L) + // The bool operator only works if there are no implicit conversions from an obj to + // a bool-compatible type, which can then be used to unintentionally violate type safety. + // C++11 and above supports the "explicit" keyword on conversion operators to stop this + // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating + // the object handle as a bool in expressions like: + // if (obj) vkDestroy(obj); + #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; } + #else + #define VK_NONDISP_HANDLE_OPERATOR_BOOL() + #endif + #define VK_DEFINE_NONDISP_HANDLE(obj) \ + struct obj { \ + obj() : handle(0) { } \ + obj(uint64_t x) : handle(x) { } \ + obj& operator =(uint64_t x) { handle = x; return *this; } \ + bool operator==(const obj& other) const { return handle == other.handle; } \ + bool operator!=(const obj& other) const { return handle != other.handle; } \ + bool operator!() const { return !handle; } \ + VK_NONDISP_HANDLE_OPERATOR_BOOL() \ + uint64_t handle; \ + }; +#else + #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj; +#endif + + + +#define VK_LOD_CLAMP_NONE MAX_FLOAT +#define VK_LAST_MIP_LEVEL UINT32_MAX +#define VK_LAST_ARRAY_SLICE UINT32_MAX +#define VK_WHOLE_SIZE UINT64_MAX +#define VK_ATTACHMENT_UNUSED UINT32_MAX +#define VK_TRUE 1 +#define VK_FALSE 0 +#define VK_NULL_HANDLE 0 +#define VK_MAX_PHYSICAL_DEVICE_NAME 256 +#define VK_UUID_LENGTH 16 +#define VK_MAX_MEMORY_TYPES 32 +#define VK_MAX_MEMORY_HEAPS 16 +#define VK_MAX_EXTENSION_NAME 256 +#define VK_MAX_DESCRIPTION 256 + +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalDevice) +VK_DEFINE_HANDLE(VkDevice) +VK_DEFINE_HANDLE(VkQueue) +VK_DEFINE_HANDLE(VkCmdBuffer) +VK_DEFINE_NONDISP_HANDLE(VkFence) +VK_DEFINE_NONDISP_HANDLE(VkDeviceMemory) +VK_DEFINE_NONDISP_HANDLE(VkBuffer) +VK_DEFINE_NONDISP_HANDLE(VkImage) +VK_DEFINE_NONDISP_HANDLE(VkSemaphore) +VK_DEFINE_NONDISP_HANDLE(VkEvent) +VK_DEFINE_NONDISP_HANDLE(VkQueryPool) +VK_DEFINE_NONDISP_HANDLE(VkBufferView) +VK_DEFINE_NONDISP_HANDLE(VkImageView) +VK_DEFINE_NONDISP_HANDLE(VkAttachmentView) +VK_DEFINE_NONDISP_HANDLE(VkShaderModule) +VK_DEFINE_NONDISP_HANDLE(VkShader) +VK_DEFINE_NONDISP_HANDLE(VkPipelineCache) +VK_DEFINE_NONDISP_HANDLE(VkPipelineLayout) +VK_DEFINE_NONDISP_HANDLE(VkRenderPass) +VK_DEFINE_NONDISP_HANDLE(VkPipeline) +VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NONDISP_HANDLE(VkSampler) +VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool) +VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet) +VK_DEFINE_NONDISP_HANDLE(VkDynamicViewportState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicRasterState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicColorBlendState) +VK_DEFINE_NONDISP_HANDLE(VkDynamicDepthStencilState) +VK_DEFINE_NONDISP_HANDLE(VkFramebuffer) +VK_DEFINE_NONDISP_HANDLE(VkCmdPool) + + +typedef enum { + VK_SUCCESS = 0, + VK_UNSUPPORTED = 1, + VK_NOT_READY = 2, + VK_TIMEOUT = 3, + VK_EVENT_SET = 4, + VK_EVENT_RESET = 5, + VK_INCOMPLETE = 6, + VK_ERROR_UNKNOWN = -1, + VK_ERROR_UNAVAILABLE = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_OUT_OF_HOST_MEMORY = -4, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -5, + VK_ERROR_DEVICE_ALREADY_CREATED = -6, + VK_ERROR_DEVICE_LOST = -7, + VK_ERROR_INVALID_POINTER = -8, + VK_ERROR_INVALID_VALUE = -9, + VK_ERROR_INVALID_HANDLE = -10, + VK_ERROR_INVALID_ORDINAL = -11, + VK_ERROR_INVALID_MEMORY_SIZE = -12, + VK_ERROR_INVALID_EXTENSION = -13, + VK_ERROR_INVALID_FLAGS = -14, + VK_ERROR_INVALID_ALIGNMENT = -15, + VK_ERROR_INVALID_FORMAT = -16, + VK_ERROR_INVALID_IMAGE = -17, + VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -18, + VK_ERROR_INVALID_QUEUE_TYPE = -19, + VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -20, + VK_ERROR_BAD_SHADER_CODE = -21, + VK_ERROR_BAD_PIPELINE_DATA = -22, + VK_ERROR_NOT_MAPPABLE = -23, + VK_ERROR_MEMORY_MAP_FAILED = -24, + VK_ERROR_MEMORY_UNMAP_FAILED = -25, + VK_ERROR_INCOMPATIBLE_DEVICE = -26, + VK_ERROR_INCOMPATIBLE_DRIVER = -27, + VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -28, + VK_ERROR_BUILDING_COMMAND_BUFFER = -29, + VK_ERROR_MEMORY_NOT_BOUND = -30, + VK_ERROR_INCOMPATIBLE_QUEUE = -31, + VK_ERROR_INVALID_LAYER = -32, + VK_RESULT_BEGIN_RANGE = VK_ERROR_INVALID_LAYER, + VK_RESULT_END_RANGE = VK_INCOMPLETE, + VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INVALID_LAYER + 1), + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO = 4, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 5, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO = 6, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 7, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 33, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 34, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 35, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 36, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 37, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 39, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 40, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 41, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 42, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 43, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 44, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION = 45, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION = 46, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY = 47, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 48, + VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 49, + VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, + VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO, + VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum { + VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0, + VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1, + VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2, + VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3, + VK_SYSTEM_ALLOC_TYPE_DEBUG = 4, + VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT, + VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG, + VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1), + VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocType; + +typedef enum { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM = 1, + VK_FORMAT_R4G4_USCALED = 2, + VK_FORMAT_R4G4B4A4_UNORM = 3, + VK_FORMAT_R4G4B4A4_USCALED = 4, + VK_FORMAT_R5G6B5_UNORM = 5, + VK_FORMAT_R5G6B5_USCALED = 6, + VK_FORMAT_R5G5B5A1_UNORM = 7, + VK_FORMAT_R5G5B5A1_USCALED = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_R8G8B8A8_UNORM = 30, + VK_FORMAT_R8G8B8A8_SNORM = 31, + VK_FORMAT_R8G8B8A8_USCALED = 32, + VK_FORMAT_R8G8B8A8_SSCALED = 33, + VK_FORMAT_R8G8B8A8_UINT = 34, + VK_FORMAT_R8G8B8A8_SINT = 35, + VK_FORMAT_R8G8B8A8_SRGB = 36, + VK_FORMAT_R10G10B10A2_UNORM = 37, + VK_FORMAT_R10G10B10A2_SNORM = 38, + VK_FORMAT_R10G10B10A2_USCALED = 39, + VK_FORMAT_R10G10B10A2_SSCALED = 40, + VK_FORMAT_R10G10B10A2_UINT = 41, + VK_FORMAT_R10G10B10A2_SINT = 42, + VK_FORMAT_R16_UNORM = 43, + VK_FORMAT_R16_SNORM = 44, + VK_FORMAT_R16_USCALED = 45, + VK_FORMAT_R16_SSCALED = 46, + VK_FORMAT_R16_UINT = 47, + VK_FORMAT_R16_SINT = 48, + VK_FORMAT_R16_SFLOAT = 49, + VK_FORMAT_R16G16_UNORM = 50, + VK_FORMAT_R16G16_SNORM = 51, + VK_FORMAT_R16G16_USCALED = 52, + VK_FORMAT_R16G16_SSCALED = 53, + VK_FORMAT_R16G16_UINT = 54, + VK_FORMAT_R16G16_SINT = 55, + VK_FORMAT_R16G16_SFLOAT = 56, + VK_FORMAT_R16G16B16_UNORM = 57, + VK_FORMAT_R16G16B16_SNORM = 58, + VK_FORMAT_R16G16B16_USCALED = 59, + VK_FORMAT_R16G16B16_SSCALED = 60, + VK_FORMAT_R16G16B16_UINT = 61, + VK_FORMAT_R16G16B16_SINT = 62, + VK_FORMAT_R16G16B16_SFLOAT = 63, + VK_FORMAT_R16G16B16A16_UNORM = 64, + VK_FORMAT_R16G16B16A16_SNORM = 65, + VK_FORMAT_R16G16B16A16_USCALED = 66, + VK_FORMAT_R16G16B16A16_SSCALED = 67, + VK_FORMAT_R16G16B16A16_UINT = 68, + VK_FORMAT_R16G16B16A16_SINT = 69, + VK_FORMAT_R16G16B16A16_SFLOAT = 70, + VK_FORMAT_R32_UINT = 71, + VK_FORMAT_R32_SINT = 72, + VK_FORMAT_R32_SFLOAT = 73, + VK_FORMAT_R32G32_UINT = 74, + VK_FORMAT_R32G32_SINT = 75, + VK_FORMAT_R32G32_SFLOAT = 76, + VK_FORMAT_R32G32B32_UINT = 77, + VK_FORMAT_R32G32B32_SINT = 78, + VK_FORMAT_R32G32B32_SFLOAT = 79, + VK_FORMAT_R32G32B32A32_UINT = 80, + VK_FORMAT_R32G32B32A32_SINT = 81, + VK_FORMAT_R32G32B32A32_SFLOAT = 82, + VK_FORMAT_R64_SFLOAT = 83, + VK_FORMAT_R64G64_SFLOAT = 84, + VK_FORMAT_R64G64B64_SFLOAT = 85, + VK_FORMAT_R64G64B64A64_SFLOAT = 86, + VK_FORMAT_R11G11B10_UFLOAT = 87, + VK_FORMAT_R9G9B9E5_UFLOAT = 88, + VK_FORMAT_D16_UNORM = 89, + VK_FORMAT_D24_UNORM = 90, + VK_FORMAT_D32_SFLOAT = 91, + VK_FORMAT_S8_UINT = 92, + VK_FORMAT_D16_UNORM_S8_UINT = 93, + VK_FORMAT_D24_UNORM_S8_UINT = 94, + VK_FORMAT_D32_SFLOAT_S8_UINT = 95, + VK_FORMAT_BC1_RGB_UNORM = 96, + VK_FORMAT_BC1_RGB_SRGB = 97, + VK_FORMAT_BC1_RGBA_UNORM = 98, + VK_FORMAT_BC1_RGBA_SRGB = 99, + VK_FORMAT_BC2_UNORM = 100, + VK_FORMAT_BC2_SRGB = 101, + VK_FORMAT_BC3_UNORM = 102, + VK_FORMAT_BC3_SRGB = 103, + VK_FORMAT_BC4_UNORM = 104, + VK_FORMAT_BC4_SNORM = 105, + VK_FORMAT_BC5_UNORM = 106, + VK_FORMAT_BC5_SNORM = 107, + VK_FORMAT_BC6H_UFLOAT = 108, + VK_FORMAT_BC6H_SFLOAT = 109, + VK_FORMAT_BC7_UNORM = 110, + VK_FORMAT_BC7_SRGB = 111, + VK_FORMAT_ETC2_R8G8B8_UNORM = 112, + VK_FORMAT_ETC2_R8G8B8_SRGB = 113, + VK_FORMAT_ETC2_R8G8B8A1_UNORM = 114, + VK_FORMAT_ETC2_R8G8B8A1_SRGB = 115, + VK_FORMAT_ETC2_R8G8B8A8_UNORM = 116, + VK_FORMAT_ETC2_R8G8B8A8_SRGB = 117, + VK_FORMAT_EAC_R11_UNORM = 118, + VK_FORMAT_EAC_R11_SNORM = 119, + VK_FORMAT_EAC_R11G11_UNORM = 120, + VK_FORMAT_EAC_R11G11_SNORM = 121, + VK_FORMAT_ASTC_4x4_UNORM = 122, + VK_FORMAT_ASTC_4x4_SRGB = 123, + VK_FORMAT_ASTC_5x4_UNORM = 124, + VK_FORMAT_ASTC_5x4_SRGB = 125, + VK_FORMAT_ASTC_5x5_UNORM = 126, + VK_FORMAT_ASTC_5x5_SRGB = 127, + VK_FORMAT_ASTC_6x5_UNORM = 128, + VK_FORMAT_ASTC_6x5_SRGB = 129, + VK_FORMAT_ASTC_6x6_UNORM = 130, + VK_FORMAT_ASTC_6x6_SRGB = 131, + VK_FORMAT_ASTC_8x5_UNORM = 132, + VK_FORMAT_ASTC_8x5_SRGB = 133, + VK_FORMAT_ASTC_8x6_UNORM = 134, + VK_FORMAT_ASTC_8x6_SRGB = 135, + VK_FORMAT_ASTC_8x8_UNORM = 136, + VK_FORMAT_ASTC_8x8_SRGB = 137, + VK_FORMAT_ASTC_10x5_UNORM = 138, + VK_FORMAT_ASTC_10x5_SRGB = 139, + VK_FORMAT_ASTC_10x6_UNORM = 140, + VK_FORMAT_ASTC_10x6_SRGB = 141, + VK_FORMAT_ASTC_10x8_UNORM = 142, + VK_FORMAT_ASTC_10x8_SRGB = 143, + VK_FORMAT_ASTC_10x10_UNORM = 144, + VK_FORMAT_ASTC_10x10_SRGB = 145, + VK_FORMAT_ASTC_12x10_UNORM = 146, + VK_FORMAT_ASTC_12x10_SRGB = 147, + VK_FORMAT_ASTC_12x12_UNORM = 148, + VK_FORMAT_ASTC_12x12_SRGB = 149, + VK_FORMAT_B4G4R4A4_UNORM = 150, + VK_FORMAT_B5G5R5A1_UNORM = 151, + VK_FORMAT_B5G6R5_UNORM = 152, + VK_FORMAT_B5G6R5_USCALED = 153, + VK_FORMAT_B8G8R8_UNORM = 154, + VK_FORMAT_B8G8R8_SNORM = 155, + VK_FORMAT_B8G8R8_USCALED = 156, + VK_FORMAT_B8G8R8_SSCALED = 157, + VK_FORMAT_B8G8R8_UINT = 158, + VK_FORMAT_B8G8R8_SINT = 159, + VK_FORMAT_B8G8R8_SRGB = 160, + VK_FORMAT_B8G8R8A8_UNORM = 161, + VK_FORMAT_B8G8R8A8_SNORM = 162, + VK_FORMAT_B8G8R8A8_USCALED = 163, + VK_FORMAT_B8G8R8A8_SSCALED = 164, + VK_FORMAT_B8G8R8A8_UINT = 165, + VK_FORMAT_B8G8R8A8_SINT = 166, + VK_FORMAT_B8G8R8A8_SRGB = 167, + VK_FORMAT_B10G10R10A2_UNORM = 168, + VK_FORMAT_B10G10R10A2_SNORM = 169, + VK_FORMAT_B10G10R10A2_USCALED = 170, + VK_FORMAT_B10G10R10A2_SSCALED = 171, + VK_FORMAT_B10G10R10A2_UINT = 172, + VK_FORMAT_B10G10R10A2_SINT = 173, + VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, + VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT, + VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1), + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, + VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, + VK_IMAGE_TYPE_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum { + VK_IMAGE_TILING_LINEAR = 0, + VK_IMAGE_TILING_OPTIMAL = 1, + VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_LINEAR, + VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_OPTIMAL - VK_IMAGE_TILING_LINEAR + 1), + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, + VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, + VK_PHYSICAL_DEVICE_TYPE_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum { + VK_IMAGE_ASPECT_COLOR = 0, + VK_IMAGE_ASPECT_DEPTH = 1, + VK_IMAGE_ASPECT_STENCIL = 2, + VK_IMAGE_ASPECT_METADATA = 3, + VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR, + VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_METADATA, + VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_METADATA - VK_IMAGE_ASPECT_COLOR + 1), + VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF +} VkImageAspect; + +typedef enum { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, + VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS, + VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1), + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, + VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, + VK_SHARING_MODE_NUM = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum { + VK_BUFFER_VIEW_TYPE_RAW = 0, + VK_BUFFER_VIEW_TYPE_FORMATTED = 1, + VK_BUFFER_VIEW_TYPE_BEGIN_RANGE = VK_BUFFER_VIEW_TYPE_RAW, + VK_BUFFER_VIEW_TYPE_END_RANGE = VK_BUFFER_VIEW_TYPE_FORMATTED, + VK_BUFFER_VIEW_TYPE_NUM = (VK_BUFFER_VIEW_TYPE_FORMATTED - VK_BUFFER_VIEW_TYPE_RAW + 1), + VK_BUFFER_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkBufferViewType; + +typedef enum { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, + VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, + VK_IMAGE_VIEW_TYPE_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum { + VK_CHANNEL_SWIZZLE_ZERO = 0, + VK_CHANNEL_SWIZZLE_ONE = 1, + VK_CHANNEL_SWIZZLE_R = 2, + VK_CHANNEL_SWIZZLE_G = 3, + VK_CHANNEL_SWIZZLE_B = 4, + VK_CHANNEL_SWIZZLE_A = 5, + VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_ZERO, + VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A, + VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_ZERO + 1), + VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkChannelSwizzle; + +typedef enum { + VK_SHADER_STAGE_VERTEX = 0, + VK_SHADER_STAGE_TESS_CONTROL = 1, + VK_SHADER_STAGE_TESS_EVALUATION = 2, + VK_SHADER_STAGE_GEOMETRY = 3, + VK_SHADER_STAGE_FRAGMENT = 4, + VK_SHADER_STAGE_COMPUTE = 5, + VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX, + VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE, + VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1), + VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF +} VkShaderStage; + +typedef enum { + VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0, + VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX, + VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE, + VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1), + VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputStepRate; + +typedef enum { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH = 10, + VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH, + VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum { + VK_FILL_MODE_POINTS = 0, + VK_FILL_MODE_WIREFRAME = 1, + VK_FILL_MODE_SOLID = 2, + VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_POINTS, + VK_FILL_MODE_END_RANGE = VK_FILL_MODE_SOLID, + VK_FILL_MODE_NUM = (VK_FILL_MODE_SOLID - VK_FILL_MODE_POINTS + 1), + VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF +} VkFillMode; + +typedef enum { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT = 1, + VK_CULL_MODE_BACK = 2, + VK_CULL_MODE_FRONT_AND_BACK = 3, + VK_CULL_MODE_BEGIN_RANGE = VK_CULL_MODE_NONE, + VK_CULL_MODE_END_RANGE = VK_CULL_MODE_FRONT_AND_BACK, + VK_CULL_MODE_NUM = (VK_CULL_MODE_FRONT_AND_BACK - VK_CULL_MODE_NONE + 1), + VK_CULL_MODE_MAX_ENUM = 0x7FFFFFFF +} VkCullMode; + +typedef enum { + VK_FRONT_FACE_CCW = 0, + VK_FRONT_FACE_CW = 1, + VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW, + VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW, + VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1), + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, + VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, + VK_COMPARE_OP_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INC_CLAMP = 3, + VK_STENCIL_OP_DEC_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INC_WRAP = 6, + VK_STENCIL_OP_DEC_WRAP = 7, + VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, + VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP, + VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1), + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum { + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NOOP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIV = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, + VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, + VK_LOGIC_OP_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum { + VK_BLEND_ZERO = 0, + VK_BLEND_ONE = 1, + VK_BLEND_SRC_COLOR = 2, + VK_BLEND_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_DEST_COLOR = 4, + VK_BLEND_ONE_MINUS_DEST_COLOR = 5, + VK_BLEND_SRC_ALPHA = 6, + VK_BLEND_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_DEST_ALPHA = 8, + VK_BLEND_ONE_MINUS_DEST_ALPHA = 9, + VK_BLEND_CONSTANT_COLOR = 10, + VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_CONSTANT_ALPHA = 12, + VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_SRC_ALPHA_SATURATE = 14, + VK_BLEND_SRC1_COLOR = 15, + VK_BLEND_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_SRC1_ALPHA = 17, + VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO, + VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA, + VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1), + VK_BLEND_MAX_ENUM = 0x7FFFFFFF +} VkBlend; + +typedef enum { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, + VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, + VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum { + VK_TEX_FILTER_NEAREST = 0, + VK_TEX_FILTER_LINEAR = 1, + VK_TEX_FILTER_BEGIN_RANGE = VK_TEX_FILTER_NEAREST, + VK_TEX_FILTER_END_RANGE = VK_TEX_FILTER_LINEAR, + VK_TEX_FILTER_NUM = (VK_TEX_FILTER_LINEAR - VK_TEX_FILTER_NEAREST + 1), + VK_TEX_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkTexFilter; + +typedef enum { + VK_TEX_MIPMAP_MODE_BASE = 0, + VK_TEX_MIPMAP_MODE_NEAREST = 1, + VK_TEX_MIPMAP_MODE_LINEAR = 2, + VK_TEX_MIPMAP_MODE_BEGIN_RANGE = VK_TEX_MIPMAP_MODE_BASE, + VK_TEX_MIPMAP_MODE_END_RANGE = VK_TEX_MIPMAP_MODE_LINEAR, + VK_TEX_MIPMAP_MODE_NUM = (VK_TEX_MIPMAP_MODE_LINEAR - VK_TEX_MIPMAP_MODE_BASE + 1), + VK_TEX_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkTexMipmapMode; + +typedef enum { + VK_TEX_ADDRESS_WRAP = 0, + VK_TEX_ADDRESS_MIRROR = 1, + VK_TEX_ADDRESS_CLAMP = 2, + VK_TEX_ADDRESS_MIRROR_ONCE = 3, + VK_TEX_ADDRESS_CLAMP_BORDER = 4, + VK_TEX_ADDRESS_BEGIN_RANGE = VK_TEX_ADDRESS_WRAP, + VK_TEX_ADDRESS_END_RANGE = VK_TEX_ADDRESS_CLAMP_BORDER, + VK_TEX_ADDRESS_NUM = (VK_TEX_ADDRESS_CLAMP_BORDER - VK_TEX_ADDRESS_WRAP + 1), + VK_TEX_ADDRESS_MAX_ENUM = 0x7FFFFFFF +} VkTexAddress; + +typedef enum { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, + VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, + VK_BORDER_COLOR_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, + VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, + VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum { + VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0, + VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1, + VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, + VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC, + VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1), + VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorPoolUsage; + +typedef enum { + VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0, + VK_DESCRIPTOR_SET_USAGE_STATIC = 1, + VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT, + VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC, + VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1), + VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorSetUsage; + +typedef enum { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7, + VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, + VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL - VK_IMAGE_LAYOUT_UNDEFINED + 1), + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, + VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + VK_ATTACHMENT_LOAD_OP_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_ATTACHMENT_STORE_OP_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum { + VK_PIPELINE_BIND_POINT_COMPUTE = 0, + VK_PIPELINE_BIND_POINT_GRAPHICS = 1, + VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, + VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, + VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_GRAPHICS - VK_PIPELINE_BIND_POINT_COMPUTE + 1), + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum { + VK_CMD_BUFFER_LEVEL_PRIMARY = 0, + VK_CMD_BUFFER_LEVEL_SECONDARY = 1, + VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY, + VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY, + VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1), + VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCmdBufferLevel; + +typedef enum { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, + VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, + VK_INDEX_TYPE_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum { + VK_TIMESTAMP_TYPE_TOP = 0, + VK_TIMESTAMP_TYPE_BOTTOM = 1, + VK_TIMESTAMP_TYPE_BEGIN_RANGE = VK_TIMESTAMP_TYPE_TOP, + VK_TIMESTAMP_TYPE_END_RANGE = VK_TIMESTAMP_TYPE_BOTTOM, + VK_TIMESTAMP_TYPE_NUM = (VK_TIMESTAMP_TYPE_BOTTOM - VK_TIMESTAMP_TYPE_TOP + 1), + VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkTimestampType; + +typedef enum { + VK_RENDER_PASS_CONTENTS_INLINE = 0, + VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1, + VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE, + VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS, + VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1), + VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkRenderPassContents; + + +typedef enum { + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, + VK_FORMAT_FEATURE_CONVERSION_BIT = 0x00000400, +} VkFormatFeatureFlagBits; +typedef VkFlags VkFormatFeatureFlags; + +typedef enum { + VK_IMAGE_USAGE_GENERAL = 0, + VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, + VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, + VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, + VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000020, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, +} VkImageUsageFlagBits; +typedef VkFlags VkImageUsageFlags; + +typedef enum { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_DMA_BIT = 0x00000004, + VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, + VK_QUEUE_EXTENDED_BIT = 0x40000000, +} VkQueueFlagBits; +typedef VkFlags VkQueueFlags; + +typedef enum { + VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, +} VkMemoryPropertyFlagBits; +typedef VkFlags VkMemoryPropertyFlags; + +typedef enum { + VK_MEMORY_HEAP_HOST_LOCAL = 0x00000001, +} VkMemoryHeapFlagBits; +typedef VkFlags VkMemoryHeapFlags; + +typedef enum { + VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001, +} VkDeviceCreateFlagBits; +typedef VkFlags VkDeviceCreateFlags; +typedef VkFlags VkMemoryMapFlags; + +typedef enum { + VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001, + VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002, + VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004, +} VkSparseImageFormatFlagBits; +typedef VkFlags VkSparseImageFormatFlags; + +typedef enum { + VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT = 0x00000001, +} VkSparseMemoryBindFlagBits; +typedef VkFlags VkSparseMemoryBindFlags; + +typedef enum { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, +} VkFenceCreateFlagBits; +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; +typedef VkFlags VkEventCreateFlags; + +typedef enum { + VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001, + VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002, + VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004, + VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008, + VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010, + VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020, + VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040, + VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080, + VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100, + VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200, + VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400, +} VkQueryPipelineStatisticFlagBits; +typedef VkFlags VkQueryPipelineStatisticFlags; + +typedef enum { + VK_QUERY_RESULT_DEFAULT = 0, + VK_QUERY_RESULT_64_BIT = 0x00000001, + VK_QUERY_RESULT_WAIT_BIT = 0x00000002, + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, + VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, +} VkQueryResultFlagBits; +typedef VkFlags VkQueryResultFlags; + +typedef enum { + VK_BUFFER_USAGE_GENERAL = 0, + VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, + VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; + +typedef enum { + VK_BUFFER_CREATE_SPARSE_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, +} VkBufferCreateFlagBits; +typedef VkFlags VkBufferCreateFlags; + +typedef enum { + VK_IMAGE_CREATE_SPARSE_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000008, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000020, +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + +typedef enum { + VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001, + VK_ATTACHMENT_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002, +} VkAttachmentViewCreateFlagBits; +typedef VkFlags VkAttachmentViewCreateFlags; +typedef VkFlags VkShaderModuleCreateFlags; +typedef VkFlags VkShaderCreateFlags; + +typedef enum { + VK_CHANNEL_R_BIT = 0x00000001, + VK_CHANNEL_G_BIT = 0x00000002, + VK_CHANNEL_B_BIT = 0x00000004, + VK_CHANNEL_A_BIT = 0x00000008, +} VkChannelFlagBits; +typedef VkFlags VkChannelFlags; + +typedef enum { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, +} VkPipelineCreateFlagBits; +typedef VkFlags VkPipelineCreateFlags; + +typedef enum { + VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_TESS_EVALUATION_BIT = 0x00000004, + VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, + VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, + VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, + VK_SHADER_STAGE_ALL = 0x7FFFFFFF, +} VkShaderStageFlagBits; +typedef VkFlags VkShaderStageFlags; + +typedef enum { + VK_SUBPASS_DESCRIPTION_NO_OVERDRAW_BIT = 0x00000001, +} VkSubpassDescriptionFlagBits; +typedef VkFlags VkSubpassDescriptionFlags; + +typedef enum { + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, + VK_PIPELINE_STAGE_TESS_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESS_EVALUATION_SHADER_BIT = 0x00000020, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, + VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, + VK_PIPELINE_STAGE_TRANSITION_BIT = 0x00002000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_ALL_GRAPHICS = 0x000007FF, + VK_PIPELINE_STAGE_ALL_GPU_COMMANDS = 0x00003FFF, +} VkPipelineStageFlagBits; +typedef VkFlags VkPipelineStageFlags; + +typedef enum { + VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, + VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, + VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, + VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, + VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010, +} VkMemoryOutputFlagBits; +typedef VkFlags VkMemoryOutputFlags; + +typedef enum { + VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, + VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, + VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, + VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, + VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, + VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, + VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, + VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, + VK_MEMORY_INPUT_INPUT_ATTACHMENT_BIT = 0x00000100, + VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000200, +} VkMemoryInputFlagBits; +typedef VkFlags VkMemoryInputFlags; + +typedef enum { + VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, +} VkCmdPoolCreateFlagBits; +typedef VkFlags VkCmdPoolCreateFlags; + +typedef enum { + VK_CMD_POOL_RESET_RELEASE_RESOURCES = 0x00000001, +} VkCmdPoolResetFlagBits; +typedef VkFlags VkCmdPoolResetFlags; +typedef VkFlags VkCmdBufferCreateFlags; + +typedef enum { + VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001, + VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002, + VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004, + VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008, + VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010, +} VkCmdBufferOptimizeFlagBits; +typedef VkFlags VkCmdBufferOptimizeFlags; + +typedef enum { + VK_CMD_BUFFER_RESET_RELEASE_RESOURCES = 0x00000001, +} VkCmdBufferResetFlagBits; +typedef VkFlags VkCmdBufferResetFlags; + +typedef enum { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; + +typedef enum { + VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef struct { + VkStructureType sType; + const void* pNext; + const char* pAppName; + uint32_t appVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef void* (VKAPI *PFN_vkAllocFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocType allocType); + +typedef void (VKAPI *PFN_vkFreeFunction)( + void* pUserData, + void* pMem); + +typedef struct { + void* pUserData; + PFN_vkAllocFunction pfnAlloc; + PFN_vkFreeFunction pfnFree; +} VkAllocCallbacks; + +typedef struct { + VkStructureType sType; + const void* pNext; + const VkApplicationInfo* pAppInfo; + const VkAllocCallbacks* pAllocCb; + uint32_t layerCount; + const char*const* ppEnabledLayerNames; + uint32_t extensionCount; + const char*const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef struct { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSourceBlend; + VkBool32 logicOp; + VkBool32 instancedDrawIndirect; + VkBool32 depthClip; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexSideEffects; + VkBool32 tessellationSideEffects; + VkBool32 geometrySideEffects; + VkBool32 fragmentSideEffects; + VkBool32 shaderTessellationPointSize; + VkBool32 shaderGeometryPointSize; + VkBool32 shaderTextureGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageBufferArrayConstantIndexing; + VkBool32 shaderStorageImageArrayConstantIndexing; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderFloat16; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLOD; + VkBool32 sparse; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyStandard2DBlockShape; + VkBool32 sparseResidencyStandard2DMSBlockShape; + VkBool32 sparseResidencyStandard3DBlockShape; + VkBool32 sparseResidencyAlignedMipSize; + VkBool32 sparseResidencyNonResident; + VkBool32 sparseResidencyNonResidentStrict; + VkBool32 sparseResidencyAliased; +} VkPhysicalDeviceFeatures; + +typedef struct { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; +} VkFormatProperties; + +typedef struct { + uint64_t maxResourceSize; + uint32_t maxSamples; +} VkImageFormatProperties; + +typedef struct { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferSize; + uint32_t maxUniformBufferSize; + uint32_t maxStorageBufferSize; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + VkDeviceSize bufferImageGranularity; + uint32_t maxBoundDescriptorSets; + uint32_t maxDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessGenLevel; + uint32_t maxTessPatchSize; + uint32_t maxTessControlPerVertexInputComponents; + uint32_t maxTessControlPerVertexOutputComponents; + uint32_t maxTessControlPerPatchOutputComponents; + uint32_t maxTessControlTotalOutputComponents; + uint32_t maxTessEvaluationInputComponents; + uint32_t maxTessEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputBuffers; + uint32_t maxFragmentDualSourceBuffers; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectInstanceCount; + VkBool32 primitiveRestartForPatches; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxDynamicViewportStates; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + uint32_t minMemoryMapAlignment; + uint32_t minTexelBufferOffsetAlignment; + uint32_t minUniformBufferOffsetAlignment; + uint32_t minStorageBufferOffsetAlignment; + uint32_t minTexelOffset; + uint32_t maxTexelOffset; + uint32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + uint32_t maxFramebufferColorSamples; + uint32_t maxFramebufferDepthSamples; + uint32_t maxFramebufferStencilSamples; + uint32_t maxColorAttachments; + uint32_t maxSampledImageColorSamples; + uint32_t maxSampledImageDepthSamples; + uint32_t maxSampledImageIntegerSamples; + uint32_t maxStorageImageSamples; + uint32_t maxSampleMaskWords; + uint64_t timestampFrequency; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; +} VkPhysicalDeviceLimits; + +typedef struct { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorId; + uint32_t deviceId; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME]; + uint8_t pipelineCacheUUID[VK_UUID_LENGTH]; +} VkPhysicalDeviceProperties; + +typedef struct { + VkQueueFlags queueFlags; + uint32_t queueCount; + VkBool32 supportsTimestamps; +} VkPhysicalDeviceQueueProperties; + +typedef struct { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef void (VKAPI *PFN_vkVoidFunction)(void); +typedef struct { + uint32_t queueFamilyIndex; + uint32_t queueCount; +} VkDeviceQueueCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t queueRecordCount; + const VkDeviceQueueCreateInfo* pRequestedQueues; + uint32_t layerCount; + const char*const* ppEnabledLayerNames; + uint32_t extensionCount; + const char*const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; + VkDeviceCreateFlags flags; +} VkDeviceCreateInfo; + +typedef struct { + char extName[VK_MAX_EXTENSION_NAME]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct { + char layerName[VK_MAX_EXTENSION_NAME]; + uint32_t specVersion; + uint32_t implVersion; + char description[VK_MAX_DESCRIPTION]; +} VkLayerProperties; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDeviceMemory mem; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct { + int32_t width; + int32_t height; + int32_t depth; +} VkExtent3D; + +typedef struct { + VkImageAspect aspect; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct { + VkSparseImageFormatProperties formatProps; + uint32_t imageMipTailStartLOD; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} VkSparseImageMemoryRequirements; + +typedef struct { + VkDeviceSize rangeOffset; + VkDeviceSize rangeSize; + VkDeviceSize memOffset; + VkDeviceMemory mem; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBindInfo; + +typedef struct { + VkImageAspect aspect; + uint32_t mipLevel; + uint32_t arraySlice; +} VkImageSubresource; + +typedef struct { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct { + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceSize memOffset; + VkDeviceMemory mem; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBindInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkQueryType queryType; + uint32_t slots; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkBufferCreateFlags flags; + VkSharingMode sharingMode; + uint32_t queueFamilyCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkBufferViewType viewType; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arraySize; + uint32_t samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; + VkSharingMode sharingMode; + uint32_t queueFamilyCount; + const uint32_t* pQueueFamilyIndices; +} VkImageCreateInfo; + +typedef struct { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct { + VkChannelSwizzle r; + VkChannelSwizzle g; + VkChannelSwizzle b; + VkChannelSwizzle a; +} VkChannelMapping; + +typedef struct { + VkImageAspect aspect; + uint32_t baseMipLevel; + uint32_t mipLevels; + uint32_t baseArraySlice; + uint32_t arraySize; +} VkImageSubresourceRange; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkChannelMapping channels; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkImage image; + VkFormat format; + uint32_t mipLevel; + uint32_t baseArraySlice; + uint32_t arraySize; + VkAttachmentViewCreateFlags flags; +} VkAttachmentViewCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + size_t codeSize; + const void* pCode; + VkShaderModuleCreateFlags flags; +} VkShaderModuleCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkShaderModule module; + const char* pName; + VkShaderCreateFlags flags; +} VkShaderCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + size_t initialSize; + const void* initialData; + size_t maxSize; +} VkPipelineCacheCreateInfo; + +typedef struct { + uint32_t constantId; + size_t size; + uint32_t offset; +} VkSpecializationMapEntry; + +typedef struct { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMap; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkShaderStage stage; + VkShader shader; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct { + uint32_t binding; + uint32_t strideInBytes; + VkVertexInputStepRate stepRate; +} VkVertexInputBindingDescription; + +typedef struct { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offsetInBytes; +} VkVertexInputAttributeDescription; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t bindingCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t attributeCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t viewportCount; +} VkPipelineViewportStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBool32 depthClipEnable; + VkBool32 rasterizerDiscardEnable; + VkFillMode fillMode; + VkCullMode cullMode; + VkFrontFace frontFace; +} VkPipelineRasterStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t rasterSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + VkSampleMask sampleMask; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct { + VkStencilOp stencilFailOp; + VkStencilOp stencilPassOp; + VkStencilOp stencilDepthFailOp; + VkCompareOp stencilCompareOp; +} VkStencilOpState; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct { + VkBool32 blendEnable; + VkBlend srcBlendColor; + VkBlend destBlendColor; + VkBlendOp blendOpColor; + VkBlend srcBlendAlpha; + VkBlend destBlendAlpha; + VkBlendOp blendOpAlpha; + VkChannelFlags channelWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkBool32 alphaToCoverageEnable; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterStateCreateInfo* pRasterState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + VkPipelineCreateFlags flags; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateInfo cs; + VkPipelineCreateFlags flags; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct { + VkShaderStageFlags stageFlags; + uint32_t start; + uint32_t length; +} VkPushConstantRange; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkTexFilter magFilter; + VkTexFilter minFilter; + VkTexMipmapMode mipMode; + VkTexAddress addressU; + VkTexAddress addressV; + VkTexAddress addressW; + float mipLodBias; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; +} VkSamplerCreateInfo; + +typedef struct { + VkDescriptorType descriptorType; + uint32_t arraySize; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t count; + const VkDescriptorSetLayoutBinding* pBinding; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct { + VkDescriptorType type; + uint32_t count; +} VkDescriptorTypeCount; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t count; + const VkDescriptorTypeCount* pTypeCount; +} VkDescriptorPoolCreateInfo; + +typedef struct { + VkBufferView bufferView; + VkSampler sampler; + VkImageView imageView; + VkAttachmentView attachmentView; + VkImageLayout imageLayout; +} VkDescriptorInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDescriptorSet destSet; + uint32_t destBinding; + uint32_t destArrayElement; + uint32_t count; + VkDescriptorType descriptorType; + const VkDescriptorInfo* pDescriptors; +} VkWriteDescriptorSet; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet destSet; + uint32_t destBinding; + uint32_t destArrayElement; + uint32_t count; +} VkCopyDescriptorSet; + +typedef struct { + float originX; + float originY; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct { + int32_t width; + int32_t height; +} VkExtent2D; + +typedef struct { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t viewportAndScissorCount; + const VkViewport* pViewports; + const VkRect2D* pScissors; +} VkDynamicViewportStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + float depthBias; + float depthBiasClamp; + float slopeScaledDepthBias; + float lineWidth; +} VkDynamicRasterStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + float blendConst[4]; +} VkDynamicColorBlendStateCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + float minDepthBounds; + float maxDepthBounds; + uint32_t stencilReadMask; + uint32_t stencilWriteMask; + uint32_t stencilFrontRef; + uint32_t stencilBackRef; +} VkDynamicDepthStencilStateCreateInfo; + +typedef struct { + VkAttachmentView view; + VkImageLayout layout; +} VkAttachmentBindInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkAttachmentBindInfo* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkFormat format; + uint32_t samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkSubpassDescriptionFlags flags; + uint32_t inputCount; + const VkAttachmentReference* inputAttachments; + uint32_t colorCount; + const VkAttachmentReference* colorAttachments; + const VkAttachmentReference* resolveAttachments; + VkAttachmentReference depthStencilAttachment; + uint32_t preserveCount; + const VkAttachmentReference* preserveAttachments; +} VkSubpassDescription; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t srcSubpass; + uint32_t destSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags destStageMask; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; + VkBool32 byRegion; +} VkSubpassDependency; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + VkCmdPoolCreateFlags flags; +} VkCmdPoolCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkCmdPool cmdPool; + VkCmdBufferLevel level; + VkCmdBufferCreateFlags flags; +} VkCmdBufferCreateInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkCmdBufferOptimizeFlags flags; + VkRenderPass renderPass; + VkFramebuffer framebuffer; +} VkCmdBufferBeginInfo; + +typedef struct { + VkDeviceSize srcOffset; + VkDeviceSize destOffset; + VkDeviceSize copySize; +} VkBufferCopy; + +typedef struct { + VkImageSubresource srcSubresource; + VkOffset3D srcOffset; + VkImageSubresource destSubresource; + VkOffset3D destOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct { + VkImageSubresource srcSubresource; + VkOffset3D srcOffset; + VkExtent3D srcExtent; + VkImageSubresource destSubresource; + VkOffset3D destOffset; + VkExtent3D destExtent; +} VkImageBlit; + +typedef struct { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresource imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union { + float f32[4]; + int32_t s32[4]; + uint32_t u32[4]; +} VkClearColorValue; + +typedef struct { + VkOffset3D offset; + VkExtent3D extent; +} VkRect3D; + +typedef struct { + VkImageSubresource srcSubresource; + VkOffset3D srcOffset; + VkImageSubresource destSubresource; + VkOffset3D destOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union { + VkClearColorValue color; + VkClearDepthStencilValue ds; +} VkClearValue; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t attachmentCount; + const VkClearValue* pAttachmentClearValues; +} VkRenderPassBeginInfo; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; + uint32_t srcQueueFamilyIndex; + uint32_t destQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCmd; + +typedef struct { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCmd; + +typedef struct { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCmd; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t destQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct { + VkStructureType sType; + const void* pNext; + VkMemoryOutputFlags outputMask; + VkMemoryInputFlags inputMask; +} VkMemoryBarrier; + + +typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance); +typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance); +typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLimits)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueProperties)(VkPhysicalDevice physicalDevice, uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice); +typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device); +typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetGlobalLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence); +typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem); +typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem); +typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem); +typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); +typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges); +typedef VkResult (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset); +typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset); +typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef VkResult (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties); +typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); +typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo); +typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo); +typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence); +typedef VkResult (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore); +typedef VkResult (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore); +typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore); +typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore); +typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent); +typedef VkResult (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool); +typedef VkResult (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool); +typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags); +typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer); +typedef VkResult (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer); +typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView); +typedef VkResult (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView); +typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage); +typedef VkResult (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image); +typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView); +typedef VkResult (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView); +typedef VkResult (VKAPI *PFN_vkCreateAttachmentView)(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView); +typedef VkResult (VKAPI *PFN_vkDestroyAttachmentView)(VkDevice device, VkAttachmentView attachmentView); +typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule); +typedef VkResult (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule); +typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader); +typedef VkResult (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader); +typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache); +typedef VkResult (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache); +typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache); +typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData); +typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); +typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines); +typedef VkResult (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline); +typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout); +typedef VkResult (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout); +typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler); +typedef VkResult (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler); +typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout); +typedef VkResult (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout); +typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool); +typedef VkResult (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); +typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool); +typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount); +typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicViewportState)(VkDevice device, VkDynamicViewportState dynamicViewportState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicRasterState)(VkDevice device, VkDynamicRasterState dynamicRasterState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicColorBlendState)(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState); +typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState); +typedef VkResult (VKAPI *PFN_vkDestroyDynamicDepthStencilState)(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState); +typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer); +typedef VkResult (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer); +typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass); +typedef VkResult (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass); +typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool); +typedef VkResult (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool); +typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags); +typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer); +typedef VkResult (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer); +typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer); +typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags); +typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI *PFN_vkCmdBindDynamicViewportState)(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState); +typedef void (VKAPI *PFN_vkCmdBindDynamicRasterState)(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState); +typedef void (VKAPI *PFN_vkCmdBindDynamicColorBlendState)(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState); +typedef void (VKAPI *PFN_vkCmdBindDynamicDepthStencilState)(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState); +typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); +typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); +typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride); +typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z); +typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter); +typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData); +typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data); +typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI *PFN_vkCmdClearColorAttachment)(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects); +typedef void (VKAPI *PFN_vkCmdClearDepthStencilAttachment)(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects); +typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers); +typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers); +typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags); +typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot); +typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount); +typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset); +typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags); +typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values); +typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents); +typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents); +typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer); +typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers); + +#ifdef VK_PROTOTYPES +VkResult VKAPI vkCreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + VkInstance* pInstance); + +VkResult VKAPI vkDestroyInstance( + VkInstance instance); + +VkResult VKAPI vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VkResult VKAPI vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VkResult VKAPI vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageFormatProperties* pImageFormatProperties); + +VkResult VKAPI vkGetPhysicalDeviceLimits( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceLimits* pLimits); + +VkResult VKAPI vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VkResult VKAPI vkGetPhysicalDeviceQueueCount( + VkPhysicalDevice physicalDevice, + uint32_t* pCount); + +VkResult VKAPI vkGetPhysicalDeviceQueueProperties( + VkPhysicalDevice physicalDevice, + uint32_t count, + VkPhysicalDeviceQueueProperties* pQueueProperties); + +VkResult VKAPI vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr( + VkInstance instance, + const char* pName); + +PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr( + VkDevice device, + const char* pName); + +VkResult VKAPI vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + VkDevice* pDevice); + +VkResult VKAPI vkDestroyDevice( + VkDevice device); + +VkResult VKAPI vkGetGlobalExtensionProperties( + const char* pLayerName, + uint32_t* pCount, + VkExtensionProperties* pProperties); + +VkResult VKAPI vkGetPhysicalDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pCount, + VkExtensionProperties* pProperties); + +VkResult VKAPI vkGetGlobalLayerProperties( + uint32_t* pCount, + VkLayerProperties* pProperties); + +VkResult VKAPI vkGetPhysicalDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pCount, + VkLayerProperties* pProperties); + +VkResult VKAPI vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VkResult VKAPI vkQueueSubmit( + VkQueue queue, + uint32_t cmdBufferCount, + const VkCmdBuffer* pCmdBuffers, + VkFence fence); + +VkResult VKAPI vkQueueWaitIdle( + VkQueue queue); + +VkResult VKAPI vkDeviceWaitIdle( + VkDevice device); + +VkResult VKAPI vkAllocMemory( + VkDevice device, + const VkMemoryAllocInfo* pAllocInfo, + VkDeviceMemory* pMem); + +VkResult VKAPI vkFreeMemory( + VkDevice device, + VkDeviceMemory mem); + +VkResult VKAPI vkMapMemory( + VkDevice device, + VkDeviceMemory mem, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +VkResult VKAPI vkUnmapMemory( + VkDevice device, + VkDeviceMemory mem); + +VkResult VKAPI vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memRangeCount, + const VkMappedMemoryRange* pMemRanges); + +VkResult VKAPI vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memRangeCount, + const VkMappedMemoryRange* pMemRanges); + +VkResult VKAPI vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VkResult VKAPI vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory mem, + VkDeviceSize memOffset); + +VkResult VKAPI vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory mem, + VkDeviceSize memOffset); + +VkResult VKAPI vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VkResult VKAPI vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VkResult VKAPI vkGetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pNumRequirements, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + uint32_t samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pNumProperties, + VkSparseImageFormatProperties* pProperties); + +VkResult VKAPI vkQueueBindSparseBufferMemory( + VkQueue queue, + VkBuffer buffer, + uint32_t numBindings, + const VkSparseMemoryBindInfo* pBindInfo); + +VkResult VKAPI vkQueueBindSparseImageOpaqueMemory( + VkQueue queue, + VkImage image, + uint32_t numBindings, + const VkSparseMemoryBindInfo* pBindInfo); + +VkResult VKAPI vkQueueBindSparseImageMemory( + VkQueue queue, + VkImage image, + uint32_t numBindings, + const VkSparseImageMemoryBindInfo* pBindInfo); + +VkResult VKAPI vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + VkFence* pFence); + +VkResult VKAPI vkDestroyFence( + VkDevice device, + VkFence fence); + +VkResult VKAPI vkResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +VkResult VKAPI vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VkResult VKAPI vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VkResult VKAPI vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + VkSemaphore* pSemaphore); + +VkResult VKAPI vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore); + +VkResult VKAPI vkQueueSignalSemaphore( + VkQueue queue, + VkSemaphore semaphore); + +VkResult VKAPI vkQueueWaitSemaphore( + VkQueue queue, + VkSemaphore semaphore); + +VkResult VKAPI vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + VkEvent* pEvent); + +VkResult VKAPI vkDestroyEvent( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkGetEventStatus( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkSetEvent( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkResetEvent( + VkDevice device, + VkEvent event); + +VkResult VKAPI vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + VkQueryPool* pQueryPool); + +VkResult VKAPI vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool); + +VkResult VKAPI vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount, + size_t* pDataSize, + void* pData, + VkQueryResultFlags flags); + +VkResult VKAPI vkCreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + VkBuffer* pBuffer); + +VkResult VKAPI vkDestroyBuffer( + VkDevice device, + VkBuffer buffer); + +VkResult VKAPI vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + VkBufferView* pView); + +VkResult VKAPI vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView); + +VkResult VKAPI vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + VkImage* pImage); + +VkResult VKAPI vkDestroyImage( + VkDevice device, + VkImage image); + +VkResult VKAPI vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +VkResult VKAPI vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + VkImageView* pView); + +VkResult VKAPI vkDestroyImageView( + VkDevice device, + VkImageView imageView); + +VkResult VKAPI vkCreateAttachmentView( + VkDevice device, + const VkAttachmentViewCreateInfo* pCreateInfo, + VkAttachmentView* pView); + +VkResult VKAPI vkDestroyAttachmentView( + VkDevice device, + VkAttachmentView attachmentView); + +VkResult VKAPI vkCreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModule* pShaderModule); + +VkResult VKAPI vkDestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule); + +VkResult VKAPI vkCreateShader( + VkDevice device, + const VkShaderCreateInfo* pCreateInfo, + VkShader* pShader); + +VkResult VKAPI vkDestroyShader( + VkDevice device, + VkShader shader); + +VkResult VKAPI vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + VkPipelineCache* pPipelineCache); + +VkResult VKAPI vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache); + +size_t VKAPI vkGetPipelineCacheSize( + VkDevice device, + VkPipelineCache pipelineCache); + +VkResult VKAPI vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + void* pData); + +VkResult VKAPI vkMergePipelineCaches( + VkDevice device, + VkPipelineCache destCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +VkResult VKAPI vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t count, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines); + +VkResult VKAPI vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t count, + const VkComputePipelineCreateInfo* pCreateInfos, + VkPipeline* pPipelines); + +VkResult VKAPI vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline); + +VkResult VKAPI vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + VkPipelineLayout* pPipelineLayout); + +VkResult VKAPI vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout); + +VkResult VKAPI vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + VkSampler* pSampler); + +VkResult VKAPI vkDestroySampler( + VkDevice device, + VkSampler sampler); + +VkResult VKAPI vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayout* pSetLayout); + +VkResult VKAPI vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout); + +VkResult VKAPI vkCreateDescriptorPool( + VkDevice device, + VkDescriptorPoolUsage poolUsage, + uint32_t maxSets, + const VkDescriptorPoolCreateInfo* pCreateInfo, + VkDescriptorPool* pDescriptorPool); + +VkResult VKAPI vkDestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool); + +VkResult VKAPI vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool); + +VkResult VKAPI vkAllocDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorSetUsage setUsage, + uint32_t count, + const VkDescriptorSetLayout* pSetLayouts, + VkDescriptorSet* pDescriptorSets, + uint32_t* pCount); + +VkResult VKAPI vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t count, + const VkDescriptorSet* pDescriptorSets); + +VkResult VKAPI vkUpdateDescriptorSets( + VkDevice device, + uint32_t writeCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t copyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +VkResult VKAPI vkCreateDynamicViewportState( + VkDevice device, + const VkDynamicViewportStateCreateInfo* pCreateInfo, + VkDynamicViewportState* pState); + +VkResult VKAPI vkDestroyDynamicViewportState( + VkDevice device, + VkDynamicViewportState dynamicViewportState); + +VkResult VKAPI vkCreateDynamicRasterState( + VkDevice device, + const VkDynamicRasterStateCreateInfo* pCreateInfo, + VkDynamicRasterState* pState); + +VkResult VKAPI vkDestroyDynamicRasterState( + VkDevice device, + VkDynamicRasterState dynamicRasterState); + +VkResult VKAPI vkCreateDynamicColorBlendState( + VkDevice device, + const VkDynamicColorBlendStateCreateInfo* pCreateInfo, + VkDynamicColorBlendState* pState); + +VkResult VKAPI vkDestroyDynamicColorBlendState( + VkDevice device, + VkDynamicColorBlendState dynamicColorBlendState); + +VkResult VKAPI vkCreateDynamicDepthStencilState( + VkDevice device, + const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, + VkDynamicDepthStencilState* pState); + +VkResult VKAPI vkDestroyDynamicDepthStencilState( + VkDevice device, + VkDynamicDepthStencilState dynamicDepthStencilState); + +VkResult VKAPI vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + VkFramebuffer* pFramebuffer); + +VkResult VKAPI vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer); + +VkResult VKAPI vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + VkRenderPass* pRenderPass); + +VkResult VKAPI vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass); + +VkResult VKAPI vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VkResult VKAPI vkCreateCommandPool( + VkDevice device, + const VkCmdPoolCreateInfo* pCreateInfo, + VkCmdPool* pCmdPool); + +VkResult VKAPI vkDestroyCommandPool( + VkDevice device, + VkCmdPool cmdPool); + +VkResult VKAPI vkResetCommandPool( + VkDevice device, + VkCmdPool cmdPool, + VkCmdPoolResetFlags flags); + +VkResult VKAPI vkCreateCommandBuffer( + VkDevice device, + const VkCmdBufferCreateInfo* pCreateInfo, + VkCmdBuffer* pCmdBuffer); + +VkResult VKAPI vkDestroyCommandBuffer( + VkDevice device, + VkCmdBuffer commandBuffer); + +VkResult VKAPI vkBeginCommandBuffer( + VkCmdBuffer cmdBuffer, + const VkCmdBufferBeginInfo* pBeginInfo); + +VkResult VKAPI vkEndCommandBuffer( + VkCmdBuffer cmdBuffer); + +VkResult VKAPI vkResetCommandBuffer( + VkCmdBuffer cmdBuffer, + VkCmdBufferResetFlags flags); + +void VKAPI vkCmdBindPipeline( + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +void VKAPI vkCmdBindDynamicViewportState( + VkCmdBuffer cmdBuffer, + VkDynamicViewportState dynamicViewportState); + +void VKAPI vkCmdBindDynamicRasterState( + VkCmdBuffer cmdBuffer, + VkDynamicRasterState dynamicRasterState); + +void VKAPI vkCmdBindDynamicColorBlendState( + VkCmdBuffer cmdBuffer, + VkDynamicColorBlendState dynamicColorBlendState); + +void VKAPI vkCmdBindDynamicDepthStencilState( + VkCmdBuffer cmdBuffer, + VkDynamicDepthStencilState dynamicDepthStencilState); + +void VKAPI vkCmdBindDescriptorSets( + VkCmdBuffer cmdBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +void VKAPI vkCmdBindIndexBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +void VKAPI vkCmdBindVertexBuffers( + VkCmdBuffer cmdBuffer, + uint32_t startBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +void VKAPI vkCmdDraw( + VkCmdBuffer cmdBuffer, + uint32_t firstVertex, + uint32_t vertexCount, + uint32_t firstInstance, + uint32_t instanceCount); + +void VKAPI vkCmdDrawIndexed( + VkCmdBuffer cmdBuffer, + uint32_t firstIndex, + uint32_t indexCount, + int32_t vertexOffset, + uint32_t firstInstance, + uint32_t instanceCount); + +void VKAPI vkCmdDrawIndirect( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t count, + uint32_t stride); + +void VKAPI vkCmdDrawIndexedIndirect( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t count, + uint32_t stride); + +void VKAPI vkCmdDispatch( + VkCmdBuffer cmdBuffer, + uint32_t x, + uint32_t y, + uint32_t z); + +void VKAPI vkCmdDispatchIndirect( + VkCmdBuffer cmdBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +void VKAPI vkCmdCopyBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkBuffer destBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +void VKAPI vkCmdCopyImage( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +void VKAPI vkCmdBlitImage( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkTexFilter filter); + +void VKAPI vkCmdCopyBufferToImage( + VkCmdBuffer cmdBuffer, + VkBuffer srcBuffer, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +void VKAPI vkCmdCopyImageToBuffer( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer destBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +void VKAPI vkCmdUpdateBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer destBuffer, + VkDeviceSize destOffset, + VkDeviceSize dataSize, + const uint32_t* pData); + +void VKAPI vkCmdFillBuffer( + VkCmdBuffer cmdBuffer, + VkBuffer destBuffer, + VkDeviceSize destOffset, + VkDeviceSize fillSize, + uint32_t data); + +void VKAPI vkCmdClearColorImage( + VkCmdBuffer cmdBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +void VKAPI vkCmdClearDepthStencilImage( + VkCmdBuffer cmdBuffer, + VkImage image, + VkImageLayout imageLayout, + float depth, + uint32_t stencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +void VKAPI vkCmdClearColorAttachment( + VkCmdBuffer cmdBuffer, + uint32_t colorAttachment, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rectCount, + const VkRect3D* pRects); + +void VKAPI vkCmdClearDepthStencilAttachment( + VkCmdBuffer cmdBuffer, + VkImageAspectFlags imageAspectMask, + VkImageLayout imageLayout, + float depth, + uint32_t stencil, + uint32_t rectCount, + const VkRect3D* pRects); + +void VKAPI vkCmdResolveImage( + VkCmdBuffer cmdBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage destImage, + VkImageLayout destImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +void VKAPI vkCmdSetEvent( + VkCmdBuffer cmdBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +void VKAPI vkCmdResetEvent( + VkCmdBuffer cmdBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +void VKAPI vkCmdWaitEvents( + VkCmdBuffer cmdBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags destStageMask, + uint32_t memBarrierCount, + const void* const* ppMemBarriers); + +void VKAPI vkCmdPipelineBarrier( + VkCmdBuffer cmdBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags destStageMask, + VkBool32 byRegion, + uint32_t memBarrierCount, + const void* const* ppMemBarriers); + +void VKAPI vkCmdBeginQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot, + VkQueryControlFlags flags); + +void VKAPI vkCmdEndQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot); + +void VKAPI vkCmdResetQueryPool( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount); + +void VKAPI vkCmdWriteTimestamp( + VkCmdBuffer cmdBuffer, + VkTimestampType timestampType, + VkBuffer destBuffer, + VkDeviceSize destOffset); + +void VKAPI vkCmdCopyQueryPoolResults( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount, + VkBuffer destBuffer, + VkDeviceSize destOffset, + VkDeviceSize destStride, + VkQueryResultFlags flags); + +void VKAPI vkCmdPushConstants( + VkCmdBuffer cmdBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t start, + uint32_t length, + const void* values); + +void VKAPI vkCmdBeginRenderPass( + VkCmdBuffer cmdBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkRenderPassContents contents); + +void VKAPI vkCmdNextSubpass( + VkCmdBuffer cmdBuffer, + VkRenderPassContents contents); + +void VKAPI vkCmdEndRenderPass( + VkCmdBuffer cmdBuffer); + +void VKAPI vkCmdExecuteCommands( + VkCmdBuffer cmdBuffer, + uint32_t cmdBuffersCount, + const VkCmdBuffer* pCmdBuffers); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_extension_utils.h b/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_extension_utils.h new file mode 100644 index 000000000..90a9c7709 --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_extension_utils.h @@ -0,0 +1,54 @@ +/* + * Vulkan + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Courtney Goeltzenleuchter + */ + +#include "vk_layer.h" + +#ifndef LAYER_EXTENSION_UTILS_H +#define LAYER_EXTENSION_UTILS_H + +#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) + +/* + * This file contains static functions for the generated layers + */ +extern "C" { + +VkResult util_GetExtensionProperties( + const uint32_t count, + const VkExtensionProperties *layer_extensions, + uint32_t* pCount, + VkExtensionProperties* pProperties); + +VkResult util_GetLayerProperties( + const uint32_t count, + const VkLayerProperties *layer_properties, + uint32_t* pCount, + VkLayerProperties* pProperties); + +} // extern "C" +#endif // LAYER_EXTENSION_UTILS_H + diff --git a/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.cpp b/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.cpp new file mode 100644 index 000000000..5dca1c750 --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.cpp @@ -0,0 +1,198 @@ +/* + * Vulkan + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +#include +#include +#include "vk_dispatch_table_helper.h" +#include "vk_layer.h" +#include "vk_layer_table.h" +static device_table_map tableMap; +static instance_table_map tableInstanceMap; + +#define DISPATCH_MAP_DEBUG 0 + +// Map lookup must be thread safe +VkLayerDispatchTable *device_dispatch_table(void* object) +{ + dispatch_key key = get_dispatch_key(object); + device_table_map::const_iterator it = tableMap.find((void *) key); + assert(it != tableMap.end() && "Not able to find device dispatch entry"); + return it->second; +} + +VkLayerInstanceDispatchTable *instance_dispatch_table(void* object) +{ + dispatch_key key = get_dispatch_key(object); + instance_table_map::const_iterator it = tableInstanceMap.find((void *) key); +#if DISPATCH_MAP_DEBUG + if (it != tableInstanceMap.end()) { + fprintf(stderr, "instance_dispatch_table: map: %p, object: %p, key: %p, table: %p\n", &tableInstanceMap, object, key, it->second); + } else { + fprintf(stderr, "instance_dispatch_table: map: %p, object: %p, key: %p, table: UNKNOWN\n", &tableInstanceMap, object, key); + } +#endif + assert(it != tableInstanceMap.end() && "Not able to find instance dispatch entry"); + return it->second; +} + +void destroy_dispatch_table(device_table_map &map, dispatch_key key) +{ + device_table_map::const_iterator it = map.find((void *) key); +#if DISPATCH_MAP_DEBUG + if (it != map.end()) { + fprintf(stderr, "destroy device dispatch_table: map: %p, key: %p, table: %p\n", &map, key, it->second); + } else { + fprintf(stderr, "destroy device dispatch table: map: %p, key: %p, table: UNKNOWN\n", &map, key); + assert(it != map.end()); + } +#endif + map.erase(key); +} + +void destroy_dispatch_table(instance_table_map &map, dispatch_key key) +{ + instance_table_map::const_iterator it = map.find((void *) key); +#if DISPATCH_MAP_DEBUG + if (it != map.end()) { + fprintf(stderr, "destroy instance dispatch_table: map: %p, key: %p, table: %p\n", &map, key, it->second); + } else { + fprintf(stderr, "destroy instance dispatch table: map: %p, key: %p, table: UNKNOWN\n", &map, key); + assert(it != map.end()); + } +#endif + map.erase(key); +} + +void destroy_device_dispatch_table(dispatch_key key) +{ + destroy_dispatch_table(tableMap, key); +} + +void destroy_instance_dispatch_table(dispatch_key key) +{ + destroy_dispatch_table(tableInstanceMap, key); +} + +VkLayerDispatchTable *get_dispatch_table(device_table_map &map, void* object) +{ + dispatch_key key = get_dispatch_key(object); + device_table_map::const_iterator it = map.find((void *) key); +#if DISPATCH_MAP_DEBUG + if (it != map.end()) { + fprintf(stderr, "instance_dispatch_table: map: %p, object: %p, key: %p, table: %p\n", &tableInstanceMap, object, key, it->second); + } else { + fprintf(stderr, "instance_dispatch_table: map: %p, object: %p, key: %p, table: UNKNOWN\n", &tableInstanceMap, object, key); + } +#endif + assert(it != map.end() && "Not able to find device dispatch entry"); + return it->second; +} + +VkLayerInstanceDispatchTable *get_dispatch_table(instance_table_map &map, void* object) +{ +// VkLayerInstanceDispatchTable *pDisp = *(VkLayerInstanceDispatchTable **) object; + dispatch_key key = get_dispatch_key(object); + instance_table_map::const_iterator it = map.find((void *) key); +#if DISPATCH_MAP_DEBUG + if (it != map.end()) { + fprintf(stderr, "instance_dispatch_table: map: %p, object: %p, key: %p, table: %p\n", &tableInstanceMap, object, key, it->second); + } else { + fprintf(stderr, "instance_dispatch_table: map: %p, object: %p, key: %p, table: UNKNOWN\n", &tableInstanceMap, object, key); + } +#endif + assert(it != map.end() && "Not able to find instance dispatch entry"); + return it->second; +} + +/* Various dispatchable objects will use the same underlying dispatch table if they + * are created from that "parent" object. Thus use pointer to dispatch table + * as the key to these table maps. + * Instance -> PhysicalDevice + * Device -> CmdBuffer or Queue + * If use the object themselves as key to map then implies Create entrypoints have to be intercepted + * and a new key inserted into map */ +VkLayerInstanceDispatchTable * initInstanceTable(instance_table_map &map, const VkBaseLayerObject *instancew) +{ + VkLayerInstanceDispatchTable *pTable; + assert(instancew); + VkLayerInstanceDispatchTable **ppDisp = (VkLayerInstanceDispatchTable **) instancew->baseObject; + + std::unordered_map::const_iterator it = map.find((void *) *ppDisp); + if (it == map.end()) + { + pTable = new VkLayerInstanceDispatchTable; + map[(void *) *ppDisp] = pTable; +#if DISPATCH_MAP_DEBUG + fprintf(stderr, "New, Instance: map: %p, base object: %p, key: %p, table: %p\n", &map, instancew, *ppDisp, pTable); +#endif + assert(map.size() <= 1 && "Instance dispatch table map has more than one entry"); + } else + { +#if DISPATCH_MAP_DEBUG + fprintf(stderr, "Instance: map: %p, base object: %p, key: %p, table: %p\n", &map, instancew, *ppDisp, it->second); +#endif + return it->second; + } + + layer_init_instance_dispatch_table(pTable, instancew); + + return pTable; +} + +VkLayerInstanceDispatchTable * initInstanceTable(const VkBaseLayerObject *instancew) +{ + return initInstanceTable(tableInstanceMap, instancew); +} + +VkLayerDispatchTable * initDeviceTable(device_table_map &map, const VkBaseLayerObject *devw) +{ + VkLayerDispatchTable *layer_device_table = NULL; + assert(devw); + VkLayerDispatchTable **ppDisp = (VkLayerDispatchTable **) (devw->baseObject); + VkLayerDispatchTable *base_device_table = *ppDisp; + + std::unordered_map::const_iterator it = map.find((void *) base_device_table); + if (it == map.end()) + { + layer_device_table = new VkLayerDispatchTable; + map[(void *) base_device_table] = layer_device_table; +#if DISPATCH_MAP_DEBUG + fprintf(stderr, "New, Device: map: %p, base object: %p, key: %p, table: %p\n", &map, devw, *ppDisp, layer_device_table); +#endif + } else + { +#if DISPATCH_MAP_DEBUG + fprintf(stderr, "Device: map: %p, base object: %p, key: %p, table: %p\n", &map, devw, *ppDisp, it->second); +#endif + return it->second; + } + + layer_initialize_dispatch_table(layer_device_table, devw); + + return layer_device_table; +} + +VkLayerDispatchTable * initDeviceTable(const VkBaseLayerObject *devw) +{ + return initDeviceTable(tableMap, devw); +} diff --git a/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.h b/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.h new file mode 100644 index 000000000..fbf2a8cdc --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.h @@ -0,0 +1,51 @@ +/* + * Vulkan + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +#pragma once + +#include + +typedef std::unordered_map device_table_map; +typedef std::unordered_map instance_table_map; +VkLayerDispatchTable * initDeviceTable(const VkBaseLayerObject *devw); +VkLayerDispatchTable * initDeviceTable(device_table_map &map, const VkBaseLayerObject *devw); +VkLayerInstanceDispatchTable * initInstanceTable(const VkBaseLayerObject *instancew); +VkLayerInstanceDispatchTable * initInstanceTable(instance_table_map &map, const VkBaseLayerObject *instancew); + +typedef void *dispatch_key; + +static inline dispatch_key get_dispatch_key(const void* object) +{ + return (dispatch_key) *(VkLayerDispatchTable **) object; +} + +VkLayerDispatchTable *device_dispatch_table(void* object); + +VkLayerInstanceDispatchTable *instance_dispatch_table(void* object); + +VkLayerDispatchTable *get_dispatch_table(device_table_map &map, void* object); + +VkLayerInstanceDispatchTable *get_dispatch_table(instance_table_map &map, void* object); + +void destroy_device_dispatch_table(dispatch_key key); +void destroy_instance_dispatch_table(dispatch_key key); diff --git a/renderdoc/driver/vulkan/LoaderAndTools/loader/vk_loader_platform.h b/renderdoc/driver/vulkan/LoaderAndTools/loader/vk_loader_platform.h new file mode 100644 index 000000000..4e586075c --- /dev/null +++ b/renderdoc/driver/vulkan/LoaderAndTools/loader/vk_loader_platform.h @@ -0,0 +1,423 @@ +/* + * Vulkan + * + * Copyright (C) 2015 LunarG, Inc. + * Copyright 2014 Valve Software + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Jon Ashburn + * Ian Elliott + */ + +#ifndef LOADER_PLATFORM_H +#define LOADER_PLATFORM_H + +#include "vk_platform.h" + +#if defined(__linux__) +/* Linux-specific common code: */ + +// Headers: +//#define _GNU_SOURCE 1 +// TBD: Are the contents of the following file used? +#include +// Note: The following file is for dynamic loading: +#include +#include +#include +#include +#include + +// VK Library Filenames, Paths, etc.: +#define PATH_SEPERATOR ':' +#define DIRECTORY_SYMBOL '/' + +// TODO: Need to handle different Linux distros +#define DEFAULT_VK_DRIVERS_INFO "/etc/vulkan/icd.d:/usr/share/vulkan/icd.d" +#define DEFAULT_VK_DRIVERS_PATH "/usr/lib/i386-linux-gnu/vulkan/icd:/usr/lib/x86_64-linux-gnu/vulkan/icd" +#define DEFAULT_VK_LAYERS_INFO "/etc/vulkan/explicit_layer.d:/etc/vulkan/implicit_layer.d:/usr/share/vulkan/explicit_layer.d:/usr/share/vulkan/implicit_layer.d" +#define DEFAULT_VK_LAYERS_PATH "/usr/lib/i386-linux-gnu/vulkan/layer:/usr/lib/x86_64-linux-gnu/vulkan/layer" +#define LAYERS_PATH_ENV "VK_LAYER_DIRS" + +// C99: +#define PRINTF_SIZE_T_SPECIFIER "%zu" + +// File IO +static inline bool loader_platform_file_exists(const char *path) +{ + if (access(path, F_OK)) + return false; + else + return true; +} + +static inline bool loader_platform_is_path_absolute(const char *path) +{ + if (path[0] == '/') + return true; + else + return false; +} + +static inline char *loader_platform_dirname(char *path) +{ + return dirname(path); +} + +// Dynamic Loading of libraries: +typedef void * loader_platform_dl_handle; +static inline loader_platform_dl_handle loader_platform_open_library(const char* libPath) +{ + return dlopen(libPath, RTLD_LAZY | RTLD_LOCAL); +} +static inline char * loader_platform_open_library_error(const char* libPath) +{ + return dlerror(); +} +static inline void loader_platform_close_library(loader_platform_dl_handle library) +{ + dlclose(library); +} +static inline void * loader_platform_get_proc_address(loader_platform_dl_handle library, + const char *name) +{ + assert(library); + assert(name); + return dlsym(library, name); +} +static inline char * loader_platform_get_proc_address_error(const char *name) +{ + return dlerror(); +} + +// Threads: +typedef pthread_t loader_platform_thread; +#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var) \ + pthread_once_t var = PTHREAD_ONCE_INIT; +#define LOADER_PLATFORM_THREAD_ONCE_DEFINITION(var) \ + pthread_once_t var; +static inline void loader_platform_thread_once(void *ctl, void (* func) (void)) +{ + assert(func != NULL); + assert(ctl != NULL); + pthread_once((pthread_once_t *) ctl, func); +} + +// Thread IDs: +typedef pthread_t loader_platform_thread_id; +static inline loader_platform_thread_id loader_platform_get_thread_id() +{ + return pthread_self(); +} + +// Thread mutex: +typedef pthread_mutex_t loader_platform_thread_mutex; +static inline void loader_platform_thread_create_mutex(loader_platform_thread_mutex* pMutex) +{ + pthread_mutex_init(pMutex, NULL); +} +static inline void loader_platform_thread_lock_mutex(loader_platform_thread_mutex* pMutex) +{ + pthread_mutex_lock(pMutex); +} +static inline void loader_platform_thread_unlock_mutex(loader_platform_thread_mutex* pMutex) +{ + pthread_mutex_unlock(pMutex); +} +static inline void loader_platform_thread_delete_mutex(loader_platform_thread_mutex* pMutex) +{ + pthread_mutex_destroy(pMutex); +} +typedef pthread_cond_t loader_platform_thread_cond; +static inline void loader_platform_thread_init_cond(loader_platform_thread_cond* pCond) +{ + pthread_cond_init(pCond, NULL); +} +static inline void loader_platform_thread_cond_wait(loader_platform_thread_cond* pCond, loader_platform_thread_mutex* pMutex) +{ + pthread_cond_wait(pCond, pMutex); +} +static inline void loader_platform_thread_cond_broadcast(loader_platform_thread_cond* pCond) +{ + pthread_cond_broadcast(pCond); +} + +#define loader_stack_alloc(size) alloca(size) +static inline void *loader_aligned_alloc(size_t alignment, size_t size) { return aligned_alloc(alignment, size); } + +#elif defined(_WIN32) // defined(__linux__) +/* Windows-specific common code: */ + +// Headers: +#include +#include +#include +#include +#include +#include +#include +#ifdef __cplusplus +#include +#include +using namespace std; +#endif // __cplusplus + +// VK Library Filenames, Paths, etc.: +#define PATH_SEPERATOR ';' +#define DIRECTORY_SYMBOL '\\' +#define DEFAULT_VK_REGISTRY_HIVE HKEY_LOCAL_MACHINE +#define DEFAULT_VK_DRIVERS_INFO "SOFTWARE\\Khronos\\Vulkan\\Drivers" +// TODO: Are these the correct paths +#define DEFAULT_VK_DRIVERS_PATH "C:\\Windows\\System32;C:\\Windows\\SysWow64" +#define DEFAULT_VK_LAYERS_INFO "SOFTWARE\\Khronos\\Vulkan\\ExplicitLayers;SOFTWARE\\Khronos\\Vulkan\\ImplicitLayers" +#define DEFAULT_VK_LAYERS_PATH "C:\\Windows\\System32;C:\\Windows\\SysWow64" +#define LAYERS_PATH_ENV "VK_LAYER_FOLDERS" + +// C99: +// Microsoft didn't implement C99 in Visual Studio; but started adding it with +// VS2013. However, VS2013 still didn't have snprintf(). The following is a +// work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the +// "CMakeLists.txt" file). +#define snprintf _snprintf +#define strdup _strdup +#define PRINTF_SIZE_T_SPECIFIER "%Iu" + + +// File IO +static bool loader_platform_file_exists(const char *path) +{ + if ((_access(path, 0)) == -1) + return false; + else + return true; +} + +static bool loader_platform_is_path_absolute(const char *path) +{ + return !PathIsRelative(path); +} + +// WIN32 runtime doesn't have dirname(). +static inline char *loader_platform_dirname(char *path) +{ + char *current, *next; + + // TODO/TBD: Do we need to deal with the Windows's ":" character? + + for (current = path; *current != '\0'; current = next) { + next = strchr(current, DIRECTORY_SYMBOL); + if (next == NULL) { + if (current != path) + *(current - 1) = '\0'; + return path; + } else { + // Point one character past the DIRECTORY_SYMBOL: + next++; + } + } + return path; +} + +// WIN32 runtime doesn't have basename(). +// Microsoft also doesn't have basename(). Paths are different on Windows, and +// so this is just a temporary solution in order to get us compiling, so that we +// can test some scenarios, and develop the correct solution for Windows. + // TODO: Develop a better, permanent solution for Windows, to replace this + // temporary code: +static char *loader_platform_basename(char *pathname) +{ + char *current, *next; + +// TODO/TBD: Do we need to deal with the Windows's ":" character? + + for (current = pathname; *current != '\0'; current = next) { + next = strchr(current, DIRECTORY_SYMBOL); + if (next == NULL) { + // No more DIRECTORY_SYMBOL's so return p: + return current; + } else { + // Point one character past the DIRECTORY_SYMBOL: + next++; + } + } + // We shouldn't get to here, but this makes the compiler happy: + return current; +} + +// Dynamic Loading: +typedef HMODULE loader_platform_dl_handle; +static loader_platform_dl_handle loader_platform_open_library(const char* libPath) +{ + return LoadLibrary(libPath); +} +static char * loader_platform_open_library_error(const char* libPath) +{ + static char errorMsg[120]; + snprintf(errorMsg, 119, "Failed to open dynamic library \"%s\"", libPath); + return errorMsg; +} +static void loader_platform_close_library(loader_platform_dl_handle library) +{ + FreeLibrary(library); +} +static void * loader_platform_get_proc_address(loader_platform_dl_handle library, + const char *name) +{ + assert(library); + assert(name); + return GetProcAddress(library, name); +} +static char * loader_platform_get_proc_address_error(const char *name) +{ + static char errorMsg[120]; + snprintf(errorMsg, 119, "Failed to find function \"%s\" in dynamic library", name); + return errorMsg; +} + +// Threads: +typedef HANDLE loader_platform_thread; +#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var) \ + INIT_ONCE var = INIT_ONCE_STATIC_INIT; +#define LOADER_PLATFORM_THREAD_ONCE_DEFINITION(var) \ + INIT_ONCE var; +static BOOL CALLBACK InitFuncWrapper(PINIT_ONCE InitOnce, PVOID Parameter, PVOID *Context) +{ + void (*func)(void) = (void (*)(void))Parameter; + func(); + return TRUE; +} + +static void loader_platform_thread_once(void *ctl, void (* func) (void)) +{ + assert(func != NULL); + assert(ctl != NULL); + InitOnceExecuteOnce((PINIT_ONCE) ctl, InitFuncWrapper, func, NULL); +} + +// Thread IDs: +typedef DWORD loader_platform_thread_id; +static loader_platform_thread_id loader_platform_get_thread_id() +{ + return GetCurrentThreadId(); +} + +// Thread mutex: +typedef CRITICAL_SECTION loader_platform_thread_mutex; +static void loader_platform_thread_create_mutex(loader_platform_thread_mutex* pMutex) +{ + InitializeCriticalSection(pMutex); +} +static void loader_platform_thread_lock_mutex(loader_platform_thread_mutex* pMutex) +{ + EnterCriticalSection(pMutex); +} +static void loader_platform_thread_unlock_mutex(loader_platform_thread_mutex* pMutex) +{ + LeaveCriticalSection(pMutex); +} +static void loader_platform_thread_delete_mutex(loader_platform_thread_mutex* pMutex) +{ + DeleteCriticalSection(pMutex); +} +typedef CONDITION_VARIABLE loader_platform_thread_cond; +static void loader_platform_thread_init_cond(loader_platform_thread_cond* pCond) +{ + InitializeConditionVariable(pCond); +} +static void loader_platform_thread_cond_wait(loader_platform_thread_cond* pCond, loader_platform_thread_mutex* pMutex) +{ + SleepConditionVariableCS(pCond, pMutex, INFINITE); +} +static void loader_platform_thread_cond_broadcast(loader_platform_thread_cond* pCond) +{ + WakeAllConditionVariable(pCond); +} + +// Windows Registry: +char *loader_get_registry_string(const HKEY hive, + const LPCTSTR sub_key, + const char *value); + +#else // defined(_WIN32) + +#error The "loader_platform.h" file must be modified for this OS. + +// NOTE: In order to support another OS, an #elif needs to be added (above the +// "#else // defined(_WIN32)") for that OS, and OS-specific versions of the +// contents of this file must be created. + +// NOTE: Other OS-specific changes are also needed for this OS. Search for +// files with "WIN32" in it, as a quick way to find files that must be changed. + +#endif // defined(_WIN32) + +#else /* LOADER_PLATFORM_H */ +#ifndef LOADER_PLATFORM_H_TEMP +#define LOADER_PLATFORM_H_TEMP + +// NOTE: The following are hopefully-temporary macros to ensure that people +// don't forget to use the loader_platform_*() functions above: + +#if defined(__linux__) +/* Linux-specific common code: */ + +// Dynamic Loading: +#define dlopen PLEASE USE THE loader_platform_open_library() FUNCTION +#define dlerror PLEASE DO NOT USE THE dlerror() FUNCTION DIRECTLY +#define dlclose PLEASE USE THE loader_platform_close_library() FUNCTION +#define dlsym PLEASE USE THE loader_platform_get_proc_address() FUNCTION + +// Threads: +#define pthread_once PLEASE USE THE loader_platform_thread_once() FUNCTION +#define pthread_self PLEASE USE THE loader_platform_get_thread_id() FUNCTION + +// Thread mutex: +#define pthread_mutex_init PLEASE USE THE loader_platform_thread_create_mutex() FUNCTION +#define pthread_mutex_lock PLEASE USE THE loader_platform_thread_lock_mutex() FUNCTION +#define pthread_mutex_unlock PLEASE USE THE loader_platform_thread_unlock_mutex() FUNCTION +#define pthread_mutex_destroy PLEASE USE THE loader_platform_thread_delete_mutex() FUNCTION + + +#elif defined(_WIN32) // defined(__linux__) +/* Windows-specific common code: */ + +// Dynamic Loading: +//#define LoadLibrary PLEASE USE THE loader_platform_open_library() FUNCTION +#define FreeLibrary PLEASE USE THE loader_platform_close_library() FUNCTION +#define GetProcAddress PLEASE USE THE loader_platform_get_proc_address() FUNCTION + +// Threads: +#define InitOnceExecuteOnce PLEASE USE THE loader_platform_thread_once() FUNCTION +#define GetCurrentThreadId PLEASE USE THE loader_platform_get_thread_id() FUNCTION + +// Thread mutex: +#define InitializeCriticalSection PLEASE USE THE loader_platform_thread_create_mutex() FUNCTION +#define EnterCriticalSection PLEASE USE THE loader_platform_thread_lock_mutex() FUNCTION +#define LeaveCriticalSection PLEASE USE THE loader_platform_thread_unlock_mutex() FUNCTION +#define DeleteCriticalSection PLEASE USE THE loader_platform_thread_delete_mutex() FUNCTION + +#define loader_stack_alloc(size) _alloca(size) +static inline void *loader_aligned_alloc(size_t alignment, size_t size) { return _aligned_malloc(alignment, size); } + +#endif // defined(_WIN32) +#endif /* LOADER_PLATFORM_H_TEMP */ +#endif /* LOADER_PLATFORM_H */ diff --git a/renderdoc/driver/vulkan/Makefile b/renderdoc/driver/vulkan/Makefile index 6ff99dc0a..ee6e32d60 100644 --- a/renderdoc/driver/vulkan/Makefile +++ b/renderdoc/driver/vulkan/Makefile @@ -4,22 +4,31 @@ COMMIT=`git rev-parse HEAD` MACROS=-DLINUX \ -DRENDERDOC_PLATFORM=linux \ -DRENDERDOC_EXPORTS \ - -DGIT_COMMIT_HASH="\"$(COMMIT)\"" -CFLAGS=-c -Wall -Werror -Wno-unused -Wno-unknown-pragmas -fPIC $(MACROS) -I../../ -I../../3rdparty/ -I$(VULKAN_SDK)/include/vulkan + -DGIT_COMMIT_HASH="\"$(COMMIT)\"" \ + -DVK_PROTOTYPES +CFLAGS=-c -Wall -Werror -Wno-unused -Wno-unknown-pragmas -fPIC $(MACROS) -I../../ -I../../3rdparty/ -I$(VULKAN_SDK_SRC)/include -I$(VULKAN_SDK_SRC)/layers -I$(VULKAN_SDK_SRC)/loader -I$(VULKAN_SDK_SRC)/build/layers CPPFLAGS=-std=c++11 -g -Wno-reorder -fvisibility=hidden -fvisibility-inlines-hidden LDFLAGS=-lpthread -lrt -shared -ldl -lX11 OBJDIR=.obj -OBJECTS=vk_common.o \ +OBJECTS=rdtrace.o \ vk_core.o \ -vk_hooks_linux.o \ +vk_common.o \ vk_manager.o \ +vk_resources.o \ +LoaderAndTools/layers/vk_layer_table.o \ vk_replay.o \ vk_info.o \ vk_replay_linux.o \ -vk_resources.o \ + +DOBJDIR=../../.obj/data/spv +DATA=blitvs.spvo \ +checkerboardfs.spvo \ +texdisplayfs.spvo \ + +OBJDIR_DATA=$(addprefix $(DOBJDIR)/, $(DATA)) .PHONY: all -all: rdoc_vulkan.a +all: libVKLayerRenderdoc.so rdoc_vulkan.a $(OBJDIR)/%.o: %.cpp @mkdir -p $$(dirname $@) @@ -35,9 +44,22 @@ OBJDIR_OBJECTS=$(addprefix $(OBJDIR)/, $(OBJECTS)) -include $(OBJDIR_OBJECTS:.o=.d) -rdoc_vulkan.a: $(OBJDIR_OBJECTS) - ar rcs rdoc_vulkan.a $(OBJDIR_OBJECTS) +STATIC_OBJECTS=$(addprefix $(OBJDIR)/, vk_core.o \ +vk_common.o \ +vk_manager.o \ +vk_resources.o \ +LoaderAndTools/layers/vk_layer_table.o \ +vk_replay.o \ +vk_info.o \ +vk_replay_linux.o \ +) + +rdoc_vulkan.a: $(STATIC_OBJECTS) + ar rcs rdoc_vulkan.a $(STATIC_OBJECTS) + +libVKLayerRenderdoc.so: $(OBJDIR_OBJECTS) $(OBJDIR_DATA) $(VULKAN_SDK_SRC)/build/layers/liblayer_utils.so + /usr/bin/c++ -fPIC -std=c++11 -DVK_PROTOTYPES -Wpointer-arith -g -Wl,-Bsymbolic -shared -Wl,-soname,libVKLayerRenderdoc.so -o libVKLayerRenderdoc.so $(OBJDIR_OBJECTS) $(OBJDIR_DATA) ../../.obj/os/linux/linux_threading.o ../../.obj/os/linux/linux_stringio.o ../../.obj/os/linux/linux_network.o ../../.obj/os/os_specific.o ../../.obj/serialise/utf8printf.o ../../.obj/serialise/grisu2.o ../../.obj/core/core.o ../../.obj/core/remote_access.o ../../.obj/replay/capture_options.o ../../.obj/replay/type_helpers.o ../../.obj/serialise/serialiser.o ../../.obj/core/resource_manager.o ../../.obj/common/common.o $(VULKAN_SDK_SRC)/build/layers/liblayer_utils.so -Wl,-rpath,/home/greg/renderdoc/vulkan/renderdoc/driver/vulkan/lib/vulkan -lpthread -lrt -ldl -lX11 .PHONY: clean clean: - rm -rf rdoc_vulkan.a $(OBJDIR) + rm -rf rdoc_vulkan.a libVKLayerRenderdoc.so $(OBJDIR) diff --git a/renderdoc/driver/vulkan/rdtrace.cpp b/renderdoc/driver/vulkan/rdtrace.cpp new file mode 100644 index 000000000..02dda6adf --- /dev/null +++ b/renderdoc/driver/vulkan/rdtrace.cpp @@ -0,0 +1,241 @@ +/* + * Vulkan + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +#include +#include +#include +#include "vk_loader_platform.h" +#include "vk_dispatch_table_helper.h" +#include "vk_layer.h" +#include "vk_layer_table.h" +#include "vk_layer_extension_utils.h" +// The following is #included again to catch certain OS-specific functions +// being used: +#include "vk_loader_platform.h" + +// Renderdoc Includes + +#include "driver/vulkan/vk_common.h" +#include "driver/vulkan/vk_core.h" +#include "driver/vulkan/vk_hookset_defs.h" + +#include "common/threading.h" +#include "serialise/string_utils.h" + +// don't want these definitions, the only place we'll use these is as parameter/variable names +#ifdef near +#undef near +#endif + +#ifdef far +#undef far +#endif + +// Renderdoc State + +WrappedVulkan *shadowVulkan = NULL; + +// Layer Intercepts + +static const VkLayerProperties rdt_physicaldevice_layers[] = { + { + "Renderdoc", + VK_API_VERSION, + VK_MAKE_VERSION(0, 1, 0), + "layer: implements Renderdoc tracing", + } +}; + +VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pCount, + VkLayerProperties* pProperties) +{ + return util_GetLayerProperties(ARRAY_SIZE(rdt_physicaldevice_layers), rdt_physicaldevice_layers, + pCount, pProperties); +} + +static const VkExtensionProperties rdt_physicaldevice_extensions[] = { + { + DEBUG_MARKER_EXTENSION_NAME, + VK_MAKE_VERSION(0, 1, 0), + } +}; + +VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char *pLayerName, + uint32_t *pCount, + VkExtensionProperties *pProperties) +{ + return util_GetExtensionProperties(ARRAY_SIZE(rdt_physicaldevice_extensions), rdt_physicaldevice_extensions, + pCount, pProperties); +} + +static const VkLayerProperties rdt_GlobalLayers[] = { + { + "Renderdoc", + VK_API_VERSION, + VK_MAKE_VERSION(0, 1, 0), + "Trace layer: Renderdoc", + } +}; + +VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalLayerProperties( + uint32_t *pCount, + VkLayerProperties* pProperties) +{ + return util_GetLayerProperties(ARRAY_SIZE(rdt_GlobalLayers), + rdt_GlobalLayers, + pCount, pProperties); +} + +// Renderdoc Intercepts + +#define HookDefine0(ret, function) \ + VK_LAYER_EXPORT \ + ret VKAPI function() \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(); } +#define HookDefine1(ret, function, t1, p1) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1); } +#define HookDefine2(ret, function, t1, p1, t2, p2) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2); } +#define HookDefine3(ret, function, t1, p1, t2, p2, t3, p3) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3); } +#define HookDefine4(ret, function, t1, p1, t2, p2, t3, p3, t4, p4) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4); } +#define HookDefine5(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5); } +#define HookDefine6(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5, p6); } +#define HookDefine7(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5, p6, p7); } +#define HookDefine8(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5, p6, p7, p8); } +#define HookDefine9(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5, p6, p7, p8, p9); } +#define HookDefine10(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } +#define HookDefine11(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } +#define HookDefine12(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } +#define HookDefine13(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } +#define HookDefine14(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13, t14, p14) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13, t14 p14) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); } +#define HookDefine15(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13, t14, p14, t15, p15) \ + VK_LAYER_EXPORT \ + ret VKAPI function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13, t14 p14, t15 p15) \ + { SCOPED_LOCK(vkLock); return shadowVulkan->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); } + +Threading::CriticalSection vkLock; + +DefineHooks(); + +#undef HookInit +#define HookInit(function) if (!strcmp(pName, STRINGIZE(function))) return (PFN_vkVoidFunction) function; + +// proc addr routines + +VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* pName) +{ + if (device == NULL) + return NULL; + + /* loader uses this to force layer initialization; device object is wrapped */ + if (!strcmp("vkGetDeviceProcAddr", pName)) { + initDeviceTable((const VkBaseLayerObject *) device); + return (PFN_vkVoidFunction) vkGetDeviceProcAddr; + } + + HookInitVulkanDevice(); + + if (!strcmp("vkCreateDevice", pName)) + return (PFN_vkVoidFunction) vkCreateDevice; + if (!strcmp("vkDestroyDevice", pName)) + return (PFN_vkVoidFunction) vkDestroyDevice; + else + { + if (device_dispatch_table(device)->GetDeviceProcAddr == NULL) + return NULL; + return device_dispatch_table(device)->GetDeviceProcAddr(device, pName); + } +} + +VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* pName) +{ + if (instance == NULL) + return NULL; + + /* loader uses this to force layer initialization; instance object is wrapped */ + if (!strcmp("vkGetInstanceProcAddr", pName)) { + initInstanceTable((const VkBaseLayerObject *) instance); + if (shadowVulkan == NULL) { + shadowVulkan = new WrappedVulkan(""); + } + return (PFN_vkVoidFunction) vkGetInstanceProcAddr; + } + + HookInitVulkanInstance(); + + if (!strcmp("vkGetPhysicalDeviceLayerProperties", pName)) + return (PFN_vkVoidFunction) vkGetPhysicalDeviceLayerProperties; + if (!strcmp("vkGetPhysicalDeviceExtensionProperties", pName)) + return (PFN_vkVoidFunction) vkGetPhysicalDeviceExtensionProperties; + if (!strcmp("vkGetGlobalLayerProperties", pName)) + return (PFN_vkVoidFunction) vkGetGlobalLayerProperties; + + if (instance_dispatch_table(instance)->GetInstanceProcAddr == NULL) + return NULL; + return instance_dispatch_table(instance)->GetInstanceProcAddr(instance, pName); +} + diff --git a/renderdoc/driver/vulkan/renderdoc.json b/renderdoc/driver/vulkan/renderdoc.json new file mode 100644 index 000000000..023c43bb5 --- /dev/null +++ b/renderdoc/driver/vulkan/renderdoc.json @@ -0,0 +1,11 @@ +{ + "file_format_version" : "0.9.0", + "layer" : { + "name": "Renderdoc", + "type": "GLOBAL", + "library_path": "./libVKLayerRenderdoc.so", + "abi_versions": "1.0.0", + "implementation_version": "1.0.0", + "description": "LunarG Renderdoc Trace Layer" + } +} diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index 940772b21..c03dabbea 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -263,7 +263,9 @@ void WrappedVulkan::Initialise(VkInitParams ¶ms) VkInstance inst; - VkResult ret = m_Real.vkCreateInstance(&instinfo, &inst); + // GSFTODO: Fix this + // VkResult ret = m_Real.vkCreateInstance(&instinfo, &inst); + VkResult ret = instance_dispatch_table(inst)->CreateInstance(&instinfo, &inst); GetResourceManager()->RegisterResource(MakeRes(inst)); GetResourceManager()->AddLiveResource(params.InstanceID, MakeRes(inst)); @@ -272,8 +274,7 @@ void WrappedVulkan::Initialise(VkInitParams ¶ms) SAFE_DELETE_ARRAY(extscstr); } -WrappedVulkan::WrappedVulkan(const VulkanFunctions &real, const char *logFilename) - : m_Real(real) +WrappedVulkan::WrappedVulkan(const char *logFilename) { #if defined(RELEASE) const bool debugSerialiser = false; @@ -310,10 +311,10 @@ WrappedVulkan::WrappedVulkan(const VulkanFunctions &real, const char *logFilenam m_SwapPhysDevice = -1; uint32_t extCount = 0; - m_Real.vkGetGlobalExtensionProperties(NULL, &extCount, NULL); + vkGetGlobalExtensionProperties(NULL, &extCount, NULL); globalExts.driver.resize(extCount); - m_Real.vkGetGlobalExtensionProperties(NULL, &extCount, &globalExts.driver[0]); + vkGetGlobalExtensionProperties(NULL, &extCount, &globalExts.driver[0]); std::sort(globalExts.driver.begin(), globalExts.driver.end()); @@ -410,7 +411,9 @@ WrappedVulkan::~WrappedVulkan() if(m_MsgCallback != VK_NULL_HANDLE) { // VKTODOMED [0] isn't right.. - m_Real.vkDbgDestroyMsgCallback(m_PhysicalReplayData[0].inst, m_MsgCallback); + // 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); } #endif @@ -433,9 +436,9 @@ VkResult WrappedVulkan::vkCreateInstance( RDCASSERT(pCreateInfo->pNext == NULL); - VkInstance inst; + VkInstance inst = *pInstance; - VkResult ret = m_Real.vkCreateInstance(pCreateInfo, &inst); + VkResult ret = instance_dispatch_table(*pInstance)->CreateInstance(pCreateInfo, &inst); if(ret != VK_SUCCESS) return ret; @@ -450,14 +453,15 @@ VkResult WrappedVulkan::vkCreateInstance( // VKTODOLOW we should try and fetch vkDbgCreateMsgCallback ourselves if it isn't // already loaded - if(RenderDoc::Inst().GetCaptureOptions().DebugDeviceMode && m_Real.vkDbgCreateMsgCallback) + PFN_vkDbgCreateMsgCallback dcmc_fn = instance_dispatch_table(*pInstance)->DbgCreateMsgCallback; + if(RenderDoc::Inst().GetCaptureOptions().DebugDeviceMode && dcmc_fn) { 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; - m_Real.vkDbgCreateMsgCallback(inst, flags, &DebugCallbackStatic, this, &m_MsgCallback); + dcmc_fn(inst, flags, &DebugCallbackStatic, this, &m_MsgCallback); } GetResourceManager()->RegisterResource(MakeRes(inst)); @@ -477,18 +481,21 @@ VkResult WrappedVulkan::vkCreateInstance( VkResult WrappedVulkan::vkDestroyInstance( VkInstance instance) { - VkResult ret = m_Real.vkDestroyInstance(instance); + dispatch_key key = get_dispatch_key(instance); + VkResult ret = instance_dispatch_table(instance)->DestroyInstance(instance); if(ret != VK_SUCCESS) return ret; if(RenderDoc::Inst().GetCaptureOptions().DebugDeviceMode && m_MsgCallback != VK_NULL_HANDLE) { - m_Real.vkDbgDestroyMsgCallback(instance, m_MsgCallback); + instance_dispatch_table(instance)->DbgDestroyMsgCallback(instance, m_MsgCallback); } GetResourceManager()->UnregisterResource(MakeRes(instance)); + destroy_instance_dispatch_table(key); + return VK_SUCCESS; } @@ -506,7 +513,8 @@ bool WrappedVulkan::Serialise_vkEnumeratePhysicalDevices( if(m_State < WRITING) { instance = (VkInstance)GetResourceManager()->GetLiveResource(inst).handle; - VkResult ret = m_Real.vkEnumeratePhysicalDevices(instance, &count, devices); + // GSFTODO right instance? + VkResult ret = instance_dispatch_table(instance)->EnumeratePhysicalDevices(instance, &count, devices); RDCASSERT(ret == VK_SUCCESS); // VKTODOLOW match up physical devices to those available on replay @@ -530,7 +538,7 @@ bool WrappedVulkan::Serialise_vkEnumeratePhysicalDevices( data.inst = instance; data.phys = pd; - m_Real.vkGetPhysicalDeviceMemoryProperties(pd, &data.memProps); + instance_dispatch_table(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); @@ -548,7 +556,7 @@ VkResult WrappedVulkan::vkEnumeratePhysicalDevices( { uint32_t count; VkPhysicalDevice devices[8]; // VKTODOLOW: dynamically allocate - VkResult ret = m_Real.vkEnumeratePhysicalDevices(instance, &count, devices); + VkResult ret = instance_dispatch_table(instance)->EnumeratePhysicalDevices(instance, &count, devices); if(ret != VK_SUCCESS) return ret; @@ -583,7 +591,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice( if(m_State == READING) { - physicalDevice = (VkPhysicalDevice)GetResourceManager()->GetLiveResource(physId).handle; + VkPhysicalDevice rmPhys = (VkPhysicalDevice)GetResourceManager()->GetLiveResource(physId).handle; VkDevice device; @@ -591,7 +599,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice( // VKTODOLOW: check that extensions supported in capture (from createInfo) are supported in replay - VkResult ret = m_Real.vkCreateDevice(physicalDevice, &createInfo, &device); + VkResult ret = device_dispatch_table(*pDevice)->CreateDevice(rmPhys, &createInfo, &device); VkResource res = MakeRes(device); @@ -602,35 +610,36 @@ bool WrappedVulkan::Serialise_vkCreateDevice( for(size_t i=0; i < m_PhysicalReplayData.size(); i++) { - if(m_PhysicalReplayData[i].phys == physicalDevice) + if(m_PhysicalReplayData[i].phys == rmPhys) { // VKTODOHIGH super ultra mega hyper hack of great justice - void PopulateDeviceHooks(VkDevice d, VkInstance i); - PopulateDeviceHooks(device, m_PhysicalReplayData[i].inst); + // GSFTODO hack + //void PopulateDeviceHooks(VkDevice d, VkInstance i); + //PopulateDeviceHooks(device, m_PhysicalReplayData[i].inst); m_PhysicalReplayData[i].dev = device; // VKTODOHIGH: shouldn't be 0, 0 - VkResult vkr = m_Real.vkGetDeviceQueue(device, 0, 0, &m_PhysicalReplayData[i].q); + VkResult vkr = device_dispatch_table(*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 = m_Real.vkCreateCommandPool(device, &poolInfo, &m_PhysicalReplayData[i].cmdpool); + vkr = device_dispatch_table(*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 = m_Real.vkCreateCommandBuffer(device, &cmdInfo, &m_PhysicalReplayData[i].cmd); + vkr = device_dispatch_table(*pDevice)->CreateCommandBuffer(device, &cmdInfo, &m_PhysicalReplayData[i].cmd); RDCASSERT(vkr == VK_SUCCESS); #if defined(FORCE_VALIDATION_LAYER) - if(m_Real.vkDbgCreateMsgCallback) + if(device_dispatch_table(*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 = m_Real.vkDbgCreateMsgCallback(m_PhysicalReplayData[i].inst, flags, &DebugCallbackStatic, this, &m_MsgCallback); + vkr = device_dispatch_table(*pDevice)->DbgCreateMsgCallback(m_PhysicalReplayData[i].inst, flags, &DebugCallbackStatic, this, &m_MsgCallback); RDCASSERT(vkr == VK_SUCCESS); RDCLOG("Created dbg callback"); } @@ -664,7 +673,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 = m_Real.vkCreateDevice(physicalDevice, &createInfo, pDevice); + VkResult ret = device_dispatch_table(*pDevice)->CreateDevice(physicalDevice, &createInfo, pDevice); if(ret == VK_SUCCESS) { @@ -676,16 +685,16 @@ VkResult WrappedVulkan::vkCreateDevice( { m_PhysicalReplayData[i].dev = *pDevice; // VKTODOHIGH: shouldn't be 0, 0 - VkResult vkr = m_Real.vkGetDeviceQueue(*pDevice, 0, 0, &m_PhysicalReplayData[i].q); + VkResult vkr = device_dispatch_table(*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 = m_Real.vkCreateCommandPool(*pDevice, &poolInfo, &m_PhysicalReplayData[i].cmdpool); + vkr = device_dispatch_table(*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 = m_Real.vkCreateCommandBuffer(*pDevice, &cmdInfo, &m_PhysicalReplayData[i].cmd); + vkr = device_dispatch_table(*pDevice)->CreateCommandBuffer(*pDevice, &cmdInfo, &m_PhysicalReplayData[i].cmd); RDCASSERT(vkr == VK_SUCCESS); found = true; break; @@ -751,7 +760,7 @@ VkResult WrappedVulkan::vkDestroyDevice(VkDevice device) } if(m_PhysicalReplayData[i].cmd != VK_NULL_HANDLE) - m_Real.vkDestroyCommandBuffer(device, m_PhysicalReplayData[i].cmd); + device_dispatch_table(device)->DestroyCommandBuffer(device, m_PhysicalReplayData[i].cmd); m_PhysicalReplayData[i] = ReplayData(); break; @@ -759,7 +768,9 @@ VkResult WrappedVulkan::vkDestroyDevice(VkDevice device) } } - VkResult ret = m_Real.vkDestroyDevice(device); + dispatch_key key = get_dispatch_key(device); + VkResult ret = device_dispatch_table(device)->DestroyDevice(device); + destroy_device_dispatch_table(key); GetResourceManager()->UnregisterResource(MakeRes(device)); @@ -770,7 +781,7 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { - return m_Real.vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures); + return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures); } VkResult WrappedVulkan::vkGetPhysicalDeviceFormatProperties( @@ -778,7 +789,7 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceFormatProperties( VkFormat format, VkFormatProperties* pFormatProperties) { - return m_Real.vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); + return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); } VkResult WrappedVulkan::vkGetPhysicalDeviceImageFormatProperties( @@ -789,28 +800,28 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceImageFormatProperties( VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) { - return m_Real.vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, pImageFormatProperties); + return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, pImageFormatProperties); } VkResult WrappedVulkan::vkGetPhysicalDeviceLimits( VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) { - return m_Real.vkGetPhysicalDeviceLimits(physicalDevice, pLimits); + return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceLimits(physicalDevice, pLimits); } VkResult WrappedVulkan::vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { - return m_Real.vkGetPhysicalDeviceProperties(physicalDevice, pProperties); + return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties); } VkResult WrappedVulkan::vkGetPhysicalDeviceQueueCount( VkPhysicalDevice physicalDevice, uint32_t* pCount) { - return m_Real.vkGetPhysicalDeviceQueueCount(physicalDevice, pCount); + return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueCount(physicalDevice, pCount); } VkResult WrappedVulkan::vkGetPhysicalDeviceQueueProperties( @@ -818,14 +829,14 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceQueueProperties( uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties) { - return m_Real.vkGetPhysicalDeviceQueueProperties(physicalDevice, count, pQueueProperties); + return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueProperties(physicalDevice, count, pQueueProperties); } VkResult WrappedVulkan::vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { - return m_Real.vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); + return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); } VkResult WrappedVulkan::vkGetImageSubresourceLayout( @@ -834,7 +845,7 @@ VkResult WrappedVulkan::vkGetImageSubresourceLayout( const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { - return m_Real.vkGetImageSubresourceLayout(device, image, pSubresource, pLayout); + return device_dispatch_table(device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout); } VkResult WrappedVulkan::vkGetBufferMemoryRequirements( @@ -842,7 +853,7 @@ VkResult WrappedVulkan::vkGetBufferMemoryRequirements( VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { - return m_Real.vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements); + return device_dispatch_table(device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); } VkResult WrappedVulkan::vkGetImageMemoryRequirements( @@ -850,23 +861,23 @@ VkResult WrappedVulkan::vkGetImageMemoryRequirements( VkImage image, VkMemoryRequirements* pMemoryRequirements) { - return m_Real.vkGetImageMemoryRequirements(device, image, pMemoryRequirements); + return device_dispatch_table(device)->GetImageMemoryRequirements(device, image, pMemoryRequirements); } VkResult WrappedVulkan::vkGetGlobalExtensionProperties( const char* pLayerName, - uint32_t* pCount, - VkExtensionProperties* pProperties) + uint32_t* pCount, + VkExtensionProperties* pProperties) { - if(pLayerName == NULL) - { - if(pCount) *pCount = uint32_t(globalExts.extensions.size()); - if(pProperties) - memcpy(pProperties, &globalExts.extensions[0], sizeof(VkExtensionProperties)*globalExts.extensions.size()); - return VK_SUCCESS; - } + if(pLayerName == NULL) + { + if(pCount) *pCount = uint32_t(globalExts.extensions.size()); + if(pProperties) + memcpy(pProperties, &globalExts.extensions[0], sizeof(VkExtensionProperties)*globalExts.extensions.size()); + return VK_SUCCESS; + } - return m_Real.vkGetGlobalExtensionProperties(pLayerName, pCount, pProperties); + return util_GetExtensionProperties(0, NULL, pCount, pProperties); } void WrappedVulkan::DestroyObject(VkResource res, ResourceId id) @@ -882,35 +893,35 @@ void WrappedVulkan::DestroyObject(VkResource res, ResourceId id) } #define DESTROY_IMPL(type, func) \ - VkResult WrappedVulkan::func(VkDevice device, type obj) \ + VkResult WrappedVulkan::vk ## func(VkDevice device, type obj) \ { \ DestroyObject(MakeRes(obj), GetResourceManager()->GetID(MakeRes(obj))); \ - return m_Real.func(device, obj); \ + return device_dispatch_table(device)->func(device, obj); \ } -DESTROY_IMPL(VkBuffer, vkDestroyBuffer) -DESTROY_IMPL(VkBufferView, vkDestroyBufferView) -DESTROY_IMPL(VkImage, vkDestroyImage) -DESTROY_IMPL(VkImageView, vkDestroyImageView) -DESTROY_IMPL(VkAttachmentView, vkDestroyAttachmentView) -DESTROY_IMPL(VkShader, vkDestroyShader) -DESTROY_IMPL(VkShaderModule, vkDestroyShaderModule) -DESTROY_IMPL(VkPipeline, vkDestroyPipeline) -DESTROY_IMPL(VkPipelineCache, vkDestroyPipelineCache) -DESTROY_IMPL(VkPipelineLayout, vkDestroyPipelineLayout) -DESTROY_IMPL(VkSampler, vkDestroySampler) -DESTROY_IMPL(VkDescriptorSetLayout, vkDestroyDescriptorSetLayout) -DESTROY_IMPL(VkDescriptorPool, vkDestroyDescriptorPool) -DESTROY_IMPL(VkDynamicViewportState, vkDestroyDynamicViewportState) -DESTROY_IMPL(VkDynamicRasterState, vkDestroyDynamicRasterState) -DESTROY_IMPL(VkDynamicColorBlendState, vkDestroyDynamicColorBlendState) -DESTROY_IMPL(VkDynamicDepthStencilState, vkDestroyDynamicDepthStencilState) -DESTROY_IMPL(VkSemaphore, vkDestroySemaphore) -DESTROY_IMPL(VkCmdPool, vkDestroyCommandPool) -DESTROY_IMPL(VkCmdBuffer, vkDestroyCommandBuffer) -DESTROY_IMPL(VkFramebuffer, vkDestroyFramebuffer) -DESTROY_IMPL(VkRenderPass, vkDestroyRenderPass) -DESTROY_IMPL(VkSwapChainWSI, vkDestroySwapChainWSI) +DESTROY_IMPL(VkBuffer, DestroyBuffer) +DESTROY_IMPL(VkBufferView, DestroyBufferView) +DESTROY_IMPL(VkImage, DestroyImage) +DESTROY_IMPL(VkImageView, DestroyImageView) +DESTROY_IMPL(VkAttachmentView, DestroyAttachmentView) +DESTROY_IMPL(VkShader, DestroyShader) +DESTROY_IMPL(VkShaderModule, DestroyShaderModule) +DESTROY_IMPL(VkPipeline, DestroyPipeline) +DESTROY_IMPL(VkPipelineCache, DestroyPipelineCache) +DESTROY_IMPL(VkPipelineLayout, DestroyPipelineLayout) +DESTROY_IMPL(VkSampler, DestroySampler) +DESTROY_IMPL(VkDescriptorSetLayout, DestroyDescriptorSetLayout) +DESTROY_IMPL(VkDescriptorPool, DestroyDescriptorPool) +DESTROY_IMPL(VkDynamicViewportState, DestroyDynamicViewportState) +DESTROY_IMPL(VkDynamicRasterState, DestroyDynamicRasterState) +DESTROY_IMPL(VkDynamicColorBlendState, DestroyDynamicColorBlendState) +DESTROY_IMPL(VkDynamicDepthStencilState, DestroyDynamicDepthStencilState) +DESTROY_IMPL(VkSemaphore, DestroySemaphore) +DESTROY_IMPL(VkCmdPool, DestroyCommandPool) +DESTROY_IMPL(VkCmdBuffer, DestroyCommandBuffer) +DESTROY_IMPL(VkFramebuffer, DestroyFramebuffer) +DESTROY_IMPL(VkRenderPass, DestroyRenderPass) +DESTROY_IMPL(VkSwapChainWSI, DestroySwapChainWSI) #undef DESTROY_IMPL @@ -928,7 +939,7 @@ bool WrappedVulkan::Serialise_vkGetDeviceQueue( if(m_State == READING) { VkQueue queue; - VkResult ret = m_Real.vkGetDeviceQueue((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, nodeIdx, idx, &queue); + VkResult ret = device_dispatch_table(device)->GetDeviceQueue((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, nodeIdx, idx, &queue); VkResource res = MakeRes(queue); @@ -945,7 +956,7 @@ VkResult WrappedVulkan::vkGetDeviceQueue( uint32_t queueIndex, VkQueue* pQueue) { - VkResult ret = m_Real.vkGetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); + VkResult ret = device_dispatch_table(device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); if(ret == VK_SUCCESS) { @@ -1014,9 +1025,10 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( } } + VkQueue rmqueue = queue; if(m_State < WRITING) { - queue = (VkQueue)GetResourceManager()->GetLiveResource(queueId).handle; + rmqueue = (VkQueue)GetResourceManager()->GetLiveResource(queueId).handle; if(fenceId != ResourceId()) fence = (VkFence)GetResourceManager()->GetLiveResource(fenceId).handle; else @@ -1029,7 +1041,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( { m_SubmittedFences.insert(fenceId); - m_Real.vkQueueSubmit(queue, numCmds, cmds, fence); + device_dispatch_table(queue)->QueueSubmit(rmqueue, numCmds, cmds, fence); for(uint32_t i=0; i < numCmds; i++) { @@ -1141,7 +1153,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( m_SubmittedFences.insert(fenceId); - m_Real.vkQueueSubmit(queue, (uint32_t)trimmedCmds.size(), &trimmedCmds[0], fence); + device_dispatch_table(queue)->QueueSubmit(rmqueue, (uint32_t)trimmedCmds.size(), &trimmedCmds[0], fence); for(uint32_t i=0; i < numCmds; i++) { @@ -1153,7 +1165,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( { m_SubmittedFences.insert(fenceId); - m_Real.vkQueueSubmit(queue, numCmds, cmds, fence); + device_dispatch_table(queue)->QueueSubmit(rmqueue, numCmds, cmds, fence); for(uint32_t i=0; i < numCmds; i++) { @@ -1192,7 +1204,7 @@ VkResult WrappedVulkan::vkQueueSubmit( const VkCmdBuffer* pCmdBuffers, VkFence fence) { - VkResult ret = m_Real.vkQueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); + VkResult ret = device_dispatch_table(queue)->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); if(m_State == WRITING_CAPFRAME) { @@ -1236,7 +1248,7 @@ bool WrappedVulkan::Serialise_vkQueueSignalSemaphore(VkQueue queue, VkSemaphore if(m_State < WRITING) { - m_Real.vkQueueSignalSemaphore((VkQueue)GetResourceManager()->GetLiveResource(qid).handle, + device_dispatch_table(queue)->QueueSignalSemaphore((VkQueue)GetResourceManager()->GetLiveResource(qid).handle, (VkSemaphore)GetResourceManager()->GetLiveResource(sid).handle); } @@ -1245,7 +1257,7 @@ bool WrappedVulkan::Serialise_vkQueueSignalSemaphore(VkQueue queue, VkSemaphore VkResult WrappedVulkan::vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) { - VkResult ret = m_Real.vkQueueSignalSemaphore(queue, semaphore); + VkResult ret = device_dispatch_table(queue)->QueueSignalSemaphore(queue, semaphore); if(m_State >= WRITING) { @@ -1267,7 +1279,7 @@ bool WrappedVulkan::Serialise_vkQueueWaitSemaphore(VkQueue queue, VkSemaphore se if(m_State < WRITING) { - m_Real.vkQueueWaitSemaphore((VkQueue)GetResourceManager()->GetLiveResource(qid).handle, + device_dispatch_table(queue)->QueueWaitSemaphore((VkQueue)GetResourceManager()->GetLiveResource(qid).handle, (VkSemaphore)GetResourceManager()->GetLiveResource(sid).handle); } @@ -1276,7 +1288,7 @@ bool WrappedVulkan::Serialise_vkQueueWaitSemaphore(VkQueue queue, VkSemaphore se VkResult WrappedVulkan::vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) { - VkResult ret = m_Real.vkQueueWaitSemaphore(queue, semaphore); + VkResult ret = device_dispatch_table(queue)->QueueWaitSemaphore(queue, semaphore); if(m_State >= WRITING_CAPFRAME) { @@ -1297,7 +1309,7 @@ bool WrappedVulkan::Serialise_vkQueueWaitIdle(VkQueue queue) if(m_State < WRITING_CAPFRAME) { - m_Real.vkQueueWaitIdle((VkQueue)GetResourceManager()->GetLiveResource(id).handle); + device_dispatch_table(queue)->QueueWaitIdle((VkQueue)GetResourceManager()->GetLiveResource(id).handle); } return true; @@ -1305,7 +1317,7 @@ bool WrappedVulkan::Serialise_vkQueueWaitIdle(VkQueue queue) VkResult WrappedVulkan::vkQueueWaitIdle(VkQueue queue) { - VkResult ret = m_Real.vkQueueWaitIdle(queue); + VkResult ret = device_dispatch_table(queue)->QueueWaitIdle(queue); if(m_State >= WRITING_CAPFRAME) { @@ -1325,7 +1337,7 @@ bool WrappedVulkan::Serialise_vkDeviceWaitIdle(VkDevice device) if(m_State < WRITING) { - m_Real.vkDeviceWaitIdle((VkDevice)GetResourceManager()->GetLiveResource(id).handle); + device_dispatch_table(device)->DeviceWaitIdle((VkDevice)GetResourceManager()->GetLiveResource(id).handle); } return true; @@ -1333,7 +1345,7 @@ bool WrappedVulkan::Serialise_vkDeviceWaitIdle(VkDevice device) VkResult WrappedVulkan::vkDeviceWaitIdle(VkDevice device) { - VkResult ret = m_Real.vkDeviceWaitIdle(device); + VkResult ret = device_dispatch_table(device)->DeviceWaitIdle(device); if(m_State >= WRITING_CAPFRAME) { @@ -1363,7 +1375,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 = m_Real.vkAllocMemory((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &mem); + VkResult ret = device_dispatch_table(device)->AllocMemory((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &mem); ResourceId live; @@ -1388,7 +1400,7 @@ VkResult WrappedVulkan::vkAllocMemory( const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) { - VkResult ret = m_Real.vkAllocMemory(device, pAllocInfo, pMem); + VkResult ret = device_dispatch_table(device)->AllocMemory(device, pAllocInfo, pMem); if(ret == VK_SUCCESS) { @@ -1440,7 +1452,7 @@ VkResult WrappedVulkan::vkFreeMemory( record->Delete(GetResourceManager()); GetResourceManager()->UnregisterResource(MakeRes(mem)); - return m_Real.vkFreeMemory(device, mem); + return device_dispatch_table(device)->FreeMemory(device, mem); } VkResult WrappedVulkan::vkMapMemory( @@ -1451,7 +1463,7 @@ VkResult WrappedVulkan::vkMapMemory( VkMemoryMapFlags flags, void** ppData) { - VkResult ret = m_Real.vkMapMemory(device, mem, offset, size, flags, ppData); + VkResult ret = device_dispatch_table(device)->MapMemory(device, mem, offset, size, flags, ppData); if(ret == VK_SUCCESS && ppData) { @@ -1504,11 +1516,11 @@ bool WrappedVulkan::Serialise_vkUnmapMemory( if(m_State < WRITING) { - device = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; + VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; mem = (VkDeviceMemory)GetResourceManager()->GetLiveResource(id).handle; void *mapPtr = NULL; - VkResult ret = m_Real.vkMapMemory(device, mem, memOffset, memSize, flags, &mapPtr); + VkResult ret = device_dispatch_table(device)->MapMemory(rmDev, mem, memOffset, memSize, flags, &mapPtr); if(ret != VK_SUCCESS) { @@ -1518,7 +1530,7 @@ bool WrappedVulkan::Serialise_vkUnmapMemory( { memcpy((byte *)mapPtr+memOffset, data, (size_t)memSize); - ret = m_Real.vkUnmapMemory(device, mem); + ret = device_dispatch_table(device)->UnmapMemory(rmDev, mem); if(ret != VK_SUCCESS) RDCERR("Error unmapping memory on replay: 0x%08x", ret); @@ -1534,7 +1546,7 @@ VkResult WrappedVulkan::vkUnmapMemory( VkDevice device, VkDeviceMemory mem) { - VkResult ret = m_Real.vkUnmapMemory(device, mem); + VkResult ret = device_dispatch_table(device)->UnmapMemory(device, mem); if(m_State >= WRITING) { @@ -1594,11 +1606,11 @@ bool WrappedVulkan::Serialise_vkBindBufferMemory( if(m_State < WRITING) { - device = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; + VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufId).handle; mem = (VkDeviceMemory)GetResourceManager()->GetLiveResource(memId).handle; - m_Real.vkBindBufferMemory(device, buffer, mem, offs); + device_dispatch_table(device)->BindBufferMemory(rmDev, buffer, mem, offs); } return true; @@ -1638,7 +1650,7 @@ VkResult WrappedVulkan::vkBindBufferMemory( record->SetMemoryRecord(GetResourceManager()->GetResourceRecord(MakeRes(mem))); } - return m_Real.vkBindBufferMemory(device, buffer, mem, memOffset); + return device_dispatch_table(device)->BindBufferMemory(device, buffer, mem, memOffset); } bool WrappedVulkan::Serialise_vkBindImageMemory( @@ -1654,11 +1666,11 @@ bool WrappedVulkan::Serialise_vkBindImageMemory( if(m_State < WRITING) { - device = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; + VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; image = (VkImage)GetResourceManager()->GetLiveResource(imgId).handle; mem = (VkDeviceMemory)GetResourceManager()->GetLiveResource(memId).handle; - m_Real.vkBindImageMemory(device, image, mem, offs); + device_dispatch_table(device)->BindImageMemory(rmDev, image, mem, offs); } return true; @@ -1698,7 +1710,7 @@ VkResult WrappedVulkan::vkBindImageMemory( record->SetMemoryRecord(GetResourceManager()->GetResourceRecord(MakeRes(mem))); } - return m_Real.vkBindImageMemory(device, image, mem, memOffset); + return device_dispatch_table(device)->BindImageMemory(device, image, mem, memOffset); } bool WrappedVulkan::Serialise_vkCreateBuffer( @@ -1714,7 +1726,7 @@ bool WrappedVulkan::Serialise_vkCreateBuffer( { VkBuffer buf = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateBuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &buf); + VkResult ret = device_dispatch_table(device)->CreateBuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &buf); if(ret != VK_SUCCESS) { @@ -1735,7 +1747,7 @@ VkResult WrappedVulkan::vkCreateBuffer( const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) { - VkResult ret = m_Real.vkCreateBuffer(device, pCreateInfo, pBuffer); + VkResult ret = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pBuffer); if(ret == VK_SUCCESS) { @@ -1778,7 +1790,7 @@ bool WrappedVulkan::Serialise_vkCreateBufferView( { VkBufferView view = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateBufferView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); + VkResult ret = device_dispatch_table(device)->CreateBufferView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); if(ret != VK_SUCCESS) { @@ -1799,7 +1811,7 @@ VkResult WrappedVulkan::vkCreateBufferView( const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { - VkResult ret = m_Real.vkCreateBufferView(device, pCreateInfo, pView); + VkResult ret = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pView); if(ret == VK_SUCCESS) { @@ -1843,7 +1855,7 @@ bool WrappedVulkan::Serialise_vkCreateImage( { VkImage img = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateImage((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &img); + VkResult ret = device_dispatch_table(device)->CreateImage((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &img); if(ret != VK_SUCCESS) { @@ -1889,7 +1901,7 @@ VkResult WrappedVulkan::vkCreateImage( const VkImageCreateInfo* pCreateInfo, VkImage* pImage) { - VkResult ret = m_Real.vkCreateImage(device, pCreateInfo, pImage); + VkResult ret = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pImage); if(ret == VK_SUCCESS) { @@ -1959,7 +1971,7 @@ bool WrappedVulkan::Serialise_vkCreateImageView( { VkImageView view = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateImageView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); + VkResult ret = device_dispatch_table(device)->CreateImageView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); if(ret != VK_SUCCESS) { @@ -1980,7 +1992,7 @@ VkResult WrappedVulkan::vkCreateImageView( const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { - VkResult ret = m_Real.vkCreateImageView(device, pCreateInfo, pView); + VkResult ret = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pView); if(ret == VK_SUCCESS) { @@ -2024,7 +2036,7 @@ bool WrappedVulkan::Serialise_vkCreateAttachmentView( { VkAttachmentView view = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateAttachmentView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); + VkResult ret = device_dispatch_table(device)->CreateAttachmentView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); if(ret != VK_SUCCESS) { @@ -2045,7 +2057,7 @@ VkResult WrappedVulkan::vkCreateAttachmentView( const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView) { - VkResult ret = m_Real.vkCreateAttachmentView(device, pCreateInfo, pView); + VkResult ret = device_dispatch_table(device)->CreateAttachmentView(device, pCreateInfo, pView); if(ret == VK_SUCCESS) { @@ -2091,7 +2103,7 @@ bool WrappedVulkan::Serialise_vkCreateShaderModule( { VkShaderModule sh = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateShaderModule((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sh); + VkResult ret = device_dispatch_table(device)->CreateShaderModule((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sh); if(ret != VK_SUCCESS) { @@ -2112,7 +2124,7 @@ VkResult WrappedVulkan::vkCreateShaderModule( const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) { - VkResult ret = m_Real.vkCreateShaderModule(device, pCreateInfo, pShaderModule); + VkResult ret = device_dispatch_table(device)->CreateShaderModule(device, pCreateInfo, pShaderModule); if(ret == VK_SUCCESS) { @@ -2155,7 +2167,7 @@ bool WrappedVulkan::Serialise_vkCreateShader( { VkShader sh = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateShader((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sh); + VkResult ret = device_dispatch_table(device)->CreateShader((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sh); if(ret != VK_SUCCESS) { @@ -2176,7 +2188,7 @@ VkResult WrappedVulkan::vkCreateShader( const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) { - VkResult ret = m_Real.vkCreateShader(device, pCreateInfo, pShader); + VkResult ret = device_dispatch_table(device)->CreateShader(device, pCreateInfo, pShader); if(ret == VK_SUCCESS) { @@ -2224,7 +2236,7 @@ bool WrappedVulkan::Serialise_vkCreatePipelineCache( { VkPipelineCache cache = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreatePipelineCache((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &cache); + VkResult ret = device_dispatch_table(device)->CreatePipelineCache((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &cache); if(ret != VK_SUCCESS) { @@ -2245,7 +2257,7 @@ VkResult WrappedVulkan::vkCreatePipelineCache( const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) { - VkResult ret = m_Real.vkCreatePipelineCache(device, pCreateInfo, pPipelineCache); + VkResult ret = device_dispatch_table(device)->CreatePipelineCache(device, pCreateInfo, pPipelineCache); if(ret == VK_SUCCESS) { @@ -2294,10 +2306,10 @@ bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines( // use original ID m_CreationInfo.m_Pipeline[id].Init(GetResourceManager(), &info); - device = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; + VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; pipelineCache = (VkPipelineCache)GetResourceManager()->GetLiveResource(cacheId).handle; - VkResult ret = m_Real.vkCreateGraphicsPipelines(device, pipelineCache, 1, &info, &pipe); + VkResult ret = device_dispatch_table(device)->CreateGraphicsPipelines(rmDev, pipelineCache, 1, &info, &pipe); if(ret != VK_SUCCESS) { @@ -2320,7 +2332,7 @@ VkResult WrappedVulkan::vkCreateGraphicsPipelines( const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) { - VkResult ret = m_Real.vkCreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines); + VkResult ret = device_dispatch_table(device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines); if(ret == VK_SUCCESS) { @@ -2382,9 +2394,9 @@ bool WrappedVulkan::Serialise_vkCreateDescriptorPool( { VkDescriptorPool pool = VK_NULL_HANDLE; - device = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; + VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; - VkResult ret = m_Real.vkCreateDescriptorPool(device, pooluse, maxs, &info, &pool); + VkResult ret = device_dispatch_table(device)->CreateDescriptorPool(rmDev, pooluse, maxs, &info, &pool); if(ret != VK_SUCCESS) { @@ -2407,7 +2419,7 @@ VkResult WrappedVulkan::vkCreateDescriptorPool( const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) { - VkResult ret = m_Real.vkCreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); + VkResult ret = device_dispatch_table(device)->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); if(ret == VK_SUCCESS) { @@ -2454,9 +2466,9 @@ bool WrappedVulkan::Serialise_vkCreateDescriptorSetLayout( { VkDescriptorSetLayout layout = VK_NULL_HANDLE; - device = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; + VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; - VkResult ret = m_Real.vkCreateDescriptorSetLayout(device, &info, &layout); + VkResult ret = device_dispatch_table(device)->CreateDescriptorSetLayout(rmDev, &info, &layout); if(ret != VK_SUCCESS) { @@ -2477,7 +2489,7 @@ VkResult WrappedVulkan::vkCreateDescriptorSetLayout( const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) { - VkResult ret = m_Real.vkCreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); + VkResult ret = device_dispatch_table(device)->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); if(ret == VK_SUCCESS) { @@ -2520,9 +2532,9 @@ bool WrappedVulkan::Serialise_vkCreatePipelineLayout( { VkPipelineLayout layout = VK_NULL_HANDLE; - device = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; + VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; - VkResult ret = m_Real.vkCreatePipelineLayout(device, &info, &layout); + VkResult ret = device_dispatch_table(device)->CreatePipelineLayout(rmDev, &info, &layout); if(ret != VK_SUCCESS) { @@ -2543,7 +2555,7 @@ VkResult WrappedVulkan::vkCreatePipelineLayout( const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) { - VkResult ret = m_Real.vkCreatePipelineLayout(device, pCreateInfo, pPipelineLayout); + VkResult ret = device_dispatch_table(device)->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout); if(ret == VK_SUCCESS) { @@ -2588,7 +2600,7 @@ bool WrappedVulkan::Serialise_vkCreateSampler( { VkSampler samp = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateSampler((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &samp); + VkResult ret = device_dispatch_table(device)->CreateSampler((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &samp); if(ret != VK_SUCCESS) { @@ -2609,7 +2621,7 @@ VkResult WrappedVulkan::vkCreateSampler( const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { - VkResult ret = m_Real.vkCreateSampler(device, pCreateInfo, pSampler); + VkResult ret = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pSampler); if(ret == VK_SUCCESS) { @@ -2652,7 +2664,7 @@ bool WrappedVulkan::Serialise_vkCreateSemaphore( { VkSemaphore sem = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateSemaphore((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sem); + VkResult ret = device_dispatch_table(device)->CreateSemaphore((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sem); if(ret != VK_SUCCESS) { @@ -2673,7 +2685,7 @@ VkResult WrappedVulkan::vkCreateSemaphore( const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) { - VkResult ret = m_Real.vkCreateSemaphore(device, pCreateInfo, pSemaphore); + VkResult ret = device_dispatch_table(device)->CreateSemaphore(device, pCreateInfo, pSemaphore); if(ret == VK_SUCCESS) { @@ -2719,7 +2731,7 @@ bool WrappedVulkan::Serialise_vkCreateFramebuffer( // use original ID m_CreationInfo.m_Framebuffer[id].Init(GetResourceManager(), &info); - VkResult ret = m_Real.vkCreateFramebuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &fb); + VkResult ret = device_dispatch_table(device)->CreateFramebuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &fb); if(ret != VK_SUCCESS) { @@ -2740,7 +2752,7 @@ VkResult WrappedVulkan::vkCreateFramebuffer( const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) { - VkResult ret = m_Real.vkCreateFramebuffer(device, pCreateInfo, pFramebuffer); + VkResult ret = device_dispatch_table(device)->CreateFramebuffer(device, pCreateInfo, pFramebuffer); if(ret == VK_SUCCESS) { @@ -2788,7 +2800,7 @@ bool WrappedVulkan::Serialise_vkCreateRenderPass( { VkRenderPass rp = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateRenderPass((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &rp); + VkResult ret = device_dispatch_table(device)->CreateRenderPass((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &rp); if(ret != VK_SUCCESS) { @@ -2809,7 +2821,7 @@ VkResult WrappedVulkan::vkCreateRenderPass( const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) { - VkResult ret = m_Real.vkCreateRenderPass(device, pCreateInfo, pRenderPass); + VkResult ret = device_dispatch_table(device)->CreateRenderPass(device, pCreateInfo, pRenderPass); if(ret == VK_SUCCESS) { @@ -2857,7 +2869,7 @@ bool WrappedVulkan::Serialise_vkCreateDynamicViewportState( // use original ID m_CreationInfo.m_VPScissor[id].Init(GetResourceManager(), &info); - VkResult ret = m_Real.vkCreateDynamicViewportState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); + VkResult ret = device_dispatch_table(device)->CreateDynamicViewportState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); if(ret != VK_SUCCESS) { @@ -2878,7 +2890,7 @@ VkResult WrappedVulkan::vkCreateDynamicViewportState( const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState) { - VkResult ret = m_Real.vkCreateDynamicViewportState(device, pCreateInfo, pState); + VkResult ret = device_dispatch_table(device)->CreateDynamicViewportState(device, pCreateInfo, pState); if(ret == VK_SUCCESS) { @@ -2924,7 +2936,7 @@ bool WrappedVulkan::Serialise_vkCreateDynamicRasterState( // use original ID m_CreationInfo.m_Raster[id].Init(GetResourceManager(), &info); - VkResult ret = m_Real.vkCreateDynamicRasterState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); + VkResult ret = device_dispatch_table(device)->CreateDynamicRasterState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); if(ret != VK_SUCCESS) { @@ -2945,7 +2957,7 @@ VkResult WrappedVulkan::vkCreateDynamicRasterState( const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) { - VkResult ret = m_Real.vkCreateDynamicRasterState(device, pCreateInfo, pState); + VkResult ret = device_dispatch_table(device)->CreateDynamicRasterState(device, pCreateInfo, pState); if(ret == VK_SUCCESS) { @@ -2991,7 +3003,7 @@ bool WrappedVulkan::Serialise_vkCreateDynamicColorBlendState( // use original ID m_CreationInfo.m_Blend[id].Init(GetResourceManager(), &info); - VkResult ret = m_Real.vkCreateDynamicColorBlendState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); + VkResult ret = device_dispatch_table(device)->CreateDynamicColorBlendState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); if(ret != VK_SUCCESS) { @@ -3012,7 +3024,7 @@ VkResult WrappedVulkan::vkCreateDynamicColorBlendState( const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) { - VkResult ret = m_Real.vkCreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult ret = device_dispatch_table(device)->CreateDynamicColorBlendState(device, pCreateInfo, pState); if(ret == VK_SUCCESS) { @@ -3058,7 +3070,7 @@ bool WrappedVulkan::Serialise_vkCreateDynamicDepthStencilState( // use original ID m_CreationInfo.m_DepthStencil[id].Init(GetResourceManager(), &info); - VkResult ret = m_Real.vkCreateDynamicDepthStencilState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); + VkResult ret = device_dispatch_table(device)->CreateDynamicDepthStencilState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); if(ret != VK_SUCCESS) { @@ -3079,7 +3091,7 @@ VkResult WrappedVulkan::vkCreateDynamicDepthStencilState( const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState) { - VkResult ret = m_Real.vkCreateDynamicDepthStencilState(device, pCreateInfo, pState); + VkResult ret = device_dispatch_table(device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState); if(ret == VK_SUCCESS) { @@ -3124,7 +3136,7 @@ bool WrappedVulkan::Serialise_vkCreateCommandPool( { VkCmdPool pool = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateCommandPool((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &pool); + VkResult ret = device_dispatch_table(device)->CreateCommandPool((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &pool); if(ret != VK_SUCCESS) { @@ -3145,7 +3157,7 @@ VkResult WrappedVulkan::vkCreateCommandPool( const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) { - VkResult ret = m_Real.vkCreateCommandPool(device, pCreateInfo, pCmdPool); + VkResult ret = device_dispatch_table(device)->CreateCommandPool(device, pCreateInfo, pCmdPool); if(ret == VK_SUCCESS) { @@ -3181,7 +3193,7 @@ VkResult WrappedVulkan::vkResetCommandPool( VkCmdPoolResetFlags flags) { // VKTODOMED do I need to serialise this? just a driver hint.. - return m_Real.vkResetCommandPool(device, cmdPool, flags); + return device_dispatch_table(device)->ResetCommandPool(device, cmdPool, flags); } @@ -3192,7 +3204,7 @@ VkResult WrappedVulkan::vkCreateCommandBuffer( const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { - VkResult ret = m_Real.vkCreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult ret = device_dispatch_table(device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); if(ret == VK_SUCCESS) { @@ -3241,12 +3253,12 @@ bool WrappedVulkan::Serialise_vkAllocDescriptorSets( { VkDescriptorSet descset = VK_NULL_HANDLE; - device = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; + VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; descriptorPool = (VkDescriptorPool)GetResourceManager()->GetLiveResource(poolId).handle; VkDescriptorSetLayout layout = (VkDescriptorSetLayout)GetResourceManager()->GetLiveResource(layoutId).handle; uint32_t cnt = 0; - VkResult ret = m_Real.vkAllocDescriptorSets(device, descriptorPool, usage, 1, &layout, &descset, &cnt); + VkResult ret = device_dispatch_table(device)->AllocDescriptorSets(rmDev, descriptorPool, usage, 1, &layout, &descset, &cnt); if(ret != VK_SUCCESS) { @@ -3274,7 +3286,7 @@ VkResult WrappedVulkan::vkAllocDescriptorSets( VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { - VkResult ret = m_Real.vkAllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult ret = device_dispatch_table(device)->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); RDCASSERT(pCount == NULL || *pCount == count); // VKTODOMED: find out what *pCount < count means @@ -3326,7 +3338,7 @@ VkResult WrappedVulkan::vkFreeDescriptorSets( uint32_t count, const VkDescriptorSet* pDescriptorSets) { - VkResult ret = m_Real.vkFreeDescriptorSets(device, descriptorPool, count, pDescriptorSets); + VkResult ret = device_dispatch_table(device)->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets); if(ret == VK_SUCCESS) { @@ -3371,12 +3383,12 @@ bool WrappedVulkan::Serialise_vkUpdateDescriptorSets( if(m_State < WRITING) { - device = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; + VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; if(writes) - m_Real.vkUpdateDescriptorSets(device, 1, &writeDesc, 0, NULL); + device_dispatch_table(device)->UpdateDescriptorSets(rmDev, 1, &writeDesc, 0, NULL); else - m_Real.vkUpdateDescriptorSets(device, 0, NULL, 1, ©Desc); + device_dispatch_table(device)->UpdateDescriptorSets(rmDev, 0, NULL, 1, ©Desc); } return true; @@ -3389,7 +3401,7 @@ VkResult WrappedVulkan::vkUpdateDescriptorSets( uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) { - VkResult ret = m_Real.vkUpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies); + VkResult ret = device_dispatch_table(device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies); if(ret == VK_SUCCESS) { @@ -3500,7 +3512,7 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer( m_PartialReplayData.renderPassActive = false; VkCmdBuffer cmd = VK_NULL_HANDLE; - VkResult ret = m_Real.vkCreateCommandBuffer(device, &createInfo, &cmd); + VkResult ret = device_dispatch_table(cmdBuffer)->CreateCommandBuffer(device, &createInfo, &cmd); if(ret != VK_SUCCESS) { @@ -3517,7 +3529,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; - m_Real.vkBeginCommandBuffer(cmd, &info); + device_dispatch_table(cmdBuffer)->BeginCommandBuffer(cmd, &info); } } } @@ -3530,7 +3542,7 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer( if(!GetResourceManager()->HasLiveResource(bakeId)) { - VkResult ret = m_Real.vkCreateCommandBuffer(device, &createInfo, &cmd); + VkResult ret = device_dispatch_table(cmdBuffer)->CreateCommandBuffer(device, &createInfo, &cmd); if(ret != VK_SUCCESS) { @@ -3556,7 +3568,7 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer( m_CmdBufferInfo[liveBaked].device = VK_NULL_HANDLE; } - m_Real.vkBeginCommandBuffer(cmd, &info); + device_dispatch_table(cmdBuffer)->BeginCommandBuffer(cmd, &info); } return true; @@ -3589,7 +3601,7 @@ VkResult WrappedVulkan::vkBeginCommandBuffer( } } - return m_Real.vkBeginCommandBuffer(cmdBuffer, pBeginInfo); + return device_dispatch_table(cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo); } bool WrappedVulkan::Serialise_vkEndCommandBuffer(VkCmdBuffer cmdBuffer) @@ -3615,9 +3627,9 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(VkCmdBuffer cmdBuffer) RDCDEBUG("Ending partial command buffer for %llu baked to %llu", cmdId, bakeId); if(m_PartialReplayData.renderPassActive) - m_Real.vkCmdEndRenderPass(PartialCmdBuf()); + device_dispatch_table(cmdBuffer)->CmdEndRenderPass(PartialCmdBuf()); - m_Real.vkEndCommandBuffer(PartialCmdBuf()); + device_dispatch_table(cmdBuffer)->EndCommandBuffer(PartialCmdBuf()); m_PartialReplayData.partialParent = ResourceId(); } @@ -3630,7 +3642,7 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(VkCmdBuffer cmdBuffer) GetResourceManager()->RemoveReplacement(cmdId); - m_Real.vkEndCommandBuffer(cmd); + device_dispatch_table(cmdBuffer)->EndCommandBuffer(cmd); if(!m_CurEvents.empty()) { @@ -3668,7 +3680,7 @@ VkResult WrappedVulkan::vkEndCommandBuffer(VkCmdBuffer cmdBuffer) record->Bake(); } - return m_Real.vkEndCommandBuffer(cmdBuffer); + return device_dispatch_table(cmdBuffer)->EndCommandBuffer(cmdBuffer); } bool WrappedVulkan::Serialise_vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) @@ -3710,7 +3722,7 @@ bool WrappedVulkan::Serialise_vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdB if(!GetResourceManager()->HasLiveResource(bakeId)) { - VkResult ret = m_Real.vkCreateCommandBuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &cmd); + VkResult ret = device_dispatch_table(cmdBuffer)->CreateCommandBuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &cmd); if(ret != VK_SUCCESS) { @@ -3736,7 +3748,7 @@ bool WrappedVulkan::Serialise_vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdB m_CmdBufferInfo[liveBaked].device = VK_NULL_HANDLE; } - m_Real.vkResetCommandBuffer(cmd, fl); + device_dispatch_table(cmdBuffer)->ResetCommandBuffer(cmd, fl); } return true; @@ -3774,7 +3786,7 @@ VkResult WrappedVulkan::vkResetCommandBuffer( } } - return m_Real.vkResetCommandBuffer(cmdBuffer, flags); + return device_dispatch_table(cmdBuffer)->ResetCommandBuffer(cmdBuffer, flags); } // Command buffer building functions @@ -3793,7 +3805,7 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass( if(IsPartialCmd(cmdid) && InPartialRange()) { m_PartialReplayData.renderPassActive = true; - m_Real.vkCmdBeginRenderPass(PartialCmdBuf(), &beginInfo, cont); + device_dispatch_table(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))); @@ -3802,9 +3814,9 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass( } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - m_Real.vkCmdBeginRenderPass(cmdBuffer, &beginInfo, cont); + device_dispatch_table(cmdBuffer)->CmdBeginRenderPass(cmd, &beginInfo, cont); const string desc = m_pSerialiser->GetDebugStr(); @@ -3825,7 +3837,7 @@ void WrappedVulkan::vkCmdBeginRenderPass( const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) { - m_Real.vkCmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents); + device_dispatch_table(cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents); if(m_State >= WRITING) { @@ -3851,7 +3863,7 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass( if(IsPartialCmd(cmdid) && InPartialRange()) { m_PartialReplayData.renderPassActive = false; - m_Real.vkCmdEndRenderPass(PartialCmdBuf()); + device_dispatch_table(cmdBuffer)->CmdEndRenderPass(PartialCmdBuf()); m_PartialReplayData.state.renderPass = ResourceId(); m_PartialReplayData.state.framebuffer = ResourceId(); @@ -3860,9 +3872,9 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass( } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - m_Real.vkCmdEndRenderPass(cmdBuffer); + device_dispatch_table(cmdBuffer)->CmdEndRenderPass(cmd); } return true; @@ -3871,7 +3883,7 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass( void WrappedVulkan::vkCmdEndRenderPass( VkCmdBuffer cmdBuffer) { - m_Real.vkCmdEndRenderPass(cmdBuffer); + device_dispatch_table(cmdBuffer)->CmdEndRenderPass(cmdBuffer); if(m_State >= WRITING) { @@ -3899,7 +3911,7 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline( if(IsPartialCmd(cmdid) && InPartialRange()) { - m_Real.vkCmdBindPipeline(PartialCmdBuf(), bind, pipeline); + device_dispatch_table(cmdBuffer)->CmdBindPipeline(PartialCmdBuf(), bind, pipeline); if(bind == VK_PIPELINE_BIND_POINT_GRAPHICS) m_PartialReplayData.state.graphics.pipeline = pipeid; else @@ -3908,10 +3920,10 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline( } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; pipeline = (VkPipeline)GetResourceManager()->GetLiveResource(pipeid).handle; - m_Real.vkCmdBindPipeline(cmdBuffer, bind, pipeline); + device_dispatch_table(cmdBuffer)->CmdBindPipeline(cmd, bind, pipeline); } return true; @@ -3922,7 +3934,7 @@ void WrappedVulkan::vkCmdBindPipeline( VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { - m_Real.vkCmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); + device_dispatch_table(cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); if(m_State >= WRITING) { @@ -3975,7 +3987,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( if(IsPartialCmd(cmdid) && InPartialRange()) { - m_Real.vkCmdBindDescriptorSets(PartialCmdBuf(), bind, layout, first, numSets, sets, offsCount, offs); + device_dispatch_table(cmdBuffer)->CmdBindDescriptorSets(PartialCmdBuf(), bind, layout, first, numSets, sets, offsCount, offs); vector &descsets = (bind == VK_PIPELINE_BIND_POINT_GRAPHICS) @@ -3993,10 +4005,10 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; layout = (VkPipelineLayout)GetResourceManager()->GetLiveResource(layoutid).handle; - m_Real.vkCmdBindDescriptorSets(cmdBuffer, bind, layout, first, numSets, sets, offsCount, offs); + device_dispatch_table(cmdBuffer)->CmdBindDescriptorSets(cmd, bind, layout, first, numSets, sets, offsCount, offs); } if(m_State < WRITING) @@ -4018,7 +4030,7 @@ void WrappedVulkan::vkCmdBindDescriptorSets( uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { - m_Real.vkCmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + device_dispatch_table(cmdBuffer)->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); if(m_State >= WRITING) { @@ -4127,16 +4139,16 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicViewportState( if(IsPartialCmd(cmdid) && InPartialRange()) { - m_Real.vkCmdBindDynamicViewportState(PartialCmdBuf(), dynamicViewportState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicViewportState(PartialCmdBuf(), dynamicViewportState); m_PartialReplayData.state.dynamicVP = stateid; } } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; dynamicViewportState = (VkDynamicViewportState)GetResourceManager()->GetLiveResource(stateid).handle; - m_Real.vkCmdBindDynamicViewportState(cmdBuffer, dynamicViewportState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicViewportState(cmd, dynamicViewportState); } return true; @@ -4146,7 +4158,7 @@ void WrappedVulkan::vkCmdBindDynamicViewportState( VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) { - m_Real.vkCmdBindDynamicViewportState(cmdBuffer, dynamicViewportState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicViewportState(cmdBuffer, dynamicViewportState); if(m_State >= WRITING) { @@ -4173,16 +4185,16 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicRasterState( if(IsPartialCmd(cmdid) && InPartialRange()) { - m_Real.vkCmdBindDynamicRasterState(PartialCmdBuf(), dynamicRasterState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicRasterState(PartialCmdBuf(), dynamicRasterState); m_PartialReplayData.state.dynamicRS = stateid; } } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; dynamicRasterState = (VkDynamicRasterState)GetResourceManager()->GetLiveResource(stateid).handle; - m_Real.vkCmdBindDynamicRasterState(cmdBuffer, dynamicRasterState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicRasterState(cmd, dynamicRasterState); } return true; @@ -4192,7 +4204,7 @@ void WrappedVulkan::vkCmdBindDynamicRasterState( VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) { - m_Real.vkCmdBindDynamicRasterState(cmdBuffer, dynamicRasterState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState); if(m_State >= WRITING) { @@ -4219,16 +4231,16 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicColorBlendState( if(IsPartialCmd(cmdid) && InPartialRange()) { - m_Real.vkCmdBindDynamicColorBlendState(PartialCmdBuf(), dynamicColorBlendState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicColorBlendState(PartialCmdBuf(), dynamicColorBlendState); m_PartialReplayData.state.dynamicCB = stateid; } } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; dynamicColorBlendState = (VkDynamicColorBlendState)GetResourceManager()->GetLiveResource(stateid).handle; - m_Real.vkCmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicColorBlendState(cmd, dynamicColorBlendState); } return true; @@ -4238,7 +4250,7 @@ void WrappedVulkan::vkCmdBindDynamicColorBlendState( VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) { - m_Real.vkCmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); if(m_State >= WRITING) { @@ -4265,16 +4277,16 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicDepthStencilState( if(IsPartialCmd(cmdid) && InPartialRange()) { - m_Real.vkCmdBindDynamicDepthStencilState(PartialCmdBuf(), dynamicDepthStencilState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicDepthStencilState(PartialCmdBuf(), dynamicDepthStencilState); m_PartialReplayData.state.dynamicDS = stateid; } } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; dynamicDepthStencilState = (VkDynamicDepthStencilState)GetResourceManager()->GetLiveResource(stateid).handle; - m_Real.vkCmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicDepthStencilState(cmd, dynamicDepthStencilState); } return true; @@ -4284,7 +4296,7 @@ void WrappedVulkan::vkCmdBindDynamicDepthStencilState( VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) { - m_Real.vkCmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState); + device_dispatch_table(cmdBuffer)->CmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState); if(m_State >= WRITING) { @@ -4338,7 +4350,7 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers( { if(IsPartialCmd(cmdid) && InPartialRange()) { - m_Real.vkCmdBindVertexBuffers(PartialCmdBuf(), start, count, &bufs[0], &offs[0]); + device_dispatch_table(cmdBuffer)->CmdBindVertexBuffers(PartialCmdBuf(), start, count, &bufs[0], &offs[0]); if(m_PartialReplayData.state.vbuffers.size() < start + count) m_PartialReplayData.state.vbuffers.resize(start + count); @@ -4352,9 +4364,9 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers( } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - m_Real.vkCmdBindVertexBuffers(cmdBuffer, start, count, &bufs[0], &offs[0]); + device_dispatch_table(cmdBuffer)->CmdBindVertexBuffers(cmd, start, count, &bufs[0], &offs[0]); } return true; @@ -4367,7 +4379,7 @@ void WrappedVulkan::vkCmdBindVertexBuffers( const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { - m_Real.vkCmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets); + device_dispatch_table(cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets); if(m_State >= WRITING) { @@ -4400,7 +4412,7 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer( if(IsPartialCmd(cmdid) && InPartialRange()) { - m_Real.vkCmdBindIndexBuffer(PartialCmdBuf(), buffer, offs, idxType); + device_dispatch_table(cmdBuffer)->CmdBindIndexBuffer(PartialCmdBuf(), buffer, offs, idxType); m_PartialReplayData.state.ibuffer.buf = bufid; m_PartialReplayData.state.ibuffer.offs = offs; @@ -4409,10 +4421,10 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer( } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; - m_Real.vkCmdBindIndexBuffer(cmdBuffer, buffer, offs, idxType); + device_dispatch_table(cmdBuffer)->CmdBindIndexBuffer(cmd, buffer, offs, idxType); } return true; @@ -4424,7 +4436,7 @@ void WrappedVulkan::vkCmdBindIndexBuffer( VkDeviceSize offset, VkIndexType indexType) { - m_Real.vkCmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); + device_dispatch_table(cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); if(m_State >= WRITING) { @@ -4454,13 +4466,13 @@ bool WrappedVulkan::Serialise_vkCmdDraw( if(m_State == EXECUTING) { if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdDraw(PartialCmdBuf(), firstVtx, vtxCount, firstInst, instCount); + device_dispatch_table(cmdBuffer)->CmdDraw(PartialCmdBuf(), firstVtx, vtxCount, firstInst, instCount); } else if(m_State == READING) { VkCmdBuffer buf = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - m_Real.vkCmdDraw(buf, firstVtx, vtxCount, firstInst, instCount); + device_dispatch_table(cmdBuffer)->CmdDraw(buf, firstVtx, vtxCount, firstInst, instCount); const string desc = m_pSerialiser->GetDebugStr(); @@ -4494,7 +4506,7 @@ void WrappedVulkan::vkCmdDraw( uint32_t firstInstance, uint32_t instanceCount) { - m_Real.vkCmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); + device_dispatch_table(cmdBuffer)->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); if(m_State >= WRITING) { @@ -4534,15 +4546,15 @@ bool WrappedVulkan::Serialise_vkCmdBlitImage( destImage = (VkImage)GetResourceManager()->GetLiveResource(dstid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdBlitImage(PartialCmdBuf(), srcImage, srclayout, destImage, dstlayout, count, regions, f); + device_dispatch_table(cmdBuffer)->CmdBlitImage(PartialCmdBuf(), srcImage, srclayout, destImage, dstlayout, count, regions, f); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; srcImage = (VkImage)GetResourceManager()->GetLiveResource(srcid).handle; destImage = (VkImage)GetResourceManager()->GetLiveResource(dstid).handle; - m_Real.vkCmdBlitImage(cmdBuffer, srcImage, srclayout, destImage, dstlayout, count, regions, f); + device_dispatch_table(cmdBuffer)->CmdBlitImage(cmd, srcImage, srclayout, destImage, dstlayout, count, regions, f); } SAFE_DELETE_ARRAY(regions); @@ -4560,7 +4572,7 @@ void WrappedVulkan::vkCmdBlitImage( const VkImageBlit* pRegions, VkTexFilter filter) { - m_Real.vkCmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter); + device_dispatch_table(cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter); if(m_State >= WRITING) { @@ -4601,15 +4613,15 @@ bool WrappedVulkan::Serialise_vkCmdCopyImage( destImage = (VkImage)GetResourceManager()->GetLiveResource(dstid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdCopyImage(PartialCmdBuf(), srcImage, srclayout, destImage, dstlayout, count, regions); + device_dispatch_table(cmdBuffer)->CmdCopyImage(PartialCmdBuf(), srcImage, srclayout, destImage, dstlayout, count, regions); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; srcImage = (VkImage)GetResourceManager()->GetLiveResource(srcid).handle; destImage = (VkImage)GetResourceManager()->GetLiveResource(dstid).handle; - m_Real.vkCmdCopyImage(cmdBuffer, srcImage, srclayout, destImage, dstlayout, count, regions); + device_dispatch_table(cmdBuffer)->CmdCopyImage(cmd, srcImage, srclayout, destImage, dstlayout, count, regions); } SAFE_DELETE_ARRAY(regions); @@ -4626,7 +4638,7 @@ void WrappedVulkan::vkCmdCopyImage( uint32_t regionCount, const VkImageCopy* pRegions) { - m_Real.vkCmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); + device_dispatch_table(cmdBuffer)->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); if(m_State >= WRITING) { @@ -4665,15 +4677,15 @@ bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage( destImage = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdCopyBufferToImage(PartialCmdBuf(), srcBuffer, destImage, destImageLayout, count, regions); + device_dispatch_table(cmdBuffer)->CmdCopyBufferToImage(PartialCmdBuf(), srcBuffer, destImage, destImageLayout, count, regions); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; srcBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; destImage = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; - m_Real.vkCmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, count, regions); + device_dispatch_table(cmdBuffer)->CmdCopyBufferToImage(cmd, srcBuffer, destImage, destImageLayout, count, regions); } SAFE_DELETE_ARRAY(regions); @@ -4689,7 +4701,7 @@ void WrappedVulkan::vkCmdCopyBufferToImage( uint32_t regionCount, const VkBufferImageCopy* pRegions) { - m_Real.vkCmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); + device_dispatch_table(cmdBuffer)->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); if(m_State >= WRITING) { @@ -4729,15 +4741,15 @@ bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer( destBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdCopyImageToBuffer(PartialCmdBuf(), srcImage, layout, destBuffer, count, regions); + device_dispatch_table(cmdBuffer)->CmdCopyImageToBuffer(PartialCmdBuf(), srcImage, layout, destBuffer, count, regions); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; srcImage = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; destBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; - m_Real.vkCmdCopyImageToBuffer(cmdBuffer, srcImage, layout, destBuffer, count, regions); + device_dispatch_table(cmdBuffer)->CmdCopyImageToBuffer(cmd, srcImage, layout, destBuffer, count, regions); } SAFE_DELETE_ARRAY(regions); @@ -4753,7 +4765,7 @@ void WrappedVulkan::vkCmdCopyImageToBuffer( uint32_t regionCount, const VkBufferImageCopy* pRegions) { - m_Real.vkCmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); + device_dispatch_table(cmdBuffer)->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); if(m_State >= WRITING) { @@ -4791,15 +4803,15 @@ bool WrappedVulkan::Serialise_vkCmdCopyBuffer( destBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(dstid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdCopyBuffer(PartialCmdBuf(), srcBuffer, destBuffer, count, regions); + device_dispatch_table(cmdBuffer)->CmdCopyBuffer(PartialCmdBuf(), srcBuffer, destBuffer, count, regions); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; srcBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(srcid).handle; destBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(dstid).handle; - m_Real.vkCmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, count, regions); + device_dispatch_table(cmdBuffer)->CmdCopyBuffer(cmd, srcBuffer, destBuffer, count, regions); } SAFE_DELETE_ARRAY(regions); @@ -4814,7 +4826,7 @@ void WrappedVulkan::vkCmdCopyBuffer( uint32_t regionCount, const VkBufferCopy* pRegions) { - m_Real.vkCmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); + device_dispatch_table(cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); if(m_State >= WRITING) { @@ -4853,14 +4865,14 @@ bool WrappedVulkan::Serialise_vkCmdClearColorImage( image = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdClearColorImage(PartialCmdBuf(), image, layout, &col, count, ranges); + device_dispatch_table(cmdBuffer)->CmdClearColorImage(PartialCmdBuf(), image, layout, &col, count, ranges); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; image = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; - m_Real.vkCmdClearColorImage(cmdBuffer, image, layout, &col, count, ranges); + device_dispatch_table(cmdBuffer)->CmdClearColorImage(cmd, image, layout, &col, count, ranges); } SAFE_DELETE_ARRAY(ranges); @@ -4876,7 +4888,7 @@ void WrappedVulkan::vkCmdClearColorImage( uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { - m_Real.vkCmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges); + device_dispatch_table(cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges); if(m_State >= WRITING) { @@ -4912,14 +4924,14 @@ bool WrappedVulkan::Serialise_vkCmdClearDepthStencilImage( image = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdClearDepthStencilImage(PartialCmdBuf(), image, l, d, s, count, ranges); + device_dispatch_table(cmdBuffer)->CmdClearDepthStencilImage(PartialCmdBuf(), image, l, d, s, count, ranges); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; image = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; - m_Real.vkCmdClearDepthStencilImage(cmdBuffer, image, l, d, s, count, ranges); + device_dispatch_table(cmdBuffer)->CmdClearDepthStencilImage(cmd, image, l, d, s, count, ranges); } SAFE_DELETE_ARRAY(ranges); @@ -4936,7 +4948,7 @@ void WrappedVulkan::vkCmdClearDepthStencilImage( uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { - m_Real.vkCmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); + device_dispatch_table(cmdBuffer)->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); if(m_State >= WRITING) { @@ -4969,13 +4981,13 @@ bool WrappedVulkan::Serialise_vkCmdClearColorAttachment( if(m_State == EXECUTING) { if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdClearColorAttachment(PartialCmdBuf(), att, layout, &col, count, rects); + device_dispatch_table(cmdBuffer)->CmdClearColorAttachment(PartialCmdBuf(), att, layout, &col, count, rects); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - m_Real.vkCmdClearColorAttachment(cmdBuffer, att, layout, &col, count, rects); + device_dispatch_table(cmdBuffer)->CmdClearColorAttachment(cmdBuffer, att, layout, &col, count, rects); const string desc = m_pSerialiser->GetDebugStr(); @@ -5006,7 +5018,7 @@ void WrappedVulkan::vkCmdClearColorAttachment( uint32_t rectCount, const VkRect3D* pRects) { - m_Real.vkCmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects); + device_dispatch_table(cmdBuffer)->CmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects); if(m_State >= WRITING) { @@ -5041,13 +5053,13 @@ bool WrappedVulkan::Serialise_vkCmdClearDepthStencilAttachment( if(m_State == EXECUTING) { if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdClearDepthStencilAttachment(PartialCmdBuf(), asp, lay, d, s, count, rects); + device_dispatch_table(cmdBuffer)->CmdClearDepthStencilAttachment(PartialCmdBuf(), asp, lay, d, s, count, rects); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - m_Real.vkCmdClearDepthStencilAttachment(cmdBuffer, asp, lay, d, s, count, rects); + device_dispatch_table(cmdBuffer)->CmdClearDepthStencilAttachment(cmd, asp, lay, d, s, count, rects); } SAFE_DELETE_ARRAY(rects); @@ -5064,7 +5076,7 @@ void WrappedVulkan::vkCmdClearDepthStencilAttachment( uint32_t rectCount, const VkRect3D* pRects) { - m_Real.vkCmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects); + device_dispatch_table(cmdBuffer)->CmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects); if(m_State >= WRITING) { @@ -5132,7 +5144,7 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( { if(IsPartialCmd(cmdid) && InPartialRange()) { - m_Real.vkCmdPipelineBarrier(PartialCmdBuf(), src, dest, region, memCount, (const void **)&mems[0]); + device_dispatch_table(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]); @@ -5140,12 +5152,12 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - m_Real.vkCmdPipelineBarrier(cmdBuffer, src, dest, region, memCount, (const void **)&mems[0]); + device_dispatch_table(cmdBuffer)->CmdPipelineBarrier(cmd, src, dest, region, memCount, (const void **)&mems[0]); - ResourceId cmd = GetResourceManager()->GetID(MakeRes(cmdBuffer)); - GetResourceManager()->RecordTransitions(m_CmdBufferInfo[cmd].imgtransitions, m_ImageInfo, (uint32_t)imTrans.size(), &imTrans[0]); + ResourceId rmcmd = GetResourceManager()->GetID(MakeRes(cmdBuffer)); + GetResourceManager()->RecordTransitions(m_CmdBufferInfo[rmcmd].imgtransitions, m_ImageInfo, (uint32_t)imTrans.size(), &imTrans[0]); } for(size_t i=0; i < mems.size(); i++) @@ -5162,7 +5174,7 @@ void WrappedVulkan::vkCmdPipelineBarrier( uint32_t memBarrierCount, const void* const* ppMemBarriers) { - m_Real.vkCmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers); + device_dispatch_table(cmdBuffer)->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers); if(m_State >= WRITING) { @@ -5198,14 +5210,14 @@ VkResult WrappedVulkan::vkDbgCreateMsgCallback( void* pUserData, VkDbgMsgCallback* pMsgCallback) { - return m_Real.vkDbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback); + return instance_dispatch_table(instance)->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback); } VkResult WrappedVulkan::vkDbgDestroyMsgCallback( VkInstance instance, VkDbgMsgCallback msgCallback) { - return m_Real.vkDbgDestroyMsgCallback(instance, msgCallback); + return instance_dispatch_table(instance)->DbgDestroyMsgCallback(instance, msgCallback); } bool WrappedVulkan::Serialise_vkCmdDbgMarkerBegin( @@ -5427,7 +5439,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 }; - m_Real.vkBeginCommandBuffer(cmd, &beginInfo); + device_dispatch_table(cmd)->BeginCommandBuffer(cmd, &beginInfo); VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; VkPipelineStageFlags dest_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; @@ -5437,11 +5449,11 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(bool applyInitialState) vector barriers; for(size_t i=0; i < imgTransitions.size(); i++) barriers.push_back(&imgTransitions[i]); - m_Real.vkCmdPipelineBarrier(cmd, src_stages, dest_stages, false, (uint32_t)imgTransitions.size(), (const void *const *)&barriers[0]); + device_dispatch_table(cmd)->CmdPipelineBarrier(cmd, src_stages, dest_stages, false, (uint32_t)imgTransitions.size(), (const void *const *)&barriers[0]); } - m_Real.vkEndCommandBuffer(cmd); - m_Real.vkQueueSubmit(GetQ(), 1, &cmd, VK_NULL_HANDLE); + device_dispatch_table(cmd)->EndCommandBuffer(cmd); + device_dispatch_table(GetQ())->QueueSubmit(GetQ(), 1, &cmd, VK_NULL_HANDLE); } return true; @@ -5464,7 +5476,7 @@ void WrappedVulkan::FinishCapture() //m_SuccessfulCapture = false; - m_Real.vkDeviceWaitIdle(GetDev()); + device_dispatch_table(GetDev())->DeviceWaitIdle(GetDev()); } void WrappedVulkan::ReadLogInitialisation() @@ -5579,7 +5591,7 @@ void WrappedVulkan::ContextReplayLog(LogState readType, uint32_t startEventID, u Serialise_BeginCaptureFrame(!partial); - m_Real.vkDeviceWaitIdle(GetDev()); + device_dispatch_table(GetDev())->DeviceWaitIdle(GetDev()); m_pSerialiser->PopContext(NULL, header); @@ -5661,8 +5673,8 @@ void WrappedVulkan::ContextReplayLog(LogState readType, uint32_t startEventID, u if(m_PartialReplayData.resultPartialCmdBuffer != VK_NULL_HANDLE) { - m_Real.vkDeviceWaitIdle(m_PartialReplayData.partialDevice); - m_Real.vkDestroyCommandBuffer(m_PartialReplayData.partialDevice, m_PartialReplayData.resultPartialCmdBuffer); + device_dispatch_table(GetDev())->DeviceWaitIdle(m_PartialReplayData.partialDevice); + device_dispatch_table(GetDev())->DestroyCommandBuffer(m_PartialReplayData.partialDevice, m_PartialReplayData.resultPartialCmdBuffer); m_PartialReplayData.resultPartialCmdBuffer = VK_NULL_HANDLE; } @@ -5780,13 +5792,13 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexed( if(m_State == EXECUTING) { if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdDrawIndexed(PartialCmdBuf(), firstIdx, idxCount, vtxOffs, firstInst, instCount); + device_dispatch_table(cmdBuffer)->CmdDrawIndexed(PartialCmdBuf(), firstIdx, idxCount, vtxOffs, firstInst, instCount); } else if(m_State == READING) { VkCmdBuffer buf = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - m_Real.vkCmdDrawIndexed(buf, firstIdx, idxCount, vtxOffs, firstInst, instCount); + device_dispatch_table(cmdBuffer)->CmdDrawIndexed(buf, firstIdx, idxCount, vtxOffs, firstInst, instCount); } return true; @@ -5800,7 +5812,7 @@ void WrappedVulkan::vkCmdDrawIndexed( uint32_t firstInstance, uint32_t instanceCount) { - m_Real.vkCmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); + device_dispatch_table(cmdBuffer)->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); if(m_State >= WRITING) { @@ -5832,14 +5844,14 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndirect( buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdDrawIndirect(PartialCmdBuf(), buffer, offs, cnt, strd); + device_dispatch_table(cmdBuffer)->CmdDrawIndirect(PartialCmdBuf(), buffer, offs, cnt, strd); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; - m_Real.vkCmdDrawIndirect(cmdBuffer, buffer, offs, cnt, strd); + device_dispatch_table(cmdBuffer)->CmdDrawIndirect(cmd, buffer, offs, cnt, strd); } return true; @@ -5852,7 +5864,7 @@ void WrappedVulkan::vkCmdDrawIndirect( uint32_t count, uint32_t stride) { - m_Real.vkCmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); + device_dispatch_table(cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); if(m_State >= WRITING) { @@ -5884,14 +5896,14 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect( buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdDrawIndexedIndirect(PartialCmdBuf(), buffer, offs, cnt, strd); + device_dispatch_table(cmdBuffer)->CmdDrawIndexedIndirect(PartialCmdBuf(), buffer, offs, cnt, strd); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; - m_Real.vkCmdDrawIndexedIndirect(cmdBuffer, buffer, offs, cnt, strd); + device_dispatch_table(cmdBuffer)->CmdDrawIndexedIndirect(cmd, buffer, offs, cnt, strd); } return true; @@ -5904,7 +5916,7 @@ void WrappedVulkan::vkCmdDrawIndexedIndirect( uint32_t count, uint32_t stride) { - m_Real.vkCmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); + device_dispatch_table(cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); if(m_State >= WRITING) { @@ -5931,13 +5943,13 @@ bool WrappedVulkan::Serialise_vkCmdDispatch( if(m_State == EXECUTING) { if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdDispatch(PartialCmdBuf(), x, y, z); + device_dispatch_table(cmdBuffer)->CmdDispatch(PartialCmdBuf(), x, y, z); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - m_Real.vkCmdDispatch(cmdBuffer, X, Y, Z); + device_dispatch_table(cmdBuffer)->CmdDispatch(cmd, X, Y, Z); } return true; @@ -5949,7 +5961,7 @@ void WrappedVulkan::vkCmdDispatch( uint32_t y, uint32_t z) { - m_Real.vkCmdDispatch(cmdBuffer, x, y, z); + device_dispatch_table(cmdBuffer)->CmdDispatch(cmdBuffer, x, y, z); if(m_State >= WRITING) { @@ -5976,14 +5988,14 @@ bool WrappedVulkan::Serialise_vkCmdDispatchIndirect( buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - m_Real.vkCmdDispatchIndirect(PartialCmdBuf(), buffer, offs); + device_dispatch_table(cmdBuffer)->CmdDispatchIndirect(PartialCmdBuf(), buffer, offs); } else if(m_State == READING) { - cmdBuffer = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; + VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; - m_Real.vkCmdDispatchIndirect(cmdBuffer, buffer, offs); + device_dispatch_table(cmdBuffer)->CmdDispatchIndirect(cmd, buffer, offs); } return true; @@ -5994,7 +6006,7 @@ void WrappedVulkan::vkCmdDispatchIndirect( VkBuffer buffer, VkDeviceSize offset) { - m_Real.vkCmdDispatchIndirect(cmdBuffer, buffer, offset); + device_dispatch_table(cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset); if(m_State >= WRITING) { @@ -6016,7 +6028,7 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceSurfaceSupportWSI( const VkSurfaceDescriptionWSI* pSurfaceDescription, VkBool32* pSupported) { - return m_Real.vkGetPhysicalDeviceSurfaceSupportWSI(physicalDevice, queueFamilyIndex, pSurfaceDescription, pSupported); + return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceSupportWSI(physicalDevice, queueFamilyIndex, pSurfaceDescription, pSupported); } VkResult WrappedVulkan::vkGetSurfaceInfoWSI( @@ -6026,7 +6038,7 @@ VkResult WrappedVulkan::vkGetSurfaceInfoWSI( size_t* pDataSize, void* pData) { - return m_Real.vkGetSurfaceInfoWSI(device, pSurfaceDescription, infoType, pDataSize, pData); + return device_dispatch_table(device)->GetSurfaceInfoWSI(device, pSurfaceDescription, infoType, pDataSize, pData); } bool WrappedVulkan::Serialise_vkGetSwapChainInfoWSI( @@ -6071,7 +6083,7 @@ VkResult WrappedVulkan::vkGetSwapChainInfoWSI( if(pDataSize == NULL) pDataSize = &dummySize; - VkResult ret = m_Real.vkGetSwapChainInfoWSI(device, swapChain, infoType, pDataSize, pData); + VkResult ret = device_dispatch_table(device)->GetSwapChainInfoWSI(device, swapChain, infoType, pDataSize, pData); if(infoType == VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI && pData && m_State >= WRITING) { @@ -6125,7 +6137,7 @@ VkResult WrappedVulkan::vkAcquireNextImageWSI( uint32_t* pImageIndex) { // VKTODOLOW: does this need to be intercepted/serialised? - return m_Real.vkAcquireNextImageWSI(device, swapChain, timeout, semaphore, pImageIndex); + return device_dispatch_table(device)->AcquireNextImageWSI(device, swapChain, timeout, semaphore, pImageIndex); } bool WrappedVulkan::Serialise_vkCreateSwapChainWSI( @@ -6143,9 +6155,9 @@ bool WrappedVulkan::Serialise_vkCreateSwapChainWSI( { VkResult vkr = VK_SUCCESS; - size_t swapChainImagesSize; - vkr = m_Real.vkGetSwapChainInfoWSI(device, *pSwapChain, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &swapChainImagesSize, NULL); - RDCASSERT(vkr == VK_SUCCESS); + size_t swapChainImagesSize; + vkr = device_dispatch_table(device)->GetSwapChainInfoWSI(device, *pSwapChain, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &swapChainImagesSize, NULL); + RDCASSERT(vkr == VK_SUCCESS); numIms = uint32_t(swapChainImagesSize/sizeof(VkSwapChainImagePropertiesWSI)); } @@ -6191,12 +6203,12 @@ bool WrappedVulkan::Serialise_vkCreateSwapChainWSI( VkDeviceMemory mem = VK_NULL_HANDLE; VkImage im = VK_NULL_HANDLE; - VkResult vkr = m_Real.vkCreateImage(dev, &imInfo, &im); + VkResult vkr = device_dispatch_table(device)->CreateImage(dev, &imInfo, &im); RDCASSERT(vkr == VK_SUCCESS); VkMemoryRequirements mrq = {0}; - vkr = m_Real.vkGetImageMemoryRequirements(dev, im, &mrq); + vkr = device_dispatch_table(device)->GetImageMemoryRequirements(dev, im, &mrq); RDCASSERT(vkr == VK_SUCCESS); VkMemoryAllocInfo allocInfo = { @@ -6204,10 +6216,10 @@ bool WrappedVulkan::Serialise_vkCreateSwapChainWSI( mrq.size, GetGPULocalMemoryIndex(mrq.memoryTypeBits), }; - vkr = m_Real.vkAllocMemory(dev, &allocInfo, &mem); + vkr = device_dispatch_table(device)->AllocMemory(dev, &allocInfo, &mem); RDCASSERT(vkr == VK_SUCCESS); - vkr = m_Real.vkBindImageMemory(dev, im, mem, 0); + vkr = device_dispatch_table(device)->BindImageMemory(dev, im, mem, 0); RDCASSERT(vkr == VK_SUCCESS); GetResourceManager()->RegisterResource(MakeRes(mem)); @@ -6248,7 +6260,7 @@ VkResult WrappedVulkan::vkCreateSwapChainWSI( const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain) { - VkResult ret = m_Real.vkCreateSwapChainWSI(device, pCreateInfo, pSwapChain); + VkResult ret = device_dispatch_table(device)->CreateSwapChainWSI(device, pCreateInfo, pSwapChain); if(ret == VK_SUCCESS) { @@ -6278,7 +6290,7 @@ VkResult WrappedVulkan::vkCreateSwapChainWSI( // serialise out the swap chain images { size_t swapChainImagesSize; - VkResult ret = m_Real.vkGetSwapChainInfoWSI(device, *pSwapChain, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &swapChainImagesSize, NULL); + VkResult ret = device_dispatch_table(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); @@ -6332,7 +6344,7 @@ VkResult WrappedVulkan::vkQueuePresentWSI( VkQueue queue, VkPresentInfoWSI* pPresentInfo) { - VkResult ret = m_Real.vkQueuePresentWSI(queue, pPresentInfo); + VkResult ret = device_dispatch_table(queue)->QueuePresentWSI(queue, pPresentInfo); if(ret != VK_SUCCESS || pPresentInfo->swapChainCount == 0) return ret; @@ -6382,7 +6394,7 @@ VkResult WrappedVulkan::vkQueuePresentWSI( for(size_t i=0; i < m_FrameRecord.size(); i++) RDCLOG("Captured Frame %d. Multiple frame capture not supported.\n", m_FrameRecord[i].frameInfo.frameNumber); #if !defined(RELEASE) - RDCLOG("%llu chunks - %.2f MB", Chunk::NumLiveChunks(), float(Chunk::TotalMem())/1024.0f/1024.0f); + // RDCLOG("%llu chunks - %.2f MB", Chunk::NumLiveChunks(), float(Chunk::TotalMem())/1024.0f/1024.0f); #endif } } @@ -6554,12 +6566,12 @@ bool WrappedVulkan::Prepare_InitialState(VkResource res) meminfo.size, GetReadbackMemoryIndex(mrq.memoryTypeBits), }; - vkr = m_Real.vkAllocMemory(d, &allocInfo, &mem); + vkr = device_dispatch_table(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 = m_Real.vkBeginCommandBuffer(cmd, &beginInfo); + vkr = device_dispatch_table(cmd)->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); VkBufferCreateInfo bufInfo = { @@ -6570,33 +6582,33 @@ bool WrappedVulkan::Prepare_InitialState(VkResource res) VkBuffer srcBuf, dstBuf; - vkr = m_Real.vkCreateBuffer(d, &bufInfo, &srcBuf); + vkr = device_dispatch_table(d)->CreateBuffer(d, &bufInfo, &srcBuf); RDCASSERT(vkr == VK_SUCCESS); - vkr = m_Real.vkCreateBuffer(d, &bufInfo, &dstBuf); + vkr = device_dispatch_table(d)->CreateBuffer(d, &bufInfo, &dstBuf); RDCASSERT(vkr == VK_SUCCESS); - vkr = m_Real.vkBindBufferMemory(d, srcBuf, (VkDeviceMemory)res.handle, 0); + vkr = device_dispatch_table(d)->BindBufferMemory(d, srcBuf, (VkDeviceMemory)res.handle, 0); RDCASSERT(vkr == VK_SUCCESS); - vkr = m_Real.vkBindBufferMemory(d, dstBuf, mem, 0); + vkr = device_dispatch_table(d)->BindBufferMemory(d, dstBuf, mem, 0); RDCASSERT(vkr == VK_SUCCESS); VkBufferCopy region = { 0, 0, meminfo.size }; - m_Real.vkCmdCopyBuffer(cmd, srcBuf, dstBuf, 1, ®ion); + device_dispatch_table(cmd)->CmdCopyBuffer(cmd, srcBuf, dstBuf, 1, ®ion); - vkr = m_Real.vkEndCommandBuffer(cmd); + vkr = device_dispatch_table(cmd)->EndCommandBuffer(cmd); RDCASSERT(vkr == VK_SUCCESS); - vkr = m_Real.vkQueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vkr = device_dispatch_table(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. - m_Real.vkQueueWaitIdle(q); + device_dispatch_table(q)->QueueWaitIdle(q); - m_Real.vkDestroyBuffer(d, srcBuf); - m_Real.vkDestroyBuffer(d, dstBuf); + device_dispatch_table(d)->DestroyBuffer(d, srcBuf); + device_dispatch_table(d)->DestroyBuffer(d, dstBuf); GetResourceManager()->SetInitialContents(id, VulkanResourceManager::InitialContentData(MakeRes(mem), (uint32_t)meminfo.size, NULL)); @@ -6652,13 +6664,13 @@ bool WrappedVulkan::Serialise_InitialState(VkResource res) VkDevice d = GetDev(); byte *ptr = NULL; - m_Real.vkMapMemory(d, (VkDeviceMemory)initContents.resource.handle, 0, 0, 0, (void **)&ptr); + device_dispatch_table(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); - m_Real.vkUnmapMemory(d, (VkDeviceMemory)initContents.resource.handle); + device_dispatch_table(d)->UnmapMemory(d, (VkDeviceMemory)initContents.resource.handle); } } else @@ -6720,7 +6732,7 @@ bool WrappedVulkan::Serialise_InitialState(VkResource res) dataSize, GetUploadMemoryIndex(mrq.memoryTypeBits), }; - vkr = m_Real.vkAllocMemory(d, &allocInfo, &mem); + vkr = device_dispatch_table(d)->AllocMemory(d, &allocInfo, &mem); RDCASSERT(vkr == VK_SUCCESS); VkBufferCreateInfo bufInfo = { @@ -6731,20 +6743,20 @@ bool WrappedVulkan::Serialise_InitialState(VkResource res) VkBuffer buf; - vkr = m_Real.vkCreateBuffer(d, &bufInfo, &buf); + vkr = device_dispatch_table(d)->CreateBuffer(d, &bufInfo, &buf); RDCASSERT(vkr == VK_SUCCESS); - vkr = m_Real.vkBindBufferMemory(d, buf, mem, 0); + vkr = device_dispatch_table(d)->BindBufferMemory(d, buf, mem, 0); RDCASSERT(vkr == VK_SUCCESS); byte *ptr = NULL; - m_Real.vkMapMemory(d, mem, 0, 0, 0, (void **)&ptr); + device_dispatch_table(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); - m_Real.vkUnmapMemory(d, mem); + device_dispatch_table(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)); @@ -6801,7 +6813,7 @@ void WrappedVulkan::Apply_InitialState(VkResource live, VulkanResourceManager::I VkWriteDescriptorSet *writes = (VkWriteDescriptorSet *)initial.blob; - VkResult vkr = m_Real.vkUpdateDescriptorSets(GetDev(), initial.num, writes, 0, NULL); + VkResult vkr = device_dispatch_table(GetDev())->UpdateDescriptorSets(GetDev(), initial.num, writes, 0, NULL); RDCASSERT(vkr == VK_SUCCESS); } else if(live.Namespace == eResDeviceMemory) @@ -6827,7 +6839,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 = m_Real.vkBeginCommandBuffer(cmd, &beginInfo); + vkr = device_dispatch_table(cmd)->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); VkBufferCreateInfo bufInfo = { @@ -6839,28 +6851,28 @@ void WrappedVulkan::Apply_InitialState(VkResource live, VulkanResourceManager::I VkBuffer dstBuf; // VKTODOMED this should be created once up front, not every time - vkr = m_Real.vkCreateBuffer(d, &bufInfo, &dstBuf); + vkr = device_dispatch_table(d)->CreateBuffer(d, &bufInfo, &dstBuf); RDCASSERT(vkr == VK_SUCCESS); - vkr = m_Real.vkBindBufferMemory(d, dstBuf, dstMem, 0); + vkr = device_dispatch_table(d)->BindBufferMemory(d, dstBuf, dstMem, 0); RDCASSERT(vkr == VK_SUCCESS); VkBufferCopy region = { 0, 0, meminfo.size }; - m_Real.vkCmdCopyBuffer(cmd, srcBuf, dstBuf, 1, ®ion); + device_dispatch_table(cmd)->CmdCopyBuffer(cmd, srcBuf, dstBuf, 1, ®ion); - vkr = m_Real.vkEndCommandBuffer(cmd); + vkr = device_dispatch_table(cmd)->EndCommandBuffer(cmd); RDCASSERT(vkr == VK_SUCCESS); - vkr = m_Real.vkQueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vkr = device_dispatch_table(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. - m_Real.vkQueueWaitIdle(q); + device_dispatch_table(q)->QueueWaitIdle(q); - m_Real.vkDestroyBuffer(d, dstBuf); + device_dispatch_table(d)->DestroyBuffer(d, dstBuf); } else if(live.Namespace == eResImage) { @@ -7225,11 +7237,10 @@ void WrappedVulkan::ReplayLog(uint32_t frameID, uint32_t startEventID, uint32_t VkDevice dev = GetDev(); VkCmdBuffer cmd = GetCmd(); VkQueue q = GetQ(); - const VulkanFunctions &vk = m_Real; 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 = vk.vkBeginCommandBuffer(cmd, &beginInfo); + VkResult vkr = device_dispatch_table(cmd)->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); ImgState &st = m_ImageInfo[GetResourceManager()->GetLiveID(m_FakeBBImgId)]; @@ -7250,15 +7261,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; - vk.vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, (void **)&barrier); + device_dispatch_table(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, } }; - vk.vkCmdClearColorImage(cmd, m_FakeBBIm, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, &clearColor, 1, &t.subresourceRange); + device_dispatch_table(cmd)->CmdClearColorImage(cmd, m_FakeBBIm, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, &clearColor, 1, &t.subresourceRange); - vkr = vk.vkEndCommandBuffer(cmd); + vkr = device_dispatch_table(cmd)->EndCommandBuffer(cmd); RDCASSERT(vkr == VK_SUCCESS); - vkr = vk.vkQueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vkr = device_dispatch_table(q)->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); RDCASSERT(vkr == VK_SUCCESS); } } diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 24b4cc26f..25fa00713 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -32,11 +32,16 @@ #include "replay/replay_driver.h" #include "vk_common.h" -#include "vk_hookset.h" #include "vk_info.h" #include "vk_manager.h" #include "vk_replay.h" +// layer includes + +#include "vk_layer.h" +#include "vk_layer_table.h" +#include "vk_layer_extension_utils.h" + using std::vector; using std::list; @@ -88,8 +93,6 @@ struct DrawcallTreeNode class WrappedVulkan { private: - const VulkanFunctions &m_Real; - friend class VulkanReplay; enum { @@ -390,7 +393,7 @@ private: } public: - WrappedVulkan(const VulkanFunctions &real, const char *logFilename); + WrappedVulkan(const char *logFilename); ~WrappedVulkan(); ResourceId GetContextResourceID() { return m_ContextResourceID; } diff --git a/renderdoc/driver/vulkan/vk_hookset_defs.h b/renderdoc/driver/vulkan/vk_hookset_defs.h index 76c74c77f..1d7bede0a 100644 --- a/renderdoc/driver/vulkan/vk_hookset_defs.h +++ b/renderdoc/driver/vulkan/vk_hookset_defs.h @@ -24,7 +24,7 @@ #pragma once -#define HookInitVulkan() \ +#define HookInitVulkanInstance() \ HookInit(vkCreateInstance); \ HookInit(vkDestroyInstance); \ HookInit(vkEnumeratePhysicalDevices); \ @@ -36,6 +36,11 @@ HookInit(vkGetPhysicalDeviceQueueCount); \ HookInit(vkGetPhysicalDeviceQueueProperties); \ HookInit(vkGetPhysicalDeviceMemoryProperties); \ + HookInit(vkDbgCreateMsgCallback); \ + HookInit(vkDbgDestroyMsgCallback); \ + HookInit(vkGetPhysicalDeviceSurfaceSupportWSI) + +#define HookInitVulkanDevice() \ HookInit(vkCreateDevice); \ HookInit(vkDestroyDevice); \ HookInit(vkGetGlobalExtensionProperties); \ @@ -135,13 +140,12 @@ HookInit(vkCmdDbgMarkerEnd); \ HookInit(vkDbgCreateMsgCallback); \ HookInit(vkDbgDestroyMsgCallback); \ - HookInit(vkGetPhysicalDeviceSurfaceSupportWSI); \ HookInit(vkCreateSwapChainWSI); \ HookInit(vkDestroySwapChainWSI); \ HookInit(vkGetSurfaceInfoWSI); \ HookInit(vkGetSwapChainInfoWSI); \ HookInit(vkAcquireNextImageWSI); \ - HookInit(vkQueuePresentWSI); + HookInit(vkQueuePresentWSI) #define DefineHooks() \ HookDefine2(VkResult, vkCreateInstance, const VkInstanceCreateInfo*, pCreateInfo, VkInstance*, pInstance); \ @@ -260,4 +264,4 @@ HookDefine5(VkResult, vkGetSurfaceInfoWSI, VkDevice, device, const VkSurfaceDescriptionWSI*, pSurfaceDescription, VkSurfaceInfoTypeWSI, infoType, size_t*, pDataSize, void*, pData); \ HookDefine5(VkResult, vkGetSwapChainInfoWSI, VkDevice, device, VkSwapChainWSI, swapChain, VkSwapChainInfoTypeWSI, infoType, size_t*, pDataSize, void*, pData); \ HookDefine5(VkResult, vkAcquireNextImageWSI, VkDevice, device, VkSwapChainWSI, swapChain, uint64_t, timeout, VkSemaphore, semaphore, uint32_t*, pImageIndex); \ - HookDefine2(VkResult, vkQueuePresentWSI, VkQueue, queue, VkPresentInfoWSI*, pPresentInfo); + HookDefine2(VkResult, vkQueuePresentWSI, VkQueue, queue, VkPresentInfoWSI*, pPresentInfo) diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index 27dc9637c..c14f15249 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -25,6 +25,7 @@ #include "vk_replay.h" #include "vk_core.h" #include "vk_resources.h" +#include "vk_layer_table.h" #include "serialise/string_utils.h" @@ -96,22 +97,22 @@ void VulkanReplay::OutputWindow::SetDS(VkDeviceMemory mem, VkImage img) void VulkanReplay::OutputWindow::Destroy(WrappedVulkan *driver, VkDevice device) { - const VulkanFunctions &vk = driver->m_Real; + const VkLayerDispatchTable *vt = device_dispatch_table(device); - vk.vkDeviceWaitIdle(device); + vt->DeviceWaitIdle(device); if(bb != VK_NULL_HANDLE) { - vk.vkDestroyRenderPass(device, renderpass); + vt->DestroyRenderPass(device, renderpass); renderpass = VK_NULL_HANDLE; - vk.vkDestroyDynamicViewportState(device, fullVP); + vt->DestroyDynamicViewportState(device, fullVP); fullVP = VK_NULL_HANDLE; - vk.vkDestroyImage(device, bb); - vk.vkDestroyAttachmentView(device, bbview); - vk.vkFreeMemory(device, bbmem); - vk.vkDestroyFramebuffer(device, fb); + vt->DestroyImage(device, bb); + vt->DestroyAttachmentView(device, bbview); + vt->FreeMemory(device, bbmem); + vt->DestroyFramebuffer(device, fb); bb = VK_NULL_HANDLE; bbview = VK_NULL_HANDLE; @@ -125,10 +126,10 @@ void VulkanReplay::OutputWindow::Destroy(WrappedVulkan *driver, VkDevice device) if(dsimg != VK_NULL_HANDLE) { - vk.vkDestroyAttachmentView(device, dsview); - vk.vkDestroyImage(device, dsimg); - vk.vkFreeMemory(device, dsmem); - vk.vkDestroyFramebuffer(device, fbdepth); + vt->DestroyAttachmentView(device, dsview); + vt->DestroyImage(device, dsimg); + vt->FreeMemory(device, dsmem); + vt->DestroyFramebuffer(device, fbdepth); dsview = VK_NULL_HANDLE; dsimg = VK_NULL_HANDLE; @@ -137,12 +138,12 @@ void VulkanReplay::OutputWindow::Destroy(WrappedVulkan *driver, VkDevice device) } if(swap != VK_NULL_HANDLE) - vk.vkDestroySwapChainWSI(device, swap); + vt->DestroySwapChainWSI(device, swap); } void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, bool depth) { - const VulkanFunctions &vk = driver->m_Real; + const VkLayerDispatchTable *vt = device_dispatch_table(device); // save the old swapchain so it isn't destroyed VkSwapChainWSI old = swap; @@ -167,20 +168,20 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, old, true, }; - VkResult vkr = vk.vkCreateSwapChainWSI(device, &swapInfo, &swap); + VkResult vkr = vt->CreateSwapChainWSI(device, &swapInfo, &swap); RDCASSERT(vkr == VK_SUCCESS); if(old != VK_NULL_HANDLE) - vk.vkDestroySwapChainWSI(device, old); + vt->DestroySwapChainWSI(device, old); size_t sz; - vkr = vk.vkGetSwapChainInfoWSI(device, swap, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &sz, NULL); + vkr = vt->GetSwapChainInfoWSI(device, swap, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &sz, NULL); RDCASSERT(vkr == VK_SUCCESS); numImgs = uint32_t(sz/sizeof(VkSwapChainImagePropertiesWSI)); VkSwapChainImagePropertiesWSI* imgs = new VkSwapChainImagePropertiesWSI[numImgs]; - vkr = vk.vkGetSwapChainInfoWSI(device, swap, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &sz, imgs); + vkr = vt->GetSwapChainInfoWSI(device, swap, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &sz, imgs); RDCASSERT(vkr == VK_SUCCESS); for(size_t i=0; i < numImgs; i++) @@ -231,7 +232,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, 0, NULL, // dependencies }; - vkr = vk.vkCreateRenderPass(device, &rpinfo, &renderpass); + vkr = vt->CreateRenderPass(device, &rpinfo, &renderpass); RDCASSERT(vkr == VK_SUCCESS); } @@ -244,7 +245,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, 1, &vp, &sc }; - VkResult vkr = vk.vkCreateDynamicViewportState(device, &vpInfo, &fullVP); + VkResult vkr = vt->CreateDynamicViewportState(device, &vpInfo, &fullVP); RDCASSERT(vkr == VK_SUCCESS); } @@ -259,12 +260,12 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, 0, NULL, }; - VkResult vkr = vk.vkCreateImage(device, &imInfo, &bb); + VkResult vkr = vt->CreateImage(device, &imInfo, &bb); RDCASSERT(vkr == VK_SUCCESS); VkMemoryRequirements mrq = {0}; - vkr = vk.vkGetImageMemoryRequirements(device, bb, &mrq); + vkr = vt->GetImageMemoryRequirements(device, bb, &mrq); RDCASSERT(vkr == VK_SUCCESS); VkMemoryAllocInfo allocInfo = { @@ -272,10 +273,10 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, mrq.size, driver->GetGPULocalMemoryIndex(mrq.memoryTypeBits), }; - vkr = vk.vkAllocMemory(device, &allocInfo, &bbmem); + vkr = vt->AllocMemory(device, &allocInfo, &bbmem); RDCASSERT(vkr == VK_SUCCESS); - vkr = vk.vkBindImageMemory(device, bb, bbmem, 0); + vkr = vt->BindImageMemory(device, bb, bbmem, 0); RDCASSERT(vkr == VK_SUCCESS); bbtrans.image = bb; @@ -288,7 +289,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, bb, VK_FORMAT_B8G8R8A8_UNORM, 0, 0, 1, 0 }; - vkr = vk.vkCreateAttachmentView(device, &info, &bbview); + vkr = vt->CreateAttachmentView(device, &info, &bbview); RDCASSERT(vkr == VK_SUCCESS); VkAttachmentBindInfo attBind = { bbview, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; @@ -300,7 +301,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, (uint32_t)width, (uint32_t)height, 1, }; - vkr = vk.vkCreateFramebuffer(device, &fbinfo, &fb); + vkr = vt->CreateFramebuffer(device, &fbinfo, &fb); RDCASSERT(vkr == VK_SUCCESS); } @@ -311,14 +312,14 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, dsimg, VK_FORMAT_D32_SFLOAT_S8_UINT, 0, 0, 1, 0 }; - vkr = vk.vkCreateAttachmentView(device, &info, &dsview); + vkr = vt->CreateAttachmentView(device, &info, &dsview); RDCASSERT(vkr == VK_SUCCESS); } } void VulkanReplay::UBO::Create(WrappedVulkan *driver, VkDevice dev, VkDeviceSize size) { - const VulkanFunctions &vk = driver->m_Real; + const VkLayerDispatchTable *vt = device_dispatch_table(dev); VkBufferCreateInfo bufInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, NULL, @@ -326,11 +327,11 @@ void VulkanReplay::UBO::Create(WrappedVulkan *driver, VkDevice dev, VkDeviceSize VK_SHARING_MODE_EXCLUSIVE, 0, NULL, }; - VkResult vkr = vk.vkCreateBuffer(dev, &bufInfo, &buf); + VkResult vkr = vt->CreateBuffer(dev, &bufInfo, &buf); RDCASSERT(vkr == VK_SUCCESS); VkMemoryRequirements mrq; - vkr = vk.vkGetBufferMemoryRequirements(dev, buf, &mrq); + vkr = vt->GetBufferMemoryRequirements(dev, buf, &mrq); RDCASSERT(vkr == VK_SUCCESS); // VKTODOMED maybe don't require host visible, and do map & copy? @@ -339,10 +340,10 @@ void VulkanReplay::UBO::Create(WrappedVulkan *driver, VkDevice dev, VkDeviceSize size, driver->GetUploadMemoryIndex(mrq.memoryTypeBits), }; - vkr = vk.vkAllocMemory(dev, &allocInfo, &mem); + vkr = vt->AllocMemory(dev, &allocInfo, &mem); RDCASSERT(vkr == VK_SUCCESS); - vkr = vk.vkBindBufferMemory(dev, buf, mem, 0); + vkr = vt->BindBufferMemory(dev, buf, mem, 0); RDCASSERT(vkr == VK_SUCCESS); VkBufferViewCreateInfo bufviewInfo = { @@ -351,28 +352,28 @@ void VulkanReplay::UBO::Create(WrappedVulkan *driver, VkDevice dev, VkDeviceSize VK_FORMAT_UNDEFINED, 0, size, }; - vkr = vk.vkCreateBufferView(dev, &bufviewInfo, &view); + vkr = vt->CreateBufferView(dev, &bufviewInfo, &view); RDCASSERT(vkr == VK_SUCCESS); } -void VulkanReplay::UBO::Destroy(const VulkanFunctions &vk, VkDevice dev) +void VulkanReplay::UBO::Destroy(const VkLayerDispatchTable *vt, VkDevice dev) { - vk.vkDestroyBufferView(dev, view); - vk.vkDestroyBuffer(dev, buf); - vk.vkFreeMemory(dev, mem); + vt->DestroyBufferView(dev, view); + vt->DestroyBuffer(dev, buf); + vt->FreeMemory(dev, mem); } -void *VulkanReplay::UBO::Map(const VulkanFunctions &vk, VkDevice dev, VkDeviceSize offset, VkDeviceSize size) +void *VulkanReplay::UBO::Map(const VkLayerDispatchTable *vt, VkDevice dev, VkDeviceSize offset, VkDeviceSize size) { void *ptr = NULL; - VkResult vkr = vk.vkMapMemory(dev, mem, offset, size, 0, (void **)&ptr); + VkResult vkr = vt->MapMemory(dev, mem, offset, size, 0, (void **)&ptr); RDCASSERT(vkr == VK_SUCCESS); return ptr; } -void VulkanReplay::UBO::Unmap(const VulkanFunctions &vk, VkDevice dev) +void VulkanReplay::UBO::Unmap(const VkLayerDispatchTable *vt, VkDevice dev) { - vk.vkUnmapMemory(dev, mem); + vt->UnmapMemory(dev, mem); } VulkanReplay::VulkanReplay() @@ -387,8 +388,8 @@ VulkanReplay::VulkanReplay() void VulkanReplay::InitDebugData() { - const VulkanFunctions &vk = m_pDriver->m_Real; VkDevice dev = m_pDriver->GetDev(); + const VkLayerDispatchTable *vt = device_dispatch_table(dev); VkResult vkr = VK_SUCCESS; @@ -408,7 +409,7 @@ void VulkanReplay::InitDebugData() // VKTODOMED will have to be created on the fly for whichever image we're // viewing (and cached) - vkr = vk.vkCreateImageView(dev, &bbviewInfo, &m_FakeBBImView); + vkr = vt->CreateImageView(dev, &bbviewInfo, &m_FakeBBImView); RDCASSERT(vkr == VK_SUCCESS); VkSamplerCreateInfo sampInfo = { @@ -423,21 +424,21 @@ void VulkanReplay::InitDebugData() VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, }; - vkr = vk.vkCreateSampler(dev, &sampInfo, &m_LinearSampler); + vkr = vt->CreateSampler(dev, &sampInfo, &m_LinearSampler); RDCASSERT(vkr == VK_SUCCESS); sampInfo.minFilter = VK_TEX_FILTER_NEAREST; sampInfo.magFilter = VK_TEX_FILTER_NEAREST; sampInfo.mipMode = VK_TEX_MIPMAP_MODE_NEAREST; - vkr = vk.vkCreateSampler(dev, &sampInfo, &m_PointSampler); + vkr = vt->CreateSampler(dev, &sampInfo, &m_PointSampler); RDCASSERT(vkr == VK_SUCCESS); // VKTODOMED all of this is leaking VkPipelineCacheCreateInfo cacheInfo = { VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, NULL, 0, NULL, 0 }; - vkr = vk.vkCreatePipelineCache(dev, &cacheInfo, &m_PipelineCache); + vkr = vt->CreatePipelineCache(dev, &cacheInfo, &m_PipelineCache); RDCASSERT(vkr == VK_SUCCESS); { @@ -450,7 +451,7 @@ void VulkanReplay::InitDebugData() ARRAY_COUNT(layoutBinding), &layoutBinding[0], }; - vkr = vk.vkCreateDescriptorSetLayout(dev, &descsetLayoutInfo, &m_CheckerboardDescSetLayout); + vkr = vt->CreateDescriptorSetLayout(dev, &descsetLayoutInfo, &m_CheckerboardDescSetLayout); RDCASSERT(vkr == VK_SUCCESS); } @@ -465,7 +466,7 @@ void VulkanReplay::InitDebugData() ARRAY_COUNT(layoutBinding), &layoutBinding[0], }; - vkr = vk.vkCreateDescriptorSetLayout(dev, &descsetLayoutInfo, &m_TexDisplayDescSetLayout); + vkr = vt->CreateDescriptorSetLayout(dev, &descsetLayoutInfo, &m_TexDisplayDescSetLayout); RDCASSERT(vkr == VK_SUCCESS); } @@ -475,12 +476,12 @@ void VulkanReplay::InitDebugData() 0, NULL, // push constant ranges }; - vkr = vk.vkCreatePipelineLayout(dev, &pipeLayoutInfo, &m_TexDisplayPipeLayout); + vkr = vt->CreatePipelineLayout(dev, &pipeLayoutInfo, &m_TexDisplayPipeLayout); RDCASSERT(vkr == VK_SUCCESS); pipeLayoutInfo.pSetLayouts = &m_CheckerboardDescSetLayout; - vkr = vk.vkCreatePipelineLayout(dev, &pipeLayoutInfo, &m_CheckerboardPipeLayout); + vkr = vt->CreatePipelineLayout(dev, &pipeLayoutInfo, &m_CheckerboardPipeLayout); RDCASSERT(vkr == VK_SUCCESS); VkDescriptorTypeCount descPoolTypes[] = { @@ -493,14 +494,14 @@ void VulkanReplay::InitDebugData() ARRAY_COUNT(descPoolTypes), &descPoolTypes[0], }; - vkr = vk.vkCreateDescriptorPool(dev, VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 2, &descpoolInfo, &m_DescriptorPool); + vkr = vt->CreateDescriptorPool(dev, VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 2, &descpoolInfo, &m_DescriptorPool); RDCASSERT(vkr == VK_SUCCESS); uint32_t count; - vkr = vk.vkAllocDescriptorSets(dev, m_DescriptorPool, VK_DESCRIPTOR_SET_USAGE_STATIC, 1, &m_CheckerboardDescSetLayout, &m_CheckerboardDescSet, &count); + vkr = vt->AllocDescriptorSets(dev, m_DescriptorPool, VK_DESCRIPTOR_SET_USAGE_STATIC, 1, &m_CheckerboardDescSetLayout, &m_CheckerboardDescSet, &count); RDCASSERT(vkr == VK_SUCCESS); - vkr = vk.vkAllocDescriptorSets(dev, m_DescriptorPool, VK_DESCRIPTOR_SET_USAGE_STATIC, 1, &m_TexDisplayDescSetLayout, &m_TexDisplayDescSet, &count); + vkr = vt->AllocDescriptorSets(dev, m_DescriptorPool, VK_DESCRIPTOR_SET_USAGE_STATIC, 1, &m_TexDisplayDescSetLayout, &m_TexDisplayDescSet, &count); RDCASSERT(vkr == VK_SUCCESS); m_CheckerboardUBO.Create(m_pDriver, dev, 128); @@ -532,7 +533,7 @@ void VulkanReplay::InitDebugData() }, }; - vkr = vk.vkUpdateDescriptorSets(dev, ARRAY_COUNT(writeSet), writeSet, 0, NULL); + vkr = vt->UpdateDescriptorSets(dev, ARRAY_COUNT(writeSet), writeSet, 0, NULL); RDCASSERT(vkr == VK_SUCCESS); VkDynamicRasterStateCreateInfo rsInfo = { @@ -540,7 +541,7 @@ void VulkanReplay::InitDebugData() 0.0f, 0.0f, 0.0f, 1.0f, }; - vkr = vk.vkCreateDynamicRasterState(dev, &rsInfo, &m_DynamicRSState); + vkr = vt->CreateDynamicRasterState(dev, &rsInfo, &m_DynamicRSState); RDCASSERT(vkr == VK_SUCCESS); VkDynamicColorBlendStateCreateInfo cbInfo = { @@ -548,7 +549,7 @@ void VulkanReplay::InitDebugData() { 1.0f, 1.0f, 1.0f, 1.0f }, }; - vkr = vk.vkCreateDynamicColorBlendState(dev, &cbInfo, &m_DynamicCBStateWhite); + vkr = vt->CreateDynamicColorBlendState(dev, &cbInfo, &m_DynamicCBStateWhite); RDCASSERT(vkr == VK_SUCCESS); VkDynamicDepthStencilStateCreateInfo dsInfo = { @@ -556,7 +557,7 @@ void VulkanReplay::InitDebugData() 0.0f, 1.0f, 0xff, 0xff, 0, 0, }; - vkr = vk.vkCreateDynamicDepthStencilState(dev, &dsInfo, &m_DynamicDSStateDisabled); + vkr = vt->CreateDynamicDepthStencilState(dev, &dsInfo, &m_DynamicDSStateDisabled); RDCASSERT(vkr == VK_SUCCESS); string shaderSources[] = { @@ -582,7 +583,7 @@ void VulkanReplay::InitDebugData() shaderSources[i].size(), (void *)&shaderSources[i][0], 0, }; - vkr = vk.vkCreateShaderModule(dev, &modinfo, &module[i]); + vkr = vt->CreateShaderModule(dev, &modinfo, &module[i]); RDCASSERT(vkr == VK_SUCCESS); VkShaderCreateInfo shadinfo = { @@ -590,7 +591,7 @@ void VulkanReplay::InitDebugData() module[i], "main", 0, }; - vkr = vk.vkCreateShader(dev, &shadinfo, &shader[i]); + vkr = vt->CreateShader(dev, &shadinfo, &shader[i]); RDCASSERT(vkr == VK_SUCCESS); } @@ -661,29 +662,29 @@ void VulkanReplay::InitDebugData() stages[0].shader = shader[BLITVS]; stages[1].shader = shader[CHECKERBOARDFS]; - vkr = vk.vkCreateGraphicsPipelines(dev, m_PipelineCache, 1, &pipeInfo, &m_CheckerboardPipeline); + vkr = vt->CreateGraphicsPipelines(dev, m_PipelineCache, 1, &pipeInfo, &m_CheckerboardPipeline); RDCASSERT(vkr == VK_SUCCESS); stages[1].shader = shader[TEXDISPLAYFS]; pipeInfo.layout = m_TexDisplayPipeLayout; - vkr = vk.vkCreateGraphicsPipelines(dev, m_PipelineCache, 1, &pipeInfo, &m_TexDisplayPipeline); + vkr = vt->CreateGraphicsPipelines(dev, m_PipelineCache, 1, &pipeInfo, &m_TexDisplayPipeline); RDCASSERT(vkr == VK_SUCCESS); attState.blendEnable = true; attState.srcBlendColor = VK_BLEND_SRC_ALPHA; attState.destBlendColor = VK_BLEND_ONE_MINUS_SRC_ALPHA; - vkr = vk.vkCreateGraphicsPipelines(dev, m_PipelineCache, 1, &pipeInfo, &m_TexDisplayBlendPipeline); + vkr = vt->CreateGraphicsPipelines(dev, m_PipelineCache, 1, &pipeInfo, &m_TexDisplayBlendPipeline); RDCASSERT(vkr == VK_SUCCESS); for(size_t i=0; i < ARRAY_COUNT(module); i++) { - vkr = vk.vkDestroyShader(dev, shader[i]); + vkr = vt->DestroyShader(dev, shader[i]); RDCASSERT(vkr == VK_SUCCESS); - vkr = vk.vkDestroyShaderModule(dev, module[i]); + vkr = vt->DestroyShaderModule(dev, module[i]); RDCASSERT(vkr == VK_SUCCESS); } } @@ -786,7 +787,7 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, uint32_ VkDevice dev = m_pDriver->GetDev(); VkCmdBuffer cmd = m_pDriver->GetCmd(); VkQueue q = m_pDriver->GetQ(); - const VulkanFunctions &vk = m_pDriver->m_Real; + const VkLayerDispatchTable *vt = device_dispatch_table(dev); // VKTODOMED this should be all created offline, including separate host and // readback buffers @@ -800,11 +801,11 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, uint32_ VK_SHARING_MODE_EXCLUSIVE, 0, NULL, }; - VkResult vkr = vk.vkCreateBuffer(dev, &bufInfo, &destbuf); + VkResult vkr = vt->CreateBuffer(dev, &bufInfo, &destbuf); RDCASSERT(vkr == VK_SUCCESS); VkMemoryRequirements mrq; - vkr = vk.vkGetBufferMemoryRequirements(dev, destbuf, &mrq); + vkr = vt->GetBufferMemoryRequirements(dev, destbuf, &mrq); RDCASSERT(vkr == VK_SUCCESS); VkMemoryAllocInfo allocInfo = { @@ -812,10 +813,10 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, uint32_ 128, m_pDriver->GetReadbackMemoryIndex(mrq.memoryTypeBits), }; - vkr = vk.vkAllocMemory(dev, &allocInfo, &readbackmem); + vkr = vt->AllocMemory(dev, &allocInfo, &readbackmem); RDCASSERT(vkr == VK_SUCCESS); - vkr = vk.vkBindBufferMemory(dev, destbuf, readbackmem, 0); + vkr = vt->BindBufferMemory(dev, destbuf, readbackmem, 0); RDCASSERT(vkr == VK_SUCCESS); // VKTODOHIGH find out the actual current image state @@ -827,11 +828,11 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, uint32_ 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 = vk.vkBeginCommandBuffer(cmd, &beginInfo); + vkr = vt->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); void *barrier = (void *)&fakeTrans; - vk.vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); + vt->CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); fakeTrans.oldLayout = fakeTrans.newLayout; VkBufferImageCopy region = { @@ -839,22 +840,22 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, uint32_ { VK_IMAGE_ASPECT_COLOR, 0, 0}, { (int)x, (int)y, 0 }, { 1, 1, 1 }, }; - vk.vkCmdCopyImageToBuffer(cmd, fakeBBIm, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, destbuf, 1, ®ion); + vt->CmdCopyImageToBuffer(cmd, fakeBBIm, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, destbuf, 1, ®ion); fakeTrans.newLayout = VK_IMAGE_LAYOUT_PRESENT_SOURCE_WSI; - vk.vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); + vt->CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); - vk.vkEndCommandBuffer(cmd); + vt->EndCommandBuffer(cmd); - vk.vkQueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vt->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); - vk.vkQueueWaitIdle(q); + vt->QueueWaitIdle(q); } // VKTODOHIGH ultra cheeky - map memory directly without copying // to host-visible memory byte *pData = NULL; - vk.vkMapMemory(dev, readbackmem, 0, 0, 0, (void **)&pData); + vt->MapMemory(dev, readbackmem, 0, 0, 0, (void **)&pData); RDCASSERT(pData != NULL); @@ -875,12 +876,12 @@ void VulkanReplay::PickPixel(ResourceId texture, uint32_t x, uint32_t y, uint32_ pixel[3] = float(pData[3])/255.0f; } - vk.vkUnmapMemory(dev, readbackmem); + vt->UnmapMemory(dev, readbackmem); - vk.vkDeviceWaitIdle(dev); + vt->DeviceWaitIdle(dev); - vk.vkDestroyBuffer(dev, destbuf); - vk.vkFreeMemory(dev, readbackmem); + vt->DestroyBuffer(dev, destbuf); + vt->FreeMemory(dev, readbackmem); } uint32_t VulkanReplay::PickVertex(uint32_t frameID, uint32_t eventID, MeshDisplay cfg, uint32_t x, uint32_t y) @@ -909,11 +910,11 @@ bool VulkanReplay::RenderTexture(TextureDisplay cfg) VkDevice dev = m_pDriver->GetDev(); VkCmdBuffer cmd = m_pDriver->GetCmd(); VkQueue q = m_pDriver->GetQ(); - const VulkanFunctions &vk = m_pDriver->m_Real; + const VkLayerDispatchTable *vt = device_dispatch_table(dev); // VKTODOHIGH once we stop doing DeviceWaitIdle/QueueWaitIdle all over, this // needs to be ring-buffered - displayuniforms *data = (displayuniforms *)m_TexDisplayUBO.Map(vk, dev); + displayuniforms *data = (displayuniforms *)m_TexDisplayUBO.Map(vt, dev); data->Padding = 0; @@ -991,7 +992,7 @@ bool VulkanReplay::RenderTexture(TextureDisplay cfg) data->RawOutput = cfg.rawoutput ? 1 : 0; - m_TexDisplayUBO.Unmap(vk, dev); + m_TexDisplayUBO.Unmap(vt, dev); VkDescriptorInfo desc = {0}; desc.imageLayout = VK_IMAGE_LAYOUT_GENERAL; @@ -1005,7 +1006,7 @@ bool VulkanReplay::RenderTexture(TextureDisplay cfg) m_TexDisplayDescSet, 1, 0, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &desc }; - VkResult vkr = vk.vkUpdateDescriptorSets(dev, 1, &writeSet, 0, NULL); + VkResult vkr = vt->UpdateDescriptorSets(dev, 1, &writeSet, 0, NULL); RDCASSERT(vkr == VK_SUCCESS); // VKTODOHIGH find out the actual current image state @@ -1017,12 +1018,12 @@ bool VulkanReplay::RenderTexture(TextureDisplay cfg) 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 = vk.vkBeginCommandBuffer(cmd, &beginInfo); + vkr = vt->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); void *barrier = (void *)&fakeTrans; - vk.vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); + vt->CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); fakeTrans.oldLayout = fakeTrans.newLayout; { @@ -1033,32 +1034,32 @@ bool VulkanReplay::RenderTexture(TextureDisplay cfg) { { 0, 0, }, { outw.width, outw.height } }, 1, &clearval, }; - vk.vkCmdBeginRenderPass(cmd, &rpbegin, VK_RENDER_PASS_CONTENTS_INLINE); + vt->CmdBeginRenderPass(cmd, &rpbegin, VK_RENDER_PASS_CONTENTS_INLINE); // VKTODOMED will need a way to disable blend for other things - vk.vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, cfg.rawoutput ? m_TexDisplayPipeline : m_TexDisplayBlendPipeline); - vk.vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_TexDisplayPipeLayout, 0, 1, &m_TexDisplayDescSet, 0, NULL); + vt->CmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, cfg.rawoutput ? m_TexDisplayPipeline : m_TexDisplayBlendPipeline); + vt->CmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_TexDisplayPipeLayout, 0, 1, &m_TexDisplayDescSet, 0, NULL); - vk.vkCmdBindDynamicViewportState(cmd, outw.fullVP); - vk.vkCmdBindDynamicRasterState(cmd, m_DynamicRSState); - vk.vkCmdBindDynamicColorBlendState(cmd, m_DynamicCBStateWhite); - vk.vkCmdBindDynamicDepthStencilState(cmd, m_DynamicDSStateDisabled); + vt->CmdBindDynamicViewportState(cmd, outw.fullVP); + vt->CmdBindDynamicRasterState(cmd, m_DynamicRSState); + vt->CmdBindDynamicColorBlendState(cmd, m_DynamicCBStateWhite); + vt->CmdBindDynamicDepthStencilState(cmd, m_DynamicDSStateDisabled); - vk.vkCmdDraw(cmd, 0, 4, 0, 1); - vk.vkCmdEndRenderPass(cmd); + vt->CmdDraw(cmd, 0, 4, 0, 1); + vt->CmdEndRenderPass(cmd); } fakeTrans.newLayout = VK_IMAGE_LAYOUT_PRESENT_SOURCE_WSI; - vk.vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); + vt->CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); - vk.vkEndCommandBuffer(cmd); + vt->EndCommandBuffer(cmd); - vk.vkQueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vt->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); // VKTODOMED ideally all the commands from Bind to Flip would be recorded // into a single command buffer and we can just have several allocated // ring-buffer style - vk.vkQueueWaitIdle(q); + vt->QueueWaitIdle(q); return false; } @@ -1074,25 +1075,25 @@ void VulkanReplay::RenderCheckerboard(Vec3f light, Vec3f dark) VkDevice dev = m_pDriver->GetDev(); VkCmdBuffer cmd = m_pDriver->GetCmd(); VkQueue q = m_pDriver->GetQ(); - const VulkanFunctions &vk = m_pDriver->m_Real; + const VkLayerDispatchTable *vt = device_dispatch_table(dev); 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 = vk.vkBeginCommandBuffer(cmd, &beginInfo); + VkResult vkr = vt->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); void *barrier = (void *)&outw.bbtrans; // VKTODOHIGH once we stop doing DeviceWaitIdle/QueueWaitIdle all over, this // needs to be ring-buffered - Vec4f *data = (Vec4f *)m_CheckerboardUBO.Map(vk, dev); + Vec4f *data = (Vec4f *)m_CheckerboardUBO.Map(vt, dev); data[0].x = light.x; data[0].y = light.y; data[0].z = light.z; data[1].x = dark.x; data[1].y = dark.y; data[1].z = dark.z; - m_CheckerboardUBO.Unmap(vk, dev); + m_CheckerboardUBO.Unmap(vt, dev); { VkClearValue clearval = {0}; @@ -1102,30 +1103,30 @@ void VulkanReplay::RenderCheckerboard(Vec3f light, Vec3f dark) { { 0, 0, }, { outw.width, outw.height } }, 1, &clearval, }; - vk.vkCmdBeginRenderPass(cmd, &rpbegin, VK_RENDER_PASS_CONTENTS_INLINE); + vt->CmdBeginRenderPass(cmd, &rpbegin, VK_RENDER_PASS_CONTENTS_INLINE); - vk.vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_CheckerboardPipeline); - vk.vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_CheckerboardPipeLayout, 0, 1, &m_CheckerboardDescSet, 0, NULL); + vt->CmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_CheckerboardPipeline); + vt->CmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_CheckerboardPipeLayout, 0, 1, &m_CheckerboardDescSet, 0, NULL); - vk.vkCmdBindDynamicViewportState(cmd, outw.fullVP); - vk.vkCmdBindDynamicRasterState(cmd, m_DynamicRSState); - vk.vkCmdBindDynamicColorBlendState(cmd, m_DynamicCBStateWhite); - vk.vkCmdBindDynamicDepthStencilState(cmd, m_DynamicDSStateDisabled); + vt->CmdBindDynamicViewportState(cmd, outw.fullVP); + vt->CmdBindDynamicRasterState(cmd, m_DynamicRSState); + vt->CmdBindDynamicColorBlendState(cmd, m_DynamicCBStateWhite); + vt->CmdBindDynamicDepthStencilState(cmd, m_DynamicDSStateDisabled); - vk.vkCmdDraw(cmd, 0, 4, 0, 1); - vk.vkCmdEndRenderPass(cmd); + vt->CmdDraw(cmd, 0, 4, 0, 1); + vt->CmdEndRenderPass(cmd); } - vkr = vk.vkEndCommandBuffer(cmd); + vkr = vt->EndCommandBuffer(cmd); RDCASSERT(vkr == VK_SUCCESS); - vkr = vk.vkQueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vkr = vt->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); RDCASSERT(vkr == VK_SUCCESS); // VKTODOMED ideally all the commands from Bind to Flip would be recorded // into a single command buffer and we can just have several allocated // ring-buffer style - vk.vkQueueWaitIdle(q); + vt->QueueWaitIdle(q); } void VulkanReplay::RenderHighlightBox(float w, float h, float scale) @@ -1190,26 +1191,26 @@ void VulkanReplay::BindOutputWindow(uint64_t id, bool depth) VkDevice dev = m_pDriver->GetDev(); VkCmdBuffer cmd = m_pDriver->GetCmd(); VkQueue q = m_pDriver->GetQ(); - const VulkanFunctions &vk = m_pDriver->m_Real; + const VkLayerDispatchTable *vt = device_dispatch_table(dev); VkSemaphore sem; VkSemaphoreCreateInfo semInfo = { VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, NULL, VK_FENCE_CREATE_SIGNALED_BIT }; - VkResult vkr = vk.vkCreateSemaphore(dev, &semInfo, &sem); + VkResult vkr = vt->CreateSemaphore(dev, &semInfo, &sem); RDCASSERT(vkr == VK_SUCCESS); - vkr = vk.vkAcquireNextImageWSI(dev, outw.swap, UINT64_MAX, sem, &outw.curidx); + vkr = vt->AcquireNextImageWSI(dev, outw.swap, UINT64_MAX, sem, &outw.curidx); RDCASSERT(vkr == VK_SUCCESS); - vkr = vk.vkQueueWaitSemaphore(q, sem); + vkr = vt->QueueWaitSemaphore(q, sem); RDCASSERT(vkr == VK_SUCCESS); - vkr = vk.vkDestroySemaphore(dev, sem); + vkr = vt->DestroySemaphore(dev, sem); 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 = vk.vkBeginCommandBuffer(cmd, &beginInfo); + vkr = vt->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); void *barrier[] = { @@ -1220,19 +1221,19 @@ void VulkanReplay::BindOutputWindow(uint64_t id, bool depth) outw.bbtrans.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; outw.coltrans[outw.curidx].newLayout = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL; - vk.vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 2, barrier); + vt->CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 2, barrier); outw.bbtrans.oldLayout = outw.bbtrans.newLayout; outw.coltrans[outw.curidx].oldLayout = outw.bbtrans.newLayout; - vk.vkEndCommandBuffer(cmd); + vt->EndCommandBuffer(cmd); - vk.vkQueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vt->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); // VKTODOMED ideally all the commands from Bind to Flip would be recorded // into a single command buffer and we can just have several allocated // ring-buffer style - vk.vkQueueWaitIdle(q); + vt->QueueWaitIdle(q); } void VulkanReplay::ClearOutputWindowColour(uint64_t id, float col[4]) @@ -1246,23 +1247,23 @@ void VulkanReplay::ClearOutputWindowColour(uint64_t id, float col[4]) VkDevice dev = m_pDriver->GetDev(); VkCmdBuffer cmd = m_pDriver->GetCmd(); VkQueue q = m_pDriver->GetQ(); - const VulkanFunctions &vk = m_pDriver->m_Real; + const VkLayerDispatchTable *vt = device_dispatch_table(dev); 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 = vk.vkBeginCommandBuffer(cmd, &beginInfo); + VkResult vkr = vt->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); - vk.vkCmdClearColorImage(cmd, outw.bb, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, (VkClearColorValue *)col, 1, &outw.bbtrans.subresourceRange); + vt->CmdClearColorImage(cmd, outw.bb, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, (VkClearColorValue *)col, 1, &outw.bbtrans.subresourceRange); - vk.vkEndCommandBuffer(cmd); + vt->EndCommandBuffer(cmd); - vk.vkQueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vt->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); // VKTODOMED ideally all the commands from Bind to Flip would be recorded // into a single command buffer and we can just have several allocated // ring-buffer style - vk.vkQueueWaitIdle(q); + vt->QueueWaitIdle(q); } void VulkanReplay::ClearOutputWindowDepth(uint64_t id, float depth, uint8_t stencil) @@ -1283,11 +1284,11 @@ void VulkanReplay::FlipOutputWindow(uint64_t id) VkDevice dev = m_pDriver->GetDev(); VkCmdBuffer cmd = m_pDriver->GetCmd(); VkQueue q = m_pDriver->GetQ(); - const VulkanFunctions &vk = m_pDriver->m_Real; + const VkLayerDispatchTable *vt = device_dispatch_table(dev); 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 = vk.vkBeginCommandBuffer(cmd, &beginInfo); + VkResult vkr = vt->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); void *barrier[] = { @@ -1296,7 +1297,7 @@ void VulkanReplay::FlipOutputWindow(uint64_t id) }; outw.bbtrans.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL; - vk.vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, barrier); + vt->CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, barrier); outw.bbtrans.oldLayout = outw.bbtrans.newLayout; VkImageCopy cpy = { @@ -1307,27 +1308,27 @@ void VulkanReplay::FlipOutputWindow(uint64_t id) { outw.width, outw.height, 1 }, }; - vk.vkCmdCopyImage(cmd, outw.bb, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, outw.colimg[outw.curidx], VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, 1, &cpy); + vt->CmdCopyImage(cmd, outw.bb, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL, outw.colimg[outw.curidx], VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL, 1, &cpy); outw.bbtrans.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; outw.coltrans[outw.curidx].newLayout = VK_IMAGE_LAYOUT_PRESENT_SOURCE_WSI; - vk.vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 2, barrier); + vt->CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 2, barrier); outw.bbtrans.oldLayout = outw.bbtrans.newLayout; outw.coltrans[outw.curidx].oldLayout = outw.coltrans[outw.curidx].newLayout; - vk.vkEndCommandBuffer(cmd); + vt->EndCommandBuffer(cmd); - vk.vkQueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vt->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); VkPresentInfoWSI presentInfo = { VK_STRUCTURE_TYPE_QUEUE_PRESENT_INFO_WSI, NULL, 1, &outw.swap, &outw.curidx }; - vk.vkQueuePresentWSI(q, &presentInfo); + vt->QueuePresentWSI(q, &presentInfo); - vk.vkQueueWaitIdle(q); + vt->QueueWaitIdle(q); - vk.vkDeviceWaitIdle(dev); + vt->DeviceWaitIdle(dev); } void VulkanReplay::DestroyOutputWindow(uint64_t id) @@ -1789,8 +1790,6 @@ void VulkanReplay::SetProxyBufferData(ResourceId bufid, byte *data, size_t dataS RDCUNIMPLEMENTED("SetProxyTextureData"); } -const VulkanFunctions &GetRealVKFunctions(); - // in vk_replay_platform.cpp bool LoadVulkanLibrary(); @@ -1816,7 +1815,7 @@ ReplayCreateStatus Vulkan_CreateReplayDevice(const char *logfile, IReplayDriver return eReplayCreate_APIIncompatibleVersion; } - WrappedVulkan *vk = new WrappedVulkan(GetRealVKFunctions(), logfile); + WrappedVulkan *vk = new WrappedVulkan(logfile); vk->Initialise(initParams); RDCLOG("Created device."); diff --git a/renderdoc/driver/vulkan/vk_replay.h b/renderdoc/driver/vulkan/vk_replay.h index 44337e056..311d6ab47 100644 --- a/renderdoc/driver/vulkan/vk_replay.h +++ b/renderdoc/driver/vulkan/vk_replay.h @@ -25,6 +25,7 @@ #pragma once #include "vk_common.h" +#include "vk_layer.h" #include "api/replay/renderdoc_replay.h" #include "replay/replay_driver.h" #include "core/core.h" @@ -50,7 +51,6 @@ using std::map; #define VULKANNOTIMP(...) RDCDEBUG("Vulkan not implemented - " __VA_ARGS__) class WrappedVulkan; -struct VulkanFunctions; class VulkanReplay : public IReplayDriver { @@ -215,10 +215,10 @@ class VulkanReplay : public IReplayDriver { UBO() : buf(VK_NULL_HANDLE), mem(VK_NULL_HANDLE), view(VK_NULL_HANDLE) {} void Create(WrappedVulkan *driver, VkDevice dev, VkDeviceSize size); - void Destroy(const VulkanFunctions &vk, VkDevice dev); + void Destroy(const VkLayerDispatchTable *vk, VkDevice dev); - void *Map(const VulkanFunctions &vk, VkDevice dev, VkDeviceSize offset = 0, VkDeviceSize size = 0); - void Unmap(const VulkanFunctions &vk, VkDevice dev); + void *Map(const VkLayerDispatchTable *vk, VkDevice dev, VkDeviceSize offset = 0, VkDeviceSize size = 0); + void Unmap(const VkLayerDispatchTable *vk, VkDevice dev); VkBuffer buf; VkDeviceMemory mem; diff --git a/renderdoc/os/linux/linux_process.cpp b/renderdoc/os/linux/linux_process.cpp index 82ad3138a..6649acf19 100644 --- a/renderdoc/os/linux/linux_process.cpp +++ b/renderdoc/os/linux/linux_process.cpp @@ -218,15 +218,21 @@ uint32_t Process::LaunchAndInjectIntoProcess(const char *app, const char *workin int nenv = 0; for(; environ[nenv]; nenv++); - const int numEnvAdd = 4; + const int numEnvAdd = 7; // LD_LIBRARY_PATH // LD_PRELOAD + // VK_LAYER_DIRS + // VK_DEVICE_LAYERS + // VK_INSTANCE_LAYERS // RENDERDOC_CAPTUREOPTS // RENDERDOC_LOGFILE // might find these already existant in the environment bool libpath = false; bool preload = false; + bool layerdirs = false; + bool devicelayers = false; + bool instancelayers = false; nenv += 1+numEnvAdd; // account for terminating NULL we need to replicate, and up to N additional environment varibales @@ -262,6 +268,29 @@ uint32_t Process::LaunchAndInjectIntoProcess(const char *app, const char *workin memcpy(envp[i], environ[srci], len); strcat(envp[i], ":librenderdoc.so"); } + else if(!strncmp(environ[srci], "VK_LAYER_DIRS=", sizeof("VK_LAYER_DIRS=")-1)) + { + layerdirs = true; + envp[i] = new char[len+1+localpath.length()+30]; + memcpy(envp[i], environ[srci], len); + strcat(envp[i], ":"); + strcat(envp[i], localpath.c_str()); + strcat(envp[i], "/../../renderdoc/driver/vulkan"); + } + else if(!strncmp(environ[srci], "VK_DEVICE_LAYERS=", sizeof("VK_DEVICE_LAYERS=")-1)) + { + devicelayers = true; + envp[i] = new char[len+sizeof(":Renderdoc")]; + memcpy(envp[i], environ[srci], len); + strcat(envp[i], ":Renderdoc"); + } + else if(!strncmp(environ[srci], "VK_INSTANCE_LAYERS=", sizeof("VK_INSTANCE_LAYERS=")-1)) + { + instancelayers = true; + envp[i] = new char[len+sizeof(":Renderdoc")]; + memcpy(envp[i], environ[srci], len); + strcat(envp[i], ":Renderdoc"); + } else if(!strncmp(environ[srci], "RENDERDOC_", sizeof("RENDERDOC_")-1)) { // skip this variable entirely @@ -295,6 +324,33 @@ uint32_t Process::LaunchAndInjectIntoProcess(const char *app, const char *workin envp[i] = NULL; } + if(!layerdirs) + { + string e = StringFormat::Fmt("VK_LAYER_DIRS=%s/../../renderdoc/driver/vulkan", localpath.c_str()); + envp[i] = new char[e.length()+1]; + memcpy(envp[i], e.c_str(), e.length()+1); + i++; + envp[i] = NULL; + } + + if(!devicelayers) + { + string e = StringFormat::Fmt("VK_DEVICE_LAYERS=Renderdoc"); + envp[i] = new char[e.length()+1]; + memcpy(envp[i], e.c_str(), e.length()+1); + i++; + envp[i] = NULL; + } + + if(!instancelayers) + { + string e = StringFormat::Fmt("VK_INSTANCE_LAYERS=Renderdoc"); + envp[i] = new char[e.length()+1]; + memcpy(envp[i], e.c_str(), e.length()+1); + i++; + envp[i] = NULL; + } + if(opts) { string optstr;