diff --git a/SConscript b/SConscript index 2d690de..8fe4753 100644 --- a/SConscript +++ b/SConscript @@ -171,6 +171,7 @@ def generate_source(target, source, env): return None pygen_builder = Builder(action = generate_source) +env.Append(CCFLAGS = '-Wall -Wextra -Werror -pedantic -std=c++20') env.Append(BUILDERS = {'PyGen': pygen_builder}) env.Append(CPPPATH = ['include']) @@ -178,6 +179,7 @@ source_files = Split(""" source/data_pool.cpp source/dispatch_table.cpp source/functions.cpp + source/function_ids.cpp source/layer.cpp source/record_list.cpp source/variant_pool.cpp @@ -185,6 +187,7 @@ source_files = Split(""" # env.PyGen('source/functions.hpp', 'generators/functions.hpp.py') env.PyGen('include/vk_function_ids.h', 'generators/vk_function_ids.h.py') +env.PyGen('source/function_ids.cpp', 'generators/function_ids.cpp.py') env.PyGen('source/functions.cpp', 'generators/functions.cpp.py') env.PyGen('source/variant_wrap.hpp', 'generators/variant_wrap.hpp.py') env.SharedLibrary( diff --git a/generators/function_ids.cpp.py b/generators/function_ids.cpp.py new file mode 100644 index 0000000..d7e84a4 --- /dev/null +++ b/generators/function_ids.cpp.py @@ -0,0 +1,53 @@ +import binascii +from common import func_name_to_caps, write_epilogue, write_preamble, FIRST_PARAM_BLACKLIST, FUNC_BLACKLIST + +HEADER_GUARD = 'VK_CAPTURE_FUNCTION_IDS_H_INCLUDED' +_dbg_hashes = set() + + +def write_funccase(f, cmd): + if 'alias' in cmd or cmd["name"] in FUNC_BLACKLIST: + return + if len(cmd['params']) > 0 and cmd['params'][0]['type'] in FIRST_PARAM_BLACKLIST: + return + funchash = binascii.crc32(cmd['name'].encode('utf8')) + f.write(f""" + case VK_FUNCTION_{func_name_to_caps(cmd['name'])}_MWN: + *pName = "{cmd['name']}"; + return VK_SUCCESS;""") + + # just to make sure there are no hash collisions, we wouldn't want that + global _dbg_hashes + assert(funchash not in _dbg_hashes) + _dbg_hashes.add(funchash) + +def generate(targets): + assert(len(targets) == 1) + with open(targets[0], 'w') as f: + write_preamble(f, includes = ['', '"vk_function_ids.h"']) + commands = list(vulkan_hpp['commands'].values()) + commands.sort(key=lambda cmd: cmd['platform']) + plat = '' + f.write(""" +VkResult vkGetFunctionNameMWN(VkDevice /* device */, VkFunctionMWN function, const char** pName) +{ + switch(function) + {""") + for cmd in commands: + if plat != cmd['platform']: + if plat != '': + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + plat = cmd['platform'] + f.write(f""" +#if defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + write_funccase(f, cmd) + # finish the final platform + f.write(f"""#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + f.write(""" + default: + return VK_ERROR_UNKNOWN; + } +} +""") + write_epilogue(f) diff --git a/include/vk_capture.h b/include/vk_capture.h index 7a47463..4fa0bb6 100644 --- a/include/vk_capture.h +++ b/include/vk_capture.h @@ -82,6 +82,7 @@ typedef struct VkVariantMWN { int64_t intValue; float floatValue; double doubleValue; + const char* stringValue; const void* voidPointerValue; VkVariantMWN* pointerValue; VkVariantArrayValueMWN arrayValue; @@ -99,11 +100,20 @@ typedef struct VkRecordListItemMWN VkVariantMWN* pParameterValues; } VkRecordListItemMWN; +typedef struct VkRecordListItemFormatMWN +{ + int todo; +} VkRecordListItemFormatMWN; + typedef VkResult (VKAPI_PTR *PFN_vkAllocateRecordListMWN)(VkDevice device, const VkRecordListAllocateInfoMWN* pCreateInfo, VkRecordListMWN* pRecordList); typedef void (VKAPI_PTR *PFN_vkFreeRecordListMWN)(VkDevice device, VkRecordListMWN recordList); typedef VkResult (VKAPI_PTR *PFN_vkBeginRecordingMWN)(VkDevice device, const VkRecordInfoMWN* pRecordInfo); typedef void (VKAPI_PTR *PFN_vkEndRecordingMWN)(VkDevice device); typedef VkResult (VKAPI_PTR *PFN_vkGetRecordListItemsMWN)(VkDevice device, VkRecordListMWN recordList, uint32_t* pItemCount, VkRecordListItemMWN** pItems); +typedef VkResult (VKAPI_PTR *PFN_vkResetRecordListMWN)(VkDevice device, VkRecordListMWN recordList); + +// utility +typedef VkResult (VKAPI_PTR *PFN_vkGetFunctionNameMWN)(VkDevice device, VkFunctionMWN function, const char** pName); #if defined(__cplusplus) } // extern "C" diff --git a/site_scons/pygen.py b/site_scons/pygen.py new file mode 100644 index 0000000..a3b8c4f --- /dev/null +++ b/site_scons/pygen.py @@ -0,0 +1,20 @@ + +def generate_source(target, source, env): + import os + import sys + from importlib.util import module_from_spec, spec_from_file_location + + # allow the module to import from its current folder + sys.path.append(os.path.dirname(source[0].abspath)) + python_spec = spec_from_file_location('source', source[0].abspath) + python_mod = module_from_spec(python_spec) + python_spec.loader.exec_module(python_mod) + python_mod.generate(targets = [t.abspath for t in target]) + + # restore path + sys.path = sys.path[:-1] + + return None + +pygen_builder = Builder(action = generate_source) +# env.Append(BUILDERS = {'PyGen': pygen_builder}) diff --git a/source/data_pool.cpp b/source/data_pool.cpp index bc4a20a..54eb3e2 100644 --- a/source/data_pool.cpp +++ b/source/data_pool.cpp @@ -40,14 +40,16 @@ void* DataPool::allocate(std::size_t bytes, std::size_t alignment) } const std::size_t remainingOnPage = PAGE_SIZE - (offset % PAGE_SIZE); + const std::size_t page = offset / PAGE_SIZE; + const std::size_t localOffset = offset % PAGE_SIZE; if (remainingOnPage == PAGE_SIZE || remainingOnPage < bytes) { // next page - pages.push_back(std::make_unique()); + if (page + 1 >= pages.size()) { + pages.push_back(std::make_unique()); + } offset = PAGE_SIZE * (pages.size() - 1); } - const std::size_t page = offset / PAGE_SIZE; - const std::size_t localOffset = offset % PAGE_SIZE; std::uint8_t* result = &(*pages[page])[localOffset]; offset += bytes; assert(reinterpret_cast(result) % alignment == 0); diff --git a/source/function_ids.cpp b/source/function_ids.cpp new file mode 100644 index 0000000..6a9526b --- /dev/null +++ b/source/function_ids.cpp @@ -0,0 +1,1208 @@ + +// This file has been automatically generated. Do NOT edit edit manually, all your changes will be lost when it is regenerated. + +#include +#include "vk_function_ids.h" +namespace vk_capture +{ + +VkResult vkGetFunctionNameMWN(VkDevice /* device */, VkFunctionMWN function, const char** pName) +{ + switch(function) + { + case VK_FUNCTION_GET_DEVICE_QUEUE_MWN: + *pName = "vkGetDeviceQueue"; + return VK_SUCCESS; + case VK_FUNCTION_QUEUE_SUBMIT_MWN: + *pName = "vkQueueSubmit"; + return VK_SUCCESS; + case VK_FUNCTION_QUEUE_WAIT_IDLE_MWN: + *pName = "vkQueueWaitIdle"; + return VK_SUCCESS; + case VK_FUNCTION_DEVICE_WAIT_IDLE_MWN: + *pName = "vkDeviceWaitIdle"; + return VK_SUCCESS; + case VK_FUNCTION_ALLOCATE_MEMORY_MWN: + *pName = "vkAllocateMemory"; + return VK_SUCCESS; + case VK_FUNCTION_FREE_MEMORY_MWN: + *pName = "vkFreeMemory"; + return VK_SUCCESS; + case VK_FUNCTION_MAP_MEMORY_MWN: + *pName = "vkMapMemory"; + return VK_SUCCESS; + case VK_FUNCTION_UNMAP_MEMORY_MWN: + *pName = "vkUnmapMemory"; + return VK_SUCCESS; + case VK_FUNCTION_FLUSH_MAPPED_MEMORY_RANGES_MWN: + *pName = "vkFlushMappedMemoryRanges"; + return VK_SUCCESS; + case VK_FUNCTION_INVALIDATE_MAPPED_MEMORY_RANGES_MWN: + *pName = "vkInvalidateMappedMemoryRanges"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_MEMORY_COMMITMENT_MWN: + *pName = "vkGetDeviceMemoryCommitment"; + return VK_SUCCESS; + case VK_FUNCTION_GET_BUFFER_MEMORY_REQUIREMENTS_MWN: + *pName = "vkGetBufferMemoryRequirements"; + return VK_SUCCESS; + case VK_FUNCTION_BIND_BUFFER_MEMORY_MWN: + *pName = "vkBindBufferMemory"; + return VK_SUCCESS; + case VK_FUNCTION_GET_IMAGE_MEMORY_REQUIREMENTS_MWN: + *pName = "vkGetImageMemoryRequirements"; + return VK_SUCCESS; + case VK_FUNCTION_BIND_IMAGE_MEMORY_MWN: + *pName = "vkBindImageMemory"; + return VK_SUCCESS; + case VK_FUNCTION_GET_IMAGE_SPARSE_MEMORY_REQUIREMENTS_MWN: + *pName = "vkGetImageSparseMemoryRequirements"; + return VK_SUCCESS; + case VK_FUNCTION_QUEUE_BIND_SPARSE_MWN: + *pName = "vkQueueBindSparse"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_FENCE_MWN: + *pName = "vkCreateFence"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_FENCE_MWN: + *pName = "vkDestroyFence"; + return VK_SUCCESS; + case VK_FUNCTION_RESET_FENCES_MWN: + *pName = "vkResetFences"; + return VK_SUCCESS; + case VK_FUNCTION_GET_FENCE_STATUS_MWN: + *pName = "vkGetFenceStatus"; + return VK_SUCCESS; + case VK_FUNCTION_WAIT_FOR_FENCES_MWN: + *pName = "vkWaitForFences"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_SEMAPHORE_MWN: + *pName = "vkCreateSemaphore"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_SEMAPHORE_MWN: + *pName = "vkDestroySemaphore"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_EVENT_MWN: + *pName = "vkCreateEvent"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_EVENT_MWN: + *pName = "vkDestroyEvent"; + return VK_SUCCESS; + case VK_FUNCTION_GET_EVENT_STATUS_MWN: + *pName = "vkGetEventStatus"; + return VK_SUCCESS; + case VK_FUNCTION_SET_EVENT_MWN: + *pName = "vkSetEvent"; + return VK_SUCCESS; + case VK_FUNCTION_RESET_EVENT_MWN: + *pName = "vkResetEvent"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_QUERY_POOL_MWN: + *pName = "vkCreateQueryPool"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_QUERY_POOL_MWN: + *pName = "vkDestroyQueryPool"; + return VK_SUCCESS; + case VK_FUNCTION_GET_QUERY_POOL_RESULTS_MWN: + *pName = "vkGetQueryPoolResults"; + return VK_SUCCESS; + case VK_FUNCTION_RESET_QUERY_POOL_MWN: + *pName = "vkResetQueryPool"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_BUFFER_MWN: + *pName = "vkCreateBuffer"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_BUFFER_MWN: + *pName = "vkDestroyBuffer"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_BUFFER_VIEW_MWN: + *pName = "vkCreateBufferView"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_BUFFER_VIEW_MWN: + *pName = "vkDestroyBufferView"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_IMAGE_MWN: + *pName = "vkCreateImage"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_IMAGE_MWN: + *pName = "vkDestroyImage"; + return VK_SUCCESS; + case VK_FUNCTION_GET_IMAGE_SUBRESOURCE_LAYOUT_MWN: + *pName = "vkGetImageSubresourceLayout"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_IMAGE_VIEW_MWN: + *pName = "vkCreateImageView"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_IMAGE_VIEW_MWN: + *pName = "vkDestroyImageView"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_SHADER_MODULE_MWN: + *pName = "vkCreateShaderModule"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_SHADER_MODULE_MWN: + *pName = "vkDestroyShaderModule"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_PIPELINE_CACHE_MWN: + *pName = "vkCreatePipelineCache"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_PIPELINE_CACHE_MWN: + *pName = "vkDestroyPipelineCache"; + return VK_SUCCESS; + case VK_FUNCTION_GET_PIPELINE_CACHE_DATA_MWN: + *pName = "vkGetPipelineCacheData"; + return VK_SUCCESS; + case VK_FUNCTION_MERGE_PIPELINE_CACHES_MWN: + *pName = "vkMergePipelineCaches"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_GRAPHICS_PIPELINES_MWN: + *pName = "vkCreateGraphicsPipelines"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_COMPUTE_PIPELINES_MWN: + *pName = "vkCreateComputePipelines"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_SUBPASS_SHADING_MAX_WORKGROUP_SIZE_HUAWEI_MWN: + *pName = "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_PIPELINE_MWN: + *pName = "vkDestroyPipeline"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_PIPELINE_LAYOUT_MWN: + *pName = "vkCreatePipelineLayout"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_PIPELINE_LAYOUT_MWN: + *pName = "vkDestroyPipelineLayout"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_SAMPLER_MWN: + *pName = "vkCreateSampler"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_SAMPLER_MWN: + *pName = "vkDestroySampler"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_DESCRIPTOR_SET_LAYOUT_MWN: + *pName = "vkCreateDescriptorSetLayout"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_DESCRIPTOR_SET_LAYOUT_MWN: + *pName = "vkDestroyDescriptorSetLayout"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_DESCRIPTOR_POOL_MWN: + *pName = "vkCreateDescriptorPool"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_DESCRIPTOR_POOL_MWN: + *pName = "vkDestroyDescriptorPool"; + return VK_SUCCESS; + case VK_FUNCTION_RESET_DESCRIPTOR_POOL_MWN: + *pName = "vkResetDescriptorPool"; + return VK_SUCCESS; + case VK_FUNCTION_ALLOCATE_DESCRIPTOR_SETS_MWN: + *pName = "vkAllocateDescriptorSets"; + return VK_SUCCESS; + case VK_FUNCTION_FREE_DESCRIPTOR_SETS_MWN: + *pName = "vkFreeDescriptorSets"; + return VK_SUCCESS; + case VK_FUNCTION_UPDATE_DESCRIPTOR_SETS_MWN: + *pName = "vkUpdateDescriptorSets"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_FRAMEBUFFER_MWN: + *pName = "vkCreateFramebuffer"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_FRAMEBUFFER_MWN: + *pName = "vkDestroyFramebuffer"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_RENDER_PASS_MWN: + *pName = "vkCreateRenderPass"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_RENDER_PASS_MWN: + *pName = "vkDestroyRenderPass"; + return VK_SUCCESS; + case VK_FUNCTION_GET_RENDER_AREA_GRANULARITY_MWN: + *pName = "vkGetRenderAreaGranularity"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_COMMAND_POOL_MWN: + *pName = "vkCreateCommandPool"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_COMMAND_POOL_MWN: + *pName = "vkDestroyCommandPool"; + return VK_SUCCESS; + case VK_FUNCTION_RESET_COMMAND_POOL_MWN: + *pName = "vkResetCommandPool"; + return VK_SUCCESS; + case VK_FUNCTION_ALLOCATE_COMMAND_BUFFERS_MWN: + *pName = "vkAllocateCommandBuffers"; + return VK_SUCCESS; + case VK_FUNCTION_FREE_COMMAND_BUFFERS_MWN: + *pName = "vkFreeCommandBuffers"; + return VK_SUCCESS; + case VK_FUNCTION_BEGIN_COMMAND_BUFFER_MWN: + *pName = "vkBeginCommandBuffer"; + return VK_SUCCESS; + case VK_FUNCTION_END_COMMAND_BUFFER_MWN: + *pName = "vkEndCommandBuffer"; + return VK_SUCCESS; + case VK_FUNCTION_RESET_COMMAND_BUFFER_MWN: + *pName = "vkResetCommandBuffer"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BIND_PIPELINE_MWN: + *pName = "vkCmdBindPipeline"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_VIEWPORT_MWN: + *pName = "vkCmdSetViewport"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_SCISSOR_MWN: + *pName = "vkCmdSetScissor"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_LINE_WIDTH_MWN: + *pName = "vkCmdSetLineWidth"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_DEPTH_BIAS_MWN: + *pName = "vkCmdSetDepthBias"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_BLEND_CONSTANTS_MWN: + *pName = "vkCmdSetBlendConstants"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_DEPTH_BOUNDS_MWN: + *pName = "vkCmdSetDepthBounds"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_STENCIL_COMPARE_MASK_MWN: + *pName = "vkCmdSetStencilCompareMask"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_STENCIL_WRITE_MASK_MWN: + *pName = "vkCmdSetStencilWriteMask"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_STENCIL_REFERENCE_MWN: + *pName = "vkCmdSetStencilReference"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BIND_DESCRIPTOR_SETS_MWN: + *pName = "vkCmdBindDescriptorSets"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BIND_INDEX_BUFFER_MWN: + *pName = "vkCmdBindIndexBuffer"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BIND_VERTEX_BUFFERS_MWN: + *pName = "vkCmdBindVertexBuffers"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_MWN: + *pName = "vkCmdDraw"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_INDEXED_MWN: + *pName = "vkCmdDrawIndexed"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_MULTI_EXT_MWN: + *pName = "vkCmdDrawMultiEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_MULTI_INDEXED_EXT_MWN: + *pName = "vkCmdDrawMultiIndexedEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_INDIRECT_MWN: + *pName = "vkCmdDrawIndirect"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_INDEXED_INDIRECT_MWN: + *pName = "vkCmdDrawIndexedIndirect"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DISPATCH_MWN: + *pName = "vkCmdDispatch"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DISPATCH_INDIRECT_MWN: + *pName = "vkCmdDispatchIndirect"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SUBPASS_SHADING_HUAWEI_MWN: + *pName = "vkCmdSubpassShadingHUAWEI"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_BUFFER_MWN: + *pName = "vkCmdCopyBuffer"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_IMAGE_MWN: + *pName = "vkCmdCopyImage"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BLIT_IMAGE_MWN: + *pName = "vkCmdBlitImage"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_BUFFER_TO_IMAGE_MWN: + *pName = "vkCmdCopyBufferToImage"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_IMAGE_TO_BUFFER_MWN: + *pName = "vkCmdCopyImageToBuffer"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_UPDATE_BUFFER_MWN: + *pName = "vkCmdUpdateBuffer"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_FILL_BUFFER_MWN: + *pName = "vkCmdFillBuffer"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_CLEAR_COLOR_IMAGE_MWN: + *pName = "vkCmdClearColorImage"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_CLEAR_DEPTH_STENCIL_IMAGE_MWN: + *pName = "vkCmdClearDepthStencilImage"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_CLEAR_ATTACHMENTS_MWN: + *pName = "vkCmdClearAttachments"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_RESOLVE_IMAGE_MWN: + *pName = "vkCmdResolveImage"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_EVENT_MWN: + *pName = "vkCmdSetEvent"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_RESET_EVENT_MWN: + *pName = "vkCmdResetEvent"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_WAIT_EVENTS_MWN: + *pName = "vkCmdWaitEvents"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_PIPELINE_BARRIER_MWN: + *pName = "vkCmdPipelineBarrier"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BEGIN_QUERY_MWN: + *pName = "vkCmdBeginQuery"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_END_QUERY_MWN: + *pName = "vkCmdEndQuery"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BEGIN_CONDITIONAL_RENDERING_EXT_MWN: + *pName = "vkCmdBeginConditionalRenderingEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_END_CONDITIONAL_RENDERING_EXT_MWN: + *pName = "vkCmdEndConditionalRenderingEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_RESET_QUERY_POOL_MWN: + *pName = "vkCmdResetQueryPool"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_WRITE_TIMESTAMP_MWN: + *pName = "vkCmdWriteTimestamp"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_QUERY_POOL_RESULTS_MWN: + *pName = "vkCmdCopyQueryPoolResults"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_PUSH_CONSTANTS_MWN: + *pName = "vkCmdPushConstants"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BEGIN_RENDER_PASS_MWN: + *pName = "vkCmdBeginRenderPass"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_NEXT_SUBPASS_MWN: + *pName = "vkCmdNextSubpass"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_END_RENDER_PASS_MWN: + *pName = "vkCmdEndRenderPass"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_EXECUTE_COMMANDS_MWN: + *pName = "vkCmdExecuteCommands"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_SHARED_SWAPCHAINS_KHR_MWN: + *pName = "vkCreateSharedSwapchainsKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_SWAPCHAIN_KHR_MWN: + *pName = "vkCreateSwapchainKHR"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_SWAPCHAIN_KHR_MWN: + *pName = "vkDestroySwapchainKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_SWAPCHAIN_IMAGES_KHR_MWN: + *pName = "vkGetSwapchainImagesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_ACQUIRE_NEXT_IMAGE_KHR_MWN: + *pName = "vkAcquireNextImageKHR"; + return VK_SUCCESS; + case VK_FUNCTION_QUEUE_PRESENT_KHR_MWN: + *pName = "vkQueuePresentKHR"; + return VK_SUCCESS; + case VK_FUNCTION_DEBUG_MARKER_SET_OBJECT_NAME_EXT_MWN: + *pName = "vkDebugMarkerSetObjectNameEXT"; + return VK_SUCCESS; + case VK_FUNCTION_DEBUG_MARKER_SET_OBJECT_TAG_EXT_MWN: + *pName = "vkDebugMarkerSetObjectTagEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DEBUG_MARKER_BEGIN_EXT_MWN: + *pName = "vkCmdDebugMarkerBeginEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DEBUG_MARKER_END_EXT_MWN: + *pName = "vkCmdDebugMarkerEndEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DEBUG_MARKER_INSERT_EXT_MWN: + *pName = "vkCmdDebugMarkerInsertEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_EXECUTE_GENERATED_COMMANDS_NV_MWN: + *pName = "vkCmdExecuteGeneratedCommandsNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_PREPROCESS_GENERATED_COMMANDS_NV_MWN: + *pName = "vkCmdPreprocessGeneratedCommandsNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BIND_PIPELINE_SHADER_GROUP_NV_MWN: + *pName = "vkCmdBindPipelineShaderGroupNV"; + return VK_SUCCESS; + case VK_FUNCTION_GET_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_NV_MWN: + *pName = "vkGetGeneratedCommandsMemoryRequirementsNV"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_INDIRECT_COMMANDS_LAYOUT_NV_MWN: + *pName = "vkCreateIndirectCommandsLayoutNV"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_INDIRECT_COMMANDS_LAYOUT_NV_MWN: + *pName = "vkDestroyIndirectCommandsLayoutNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_PUSH_DESCRIPTOR_SET_KHR_MWN: + *pName = "vkCmdPushDescriptorSetKHR"; + return VK_SUCCESS; + case VK_FUNCTION_TRIM_COMMAND_POOL_MWN: + *pName = "vkTrimCommandPool"; + return VK_SUCCESS; + case VK_FUNCTION_GET_MEMORY_FD_KHR_MWN: + *pName = "vkGetMemoryFdKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_MEMORY_FD_PROPERTIES_KHR_MWN: + *pName = "vkGetMemoryFdPropertiesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_MEMORY_REMOTE_ADDRESS_NV_MWN: + *pName = "vkGetMemoryRemoteAddressNV"; + return VK_SUCCESS; + case VK_FUNCTION_GET_SEMAPHORE_FD_KHR_MWN: + *pName = "vkGetSemaphoreFdKHR"; + return VK_SUCCESS; + case VK_FUNCTION_IMPORT_SEMAPHORE_FD_KHR_MWN: + *pName = "vkImportSemaphoreFdKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_FENCE_FD_KHR_MWN: + *pName = "vkGetFenceFdKHR"; + return VK_SUCCESS; + case VK_FUNCTION_IMPORT_FENCE_FD_KHR_MWN: + *pName = "vkImportFenceFdKHR"; + return VK_SUCCESS; + case VK_FUNCTION_DISPLAY_POWER_CONTROL_EXT_MWN: + *pName = "vkDisplayPowerControlEXT"; + return VK_SUCCESS; + case VK_FUNCTION_REGISTER_DEVICE_EVENT_EXT_MWN: + *pName = "vkRegisterDeviceEventEXT"; + return VK_SUCCESS; + case VK_FUNCTION_REGISTER_DISPLAY_EVENT_EXT_MWN: + *pName = "vkRegisterDisplayEventEXT"; + return VK_SUCCESS; + case VK_FUNCTION_GET_SWAPCHAIN_COUNTER_EXT_MWN: + *pName = "vkGetSwapchainCounterEXT"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_GROUP_PEER_MEMORY_FEATURES_MWN: + *pName = "vkGetDeviceGroupPeerMemoryFeatures"; + return VK_SUCCESS; + case VK_FUNCTION_BIND_BUFFER_MEMORY2_MWN: + *pName = "vkBindBufferMemory2"; + return VK_SUCCESS; + case VK_FUNCTION_BIND_IMAGE_MEMORY2_MWN: + *pName = "vkBindImageMemory2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_DEVICE_MASK_MWN: + *pName = "vkCmdSetDeviceMask"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR_MWN: + *pName = "vkGetDeviceGroupPresentCapabilitiesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_GROUP_SURFACE_PRESENT_MODES_KHR_MWN: + *pName = "vkGetDeviceGroupSurfacePresentModesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_ACQUIRE_NEXT_IMAGE2_KHR_MWN: + *pName = "vkAcquireNextImage2KHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DISPATCH_BASE_MWN: + *pName = "vkCmdDispatchBase"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_DESCRIPTOR_UPDATE_TEMPLATE_MWN: + *pName = "vkCreateDescriptorUpdateTemplate"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_DESCRIPTOR_UPDATE_TEMPLATE_MWN: + *pName = "vkDestroyDescriptorUpdateTemplate"; + return VK_SUCCESS; + case VK_FUNCTION_UPDATE_DESCRIPTOR_SET_WITH_TEMPLATE_MWN: + *pName = "vkUpdateDescriptorSetWithTemplate"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_KHR_MWN: + *pName = "vkCmdPushDescriptorSetWithTemplateKHR"; + return VK_SUCCESS; + case VK_FUNCTION_SET_HDR_METADATA_EXT_MWN: + *pName = "vkSetHdrMetadataEXT"; + return VK_SUCCESS; + case VK_FUNCTION_GET_SWAPCHAIN_STATUS_KHR_MWN: + *pName = "vkGetSwapchainStatusKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_REFRESH_CYCLE_DURATION_GOOGLE_MWN: + *pName = "vkGetRefreshCycleDurationGOOGLE"; + return VK_SUCCESS; + case VK_FUNCTION_GET_PAST_PRESENTATION_TIMING_GOOGLE_MWN: + *pName = "vkGetPastPresentationTimingGOOGLE"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_VIEWPORT_WSCALING_NV_MWN: + *pName = "vkCmdSetViewportWScalingNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_DISCARD_RECTANGLE_EXT_MWN: + *pName = "vkCmdSetDiscardRectangleEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_SAMPLE_LOCATIONS_EXT_MWN: + *pName = "vkCmdSetSampleLocationsEXT"; + return VK_SUCCESS; + case VK_FUNCTION_GET_BUFFER_MEMORY_REQUIREMENTS2_MWN: + *pName = "vkGetBufferMemoryRequirements2"; + return VK_SUCCESS; + case VK_FUNCTION_GET_IMAGE_MEMORY_REQUIREMENTS2_MWN: + *pName = "vkGetImageMemoryRequirements2"; + return VK_SUCCESS; + case VK_FUNCTION_GET_IMAGE_SPARSE_MEMORY_REQUIREMENTS2_MWN: + *pName = "vkGetImageSparseMemoryRequirements2"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_BUFFER_MEMORY_REQUIREMENTS_MWN: + *pName = "vkGetDeviceBufferMemoryRequirements"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_IMAGE_MEMORY_REQUIREMENTS_MWN: + *pName = "vkGetDeviceImageMemoryRequirements"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_MWN: + *pName = "vkGetDeviceImageSparseMemoryRequirements"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_SAMPLER_YCBCR_CONVERSION_MWN: + *pName = "vkCreateSamplerYcbcrConversion"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_SAMPLER_YCBCR_CONVERSION_MWN: + *pName = "vkDestroySamplerYcbcrConversion"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_QUEUE2_MWN: + *pName = "vkGetDeviceQueue2"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_VALIDATION_CACHE_EXT_MWN: + *pName = "vkCreateValidationCacheEXT"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_VALIDATION_CACHE_EXT_MWN: + *pName = "vkDestroyValidationCacheEXT"; + return VK_SUCCESS; + case VK_FUNCTION_GET_VALIDATION_CACHE_DATA_EXT_MWN: + *pName = "vkGetValidationCacheDataEXT"; + return VK_SUCCESS; + case VK_FUNCTION_MERGE_VALIDATION_CACHES_EXT_MWN: + *pName = "vkMergeValidationCachesEXT"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DESCRIPTOR_SET_LAYOUT_SUPPORT_MWN: + *pName = "vkGetDescriptorSetLayoutSupport"; + return VK_SUCCESS; + case VK_FUNCTION_GET_SHADER_INFO_AMD_MWN: + *pName = "vkGetShaderInfoAMD"; + return VK_SUCCESS; + case VK_FUNCTION_SET_LOCAL_DIMMING_AMD_MWN: + *pName = "vkSetLocalDimmingAMD"; + return VK_SUCCESS; + case VK_FUNCTION_GET_CALIBRATED_TIMESTAMPS_EXT_MWN: + *pName = "vkGetCalibratedTimestampsEXT"; + return VK_SUCCESS; + case VK_FUNCTION_SET_DEBUG_UTILS_OBJECT_NAME_EXT_MWN: + *pName = "vkSetDebugUtilsObjectNameEXT"; + return VK_SUCCESS; + case VK_FUNCTION_SET_DEBUG_UTILS_OBJECT_TAG_EXT_MWN: + *pName = "vkSetDebugUtilsObjectTagEXT"; + return VK_SUCCESS; + case VK_FUNCTION_QUEUE_BEGIN_DEBUG_UTILS_LABEL_EXT_MWN: + *pName = "vkQueueBeginDebugUtilsLabelEXT"; + return VK_SUCCESS; + case VK_FUNCTION_QUEUE_END_DEBUG_UTILS_LABEL_EXT_MWN: + *pName = "vkQueueEndDebugUtilsLabelEXT"; + return VK_SUCCESS; + case VK_FUNCTION_QUEUE_INSERT_DEBUG_UTILS_LABEL_EXT_MWN: + *pName = "vkQueueInsertDebugUtilsLabelEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BEGIN_DEBUG_UTILS_LABEL_EXT_MWN: + *pName = "vkCmdBeginDebugUtilsLabelEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_END_DEBUG_UTILS_LABEL_EXT_MWN: + *pName = "vkCmdEndDebugUtilsLabelEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_INSERT_DEBUG_UTILS_LABEL_EXT_MWN: + *pName = "vkCmdInsertDebugUtilsLabelEXT"; + return VK_SUCCESS; + case VK_FUNCTION_GET_MEMORY_HOST_POINTER_PROPERTIES_EXT_MWN: + *pName = "vkGetMemoryHostPointerPropertiesEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_WRITE_BUFFER_MARKER_AMD_MWN: + *pName = "vkCmdWriteBufferMarkerAMD"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_RENDER_PASS2_MWN: + *pName = "vkCreateRenderPass2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BEGIN_RENDER_PASS2_MWN: + *pName = "vkCmdBeginRenderPass2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_NEXT_SUBPASS2_MWN: + *pName = "vkCmdNextSubpass2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_END_RENDER_PASS2_MWN: + *pName = "vkCmdEndRenderPass2"; + return VK_SUCCESS; + case VK_FUNCTION_GET_SEMAPHORE_COUNTER_VALUE_MWN: + *pName = "vkGetSemaphoreCounterValue"; + return VK_SUCCESS; + case VK_FUNCTION_WAIT_SEMAPHORES_MWN: + *pName = "vkWaitSemaphores"; + return VK_SUCCESS; + case VK_FUNCTION_SIGNAL_SEMAPHORE_MWN: + *pName = "vkSignalSemaphore"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_INDIRECT_COUNT_MWN: + *pName = "vkCmdDrawIndirectCount"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_INDEXED_INDIRECT_COUNT_MWN: + *pName = "vkCmdDrawIndexedIndirectCount"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_CHECKPOINT_NV_MWN: + *pName = "vkCmdSetCheckpointNV"; + return VK_SUCCESS; + case VK_FUNCTION_GET_QUEUE_CHECKPOINT_DATA_NV_MWN: + *pName = "vkGetQueueCheckpointDataNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BIND_TRANSFORM_FEEDBACK_BUFFERS_EXT_MWN: + *pName = "vkCmdBindTransformFeedbackBuffersEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BEGIN_TRANSFORM_FEEDBACK_EXT_MWN: + *pName = "vkCmdBeginTransformFeedbackEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_END_TRANSFORM_FEEDBACK_EXT_MWN: + *pName = "vkCmdEndTransformFeedbackEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BEGIN_QUERY_INDEXED_EXT_MWN: + *pName = "vkCmdBeginQueryIndexedEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_END_QUERY_INDEXED_EXT_MWN: + *pName = "vkCmdEndQueryIndexedEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_INDIRECT_BYTE_COUNT_EXT_MWN: + *pName = "vkCmdDrawIndirectByteCountEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_EXCLUSIVE_SCISSOR_NV_MWN: + *pName = "vkCmdSetExclusiveScissorNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BIND_SHADING_RATE_IMAGE_NV_MWN: + *pName = "vkCmdBindShadingRateImageNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_VIEWPORT_SHADING_RATE_PALETTE_NV_MWN: + *pName = "vkCmdSetViewportShadingRatePaletteNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_COARSE_SAMPLE_ORDER_NV_MWN: + *pName = "vkCmdSetCoarseSampleOrderNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_MESH_TASKS_NV_MWN: + *pName = "vkCmdDrawMeshTasksNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_MESH_TASKS_INDIRECT_NV_MWN: + *pName = "vkCmdDrawMeshTasksIndirectNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DRAW_MESH_TASKS_INDIRECT_COUNT_NV_MWN: + *pName = "vkCmdDrawMeshTasksIndirectCountNV"; + return VK_SUCCESS; + case VK_FUNCTION_COMPILE_DEFERRED_NV_MWN: + *pName = "vkCompileDeferredNV"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_ACCELERATION_STRUCTURE_NV_MWN: + *pName = "vkCreateAccelerationStructureNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BIND_INVOCATION_MASK_HUAWEI_MWN: + *pName = "vkCmdBindInvocationMaskHUAWEI"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_ACCELERATION_STRUCTURE_KHR_MWN: + *pName = "vkDestroyAccelerationStructureKHR"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_ACCELERATION_STRUCTURE_NV_MWN: + *pName = "vkDestroyAccelerationStructureNV"; + return VK_SUCCESS; + case VK_FUNCTION_GET_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_NV_MWN: + *pName = "vkGetAccelerationStructureMemoryRequirementsNV"; + return VK_SUCCESS; + case VK_FUNCTION_BIND_ACCELERATION_STRUCTURE_MEMORY_NV_MWN: + *pName = "vkBindAccelerationStructureMemoryNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_NV_MWN: + *pName = "vkCmdCopyAccelerationStructureNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_KHR_MWN: + *pName = "vkCmdCopyAccelerationStructureKHR"; + return VK_SUCCESS; + case VK_FUNCTION_COPY_ACCELERATION_STRUCTURE_KHR_MWN: + *pName = "vkCopyAccelerationStructureKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_KHR_MWN: + *pName = "vkCmdCopyAccelerationStructureToMemoryKHR"; + return VK_SUCCESS; + case VK_FUNCTION_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_KHR_MWN: + *pName = "vkCopyAccelerationStructureToMemoryKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_KHR_MWN: + *pName = "vkCmdCopyMemoryToAccelerationStructureKHR"; + return VK_SUCCESS; + case VK_FUNCTION_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_KHR_MWN: + *pName = "vkCopyMemoryToAccelerationStructureKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_KHR_MWN: + *pName = "vkCmdWriteAccelerationStructuresPropertiesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_NV_MWN: + *pName = "vkCmdWriteAccelerationStructuresPropertiesNV"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURE_NV_MWN: + *pName = "vkCmdBuildAccelerationStructureNV"; + return VK_SUCCESS; + case VK_FUNCTION_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_KHR_MWN: + *pName = "vkWriteAccelerationStructuresPropertiesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_TRACE_RAYS_KHR_MWN: + *pName = "vkCmdTraceRaysKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_TRACE_RAYS_NV_MWN: + *pName = "vkCmdTraceRaysNV"; + return VK_SUCCESS; + case VK_FUNCTION_GET_RAY_TRACING_SHADER_GROUP_HANDLES_KHR_MWN: + *pName = "vkGetRayTracingShaderGroupHandlesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_RAY_TRACING_CAPTURE_REPLAY_SHADER_GROUP_HANDLES_KHR_MWN: + *pName = "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_ACCELERATION_STRUCTURE_HANDLE_NV_MWN: + *pName = "vkGetAccelerationStructureHandleNV"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_RAY_TRACING_PIPELINES_NV_MWN: + *pName = "vkCreateRayTracingPipelinesNV"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_RAY_TRACING_PIPELINES_KHR_MWN: + *pName = "vkCreateRayTracingPipelinesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_TRACE_RAYS_INDIRECT_KHR_MWN: + *pName = "vkCmdTraceRaysIndirectKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_TRACE_RAYS_INDIRECT2_KHR_MWN: + *pName = "vkCmdTraceRaysIndirect2KHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_ACCELERATION_STRUCTURE_COMPATIBILITY_KHR_MWN: + *pName = "vkGetDeviceAccelerationStructureCompatibilityKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_RAY_TRACING_SHADER_GROUP_STACK_SIZE_KHR_MWN: + *pName = "vkGetRayTracingShaderGroupStackSizeKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_RAY_TRACING_PIPELINE_STACK_SIZE_KHR_MWN: + *pName = "vkCmdSetRayTracingPipelineStackSizeKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_IMAGE_VIEW_HANDLE_NVX_MWN: + *pName = "vkGetImageViewHandleNVX"; + return VK_SUCCESS; + case VK_FUNCTION_GET_IMAGE_VIEW_ADDRESS_NVX_MWN: + *pName = "vkGetImageViewAddressNVX"; + return VK_SUCCESS; + case VK_FUNCTION_ACQUIRE_PROFILING_LOCK_KHR_MWN: + *pName = "vkAcquireProfilingLockKHR"; + return VK_SUCCESS; + case VK_FUNCTION_RELEASE_PROFILING_LOCK_KHR_MWN: + *pName = "vkReleaseProfilingLockKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT_MWN: + *pName = "vkGetImageDrmFormatModifierPropertiesEXT"; + return VK_SUCCESS; + case VK_FUNCTION_GET_BUFFER_OPAQUE_CAPTURE_ADDRESS_MWN: + *pName = "vkGetBufferOpaqueCaptureAddress"; + return VK_SUCCESS; + case VK_FUNCTION_GET_BUFFER_DEVICE_ADDRESS_MWN: + *pName = "vkGetBufferDeviceAddress"; + return VK_SUCCESS; + case VK_FUNCTION_INITIALIZE_PERFORMANCE_API_INTEL_MWN: + *pName = "vkInitializePerformanceApiINTEL"; + return VK_SUCCESS; + case VK_FUNCTION_UNINITIALIZE_PERFORMANCE_API_INTEL_MWN: + *pName = "vkUninitializePerformanceApiINTEL"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_PERFORMANCE_MARKER_INTEL_MWN: + *pName = "vkCmdSetPerformanceMarkerINTEL"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_PERFORMANCE_STREAM_MARKER_INTEL_MWN: + *pName = "vkCmdSetPerformanceStreamMarkerINTEL"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_PERFORMANCE_OVERRIDE_INTEL_MWN: + *pName = "vkCmdSetPerformanceOverrideINTEL"; + return VK_SUCCESS; + case VK_FUNCTION_ACQUIRE_PERFORMANCE_CONFIGURATION_INTEL_MWN: + *pName = "vkAcquirePerformanceConfigurationINTEL"; + return VK_SUCCESS; + case VK_FUNCTION_RELEASE_PERFORMANCE_CONFIGURATION_INTEL_MWN: + *pName = "vkReleasePerformanceConfigurationINTEL"; + return VK_SUCCESS; + case VK_FUNCTION_QUEUE_SET_PERFORMANCE_CONFIGURATION_INTEL_MWN: + *pName = "vkQueueSetPerformanceConfigurationINTEL"; + return VK_SUCCESS; + case VK_FUNCTION_GET_PERFORMANCE_PARAMETER_INTEL_MWN: + *pName = "vkGetPerformanceParameterINTEL"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_MWN: + *pName = "vkGetDeviceMemoryOpaqueCaptureAddress"; + return VK_SUCCESS; + case VK_FUNCTION_GET_PIPELINE_EXECUTABLE_PROPERTIES_KHR_MWN: + *pName = "vkGetPipelineExecutablePropertiesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_PIPELINE_EXECUTABLE_STATISTICS_KHR_MWN: + *pName = "vkGetPipelineExecutableStatisticsKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATIONS_KHR_MWN: + *pName = "vkGetPipelineExecutableInternalRepresentationsKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_LINE_STIPPLE_EXT_MWN: + *pName = "vkCmdSetLineStippleEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_ACCELERATION_STRUCTURE_KHR_MWN: + *pName = "vkCreateAccelerationStructureKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURES_KHR_MWN: + *pName = "vkCmdBuildAccelerationStructuresKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURES_INDIRECT_KHR_MWN: + *pName = "vkCmdBuildAccelerationStructuresIndirectKHR"; + return VK_SUCCESS; + case VK_FUNCTION_BUILD_ACCELERATION_STRUCTURES_KHR_MWN: + *pName = "vkBuildAccelerationStructuresKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_KHR_MWN: + *pName = "vkGetAccelerationStructureDeviceAddressKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_DEFERRED_OPERATION_KHR_MWN: + *pName = "vkCreateDeferredOperationKHR"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_DEFERRED_OPERATION_KHR_MWN: + *pName = "vkDestroyDeferredOperationKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEFERRED_OPERATION_MAX_CONCURRENCY_KHR_MWN: + *pName = "vkGetDeferredOperationMaxConcurrencyKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DEFERRED_OPERATION_RESULT_KHR_MWN: + *pName = "vkGetDeferredOperationResultKHR"; + return VK_SUCCESS; + case VK_FUNCTION_DEFERRED_OPERATION_JOIN_KHR_MWN: + *pName = "vkDeferredOperationJoinKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_CULL_MODE_MWN: + *pName = "vkCmdSetCullMode"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_FRONT_FACE_MWN: + *pName = "vkCmdSetFrontFace"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_PRIMITIVE_TOPOLOGY_MWN: + *pName = "vkCmdSetPrimitiveTopology"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_VIEWPORT_WITH_COUNT_MWN: + *pName = "vkCmdSetViewportWithCount"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_SCISSOR_WITH_COUNT_MWN: + *pName = "vkCmdSetScissorWithCount"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BIND_VERTEX_BUFFERS2_MWN: + *pName = "vkCmdBindVertexBuffers2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_DEPTH_TEST_ENABLE_MWN: + *pName = "vkCmdSetDepthTestEnable"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_DEPTH_WRITE_ENABLE_MWN: + *pName = "vkCmdSetDepthWriteEnable"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_DEPTH_COMPARE_OP_MWN: + *pName = "vkCmdSetDepthCompareOp"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_DEPTH_BOUNDS_TEST_ENABLE_MWN: + *pName = "vkCmdSetDepthBoundsTestEnable"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_STENCIL_TEST_ENABLE_MWN: + *pName = "vkCmdSetStencilTestEnable"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_STENCIL_OP_MWN: + *pName = "vkCmdSetStencilOp"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_PATCH_CONTROL_POINTS_EXT_MWN: + *pName = "vkCmdSetPatchControlPointsEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_RASTERIZER_DISCARD_ENABLE_MWN: + *pName = "vkCmdSetRasterizerDiscardEnable"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_DEPTH_BIAS_ENABLE_MWN: + *pName = "vkCmdSetDepthBiasEnable"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_LOGIC_OP_EXT_MWN: + *pName = "vkCmdSetLogicOpEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_PRIMITIVE_RESTART_ENABLE_MWN: + *pName = "vkCmdSetPrimitiveRestartEnable"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_PRIVATE_DATA_SLOT_MWN: + *pName = "vkCreatePrivateDataSlot"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_PRIVATE_DATA_SLOT_MWN: + *pName = "vkDestroyPrivateDataSlot"; + return VK_SUCCESS; + case VK_FUNCTION_SET_PRIVATE_DATA_MWN: + *pName = "vkSetPrivateData"; + return VK_SUCCESS; + case VK_FUNCTION_GET_PRIVATE_DATA_MWN: + *pName = "vkGetPrivateData"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_BUFFER2_MWN: + *pName = "vkCmdCopyBuffer2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_IMAGE2_MWN: + *pName = "vkCmdCopyImage2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BLIT_IMAGE2_MWN: + *pName = "vkCmdBlitImage2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_BUFFER_TO_IMAGE2_MWN: + *pName = "vkCmdCopyBufferToImage2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_COPY_IMAGE_TO_BUFFER2_MWN: + *pName = "vkCmdCopyImageToBuffer2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_RESOLVE_IMAGE2_MWN: + *pName = "vkCmdResolveImage2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_FRAGMENT_SHADING_RATE_KHR_MWN: + *pName = "vkCmdSetFragmentShadingRateKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_FRAGMENT_SHADING_RATE_ENUM_NV_MWN: + *pName = "vkCmdSetFragmentShadingRateEnumNV"; + return VK_SUCCESS; + case VK_FUNCTION_GET_ACCELERATION_STRUCTURE_BUILD_SIZES_KHR_MWN: + *pName = "vkGetAccelerationStructureBuildSizesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_VERTEX_INPUT_EXT_MWN: + *pName = "vkCmdSetVertexInputEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_COLOR_WRITE_ENABLE_EXT_MWN: + *pName = "vkCmdSetColorWriteEnableEXT"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_SET_EVENT2_MWN: + *pName = "vkCmdSetEvent2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_RESET_EVENT2_MWN: + *pName = "vkCmdResetEvent2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_WAIT_EVENTS2_MWN: + *pName = "vkCmdWaitEvents2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_PIPELINE_BARRIER2_MWN: + *pName = "vkCmdPipelineBarrier2"; + return VK_SUCCESS; + case VK_FUNCTION_QUEUE_SUBMIT2_MWN: + *pName = "vkQueueSubmit2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_WRITE_TIMESTAMP2_MWN: + *pName = "vkCmdWriteTimestamp2"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_WRITE_BUFFER_MARKER2_AMD_MWN: + *pName = "vkCmdWriteBufferMarker2AMD"; + return VK_SUCCESS; + case VK_FUNCTION_GET_QUEUE_CHECKPOINT_DATA2_NV_MWN: + *pName = "vkGetQueueCheckpointData2NV"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_CU_MODULE_NVX_MWN: + *pName = "vkCreateCuModuleNVX"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_CU_FUNCTION_NVX_MWN: + *pName = "vkCreateCuFunctionNVX"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_CU_MODULE_NVX_MWN: + *pName = "vkDestroyCuModuleNVX"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_CU_FUNCTION_NVX_MWN: + *pName = "vkDestroyCuFunctionNVX"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_CU_LAUNCH_KERNEL_NVX_MWN: + *pName = "vkCmdCuLaunchKernelNVX"; + return VK_SUCCESS; + case VK_FUNCTION_SET_DEVICE_MEMORY_PRIORITY_EXT_MWN: + *pName = "vkSetDeviceMemoryPriorityEXT"; + return VK_SUCCESS; + case VK_FUNCTION_WAIT_FOR_PRESENT_KHR_MWN: + *pName = "vkWaitForPresentKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BEGIN_RENDERING_MWN: + *pName = "vkCmdBeginRendering"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_END_RENDERING_MWN: + *pName = "vkCmdEndRendering"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE_MWN: + *pName = "vkGetDescriptorSetLayoutHostMappingInfoVALVE"; + return VK_SUCCESS; + case VK_FUNCTION_GET_DESCRIPTOR_SET_HOST_MAPPING_VALVE_MWN: + *pName = "vkGetDescriptorSetHostMappingVALVE"; + return VK_SUCCESS; + case VK_FUNCTION_GET_IMAGE_SUBRESOURCE_LAYOUT2_EXT_MWN: + *pName = "vkGetImageSubresourceLayout2EXT"; + return VK_SUCCESS; + case VK_FUNCTION_GET_PIPELINE_PROPERTIES_EXT_MWN: + *pName = "vkGetPipelinePropertiesEXT"; + return VK_SUCCESS; +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + + case VK_FUNCTION_GET_SWAPCHAIN_GRALLOC_USAGE_ANDROID_MWN: + *pName = "vkGetSwapchainGrallocUsageANDROID"; + return VK_SUCCESS; + case VK_FUNCTION_GET_SWAPCHAIN_GRALLOC_USAGE2_ANDROID_MWN: + *pName = "vkGetSwapchainGrallocUsage2ANDROID"; + return VK_SUCCESS; + case VK_FUNCTION_ACQUIRE_IMAGE_ANDROID_MWN: + *pName = "vkAcquireImageANDROID"; + return VK_SUCCESS; + case VK_FUNCTION_QUEUE_SIGNAL_RELEASE_IMAGE_ANDROID_MWN: + *pName = "vkQueueSignalReleaseImageANDROID"; + return VK_SUCCESS; + case VK_FUNCTION_GET_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID_MWN: + *pName = "vkGetAndroidHardwareBufferPropertiesANDROID"; + return VK_SUCCESS; + case VK_FUNCTION_GET_MEMORY_ANDROID_HARDWARE_BUFFER_ANDROID_MWN: + *pName = "vkGetMemoryAndroidHardwareBufferANDROID"; + return VK_SUCCESS; +#endif // defined(VK_USE_PLATFORM_ANDROID_KHR) + +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#if defined(VK_USE_PLATFORM_FUCHSIA) + + case VK_FUNCTION_GET_MEMORY_ZIRCON_HANDLE_FUCHSIA_MWN: + *pName = "vkGetMemoryZirconHandleFUCHSIA"; + return VK_SUCCESS; + case VK_FUNCTION_GET_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA_MWN: + *pName = "vkGetMemoryZirconHandlePropertiesFUCHSIA"; + return VK_SUCCESS; + case VK_FUNCTION_GET_SEMAPHORE_ZIRCON_HANDLE_FUCHSIA_MWN: + *pName = "vkGetSemaphoreZirconHandleFUCHSIA"; + return VK_SUCCESS; + case VK_FUNCTION_IMPORT_SEMAPHORE_ZIRCON_HANDLE_FUCHSIA_MWN: + *pName = "vkImportSemaphoreZirconHandleFUCHSIA"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_BUFFER_COLLECTION_FUCHSIA_MWN: + *pName = "vkCreateBufferCollectionFUCHSIA"; + return VK_SUCCESS; + case VK_FUNCTION_SET_BUFFER_COLLECTION_BUFFER_CONSTRAINTS_FUCHSIA_MWN: + *pName = "vkSetBufferCollectionBufferConstraintsFUCHSIA"; + return VK_SUCCESS; + case VK_FUNCTION_SET_BUFFER_COLLECTION_IMAGE_CONSTRAINTS_FUCHSIA_MWN: + *pName = "vkSetBufferCollectionImageConstraintsFUCHSIA"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_BUFFER_COLLECTION_FUCHSIA_MWN: + *pName = "vkDestroyBufferCollectionFUCHSIA"; + return VK_SUCCESS; + case VK_FUNCTION_GET_BUFFER_COLLECTION_PROPERTIES_FUCHSIA_MWN: + *pName = "vkGetBufferCollectionPropertiesFUCHSIA"; + return VK_SUCCESS; +#endif // defined(VK_USE_PLATFORM_FUCHSIA) + +#if defined(VK_USE_PLATFORM_GGP) + +#endif // defined(VK_USE_PLATFORM_GGP) + +#if defined(VK_USE_PLATFORM_IOS_MVK) + +#endif // defined(VK_USE_PLATFORM_IOS_MVK) + +#if defined(VK_USE_PLATFORM_MACOS_MVK) + +#endif // defined(VK_USE_PLATFORM_MACOS_MVK) + +#if defined(VK_USE_PLATFORM_METAL_EXT) + + case VK_FUNCTION_EXPORT_METAL_OBJECTS_EXT_MWN: + *pName = "vkExportMetalObjectsEXT"; + return VK_SUCCESS; +#endif // defined(VK_USE_PLATFORM_METAL_EXT) + +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_FUNCTION_CREATE_VIDEO_SESSION_KHR_MWN: + *pName = "vkCreateVideoSessionKHR"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_VIDEO_SESSION_KHR_MWN: + *pName = "vkDestroyVideoSessionKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CREATE_VIDEO_SESSION_PARAMETERS_KHR_MWN: + *pName = "vkCreateVideoSessionParametersKHR"; + return VK_SUCCESS; + case VK_FUNCTION_UPDATE_VIDEO_SESSION_PARAMETERS_KHR_MWN: + *pName = "vkUpdateVideoSessionParametersKHR"; + return VK_SUCCESS; + case VK_FUNCTION_DESTROY_VIDEO_SESSION_PARAMETERS_KHR_MWN: + *pName = "vkDestroyVideoSessionParametersKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR_MWN: + *pName = "vkGetVideoSessionMemoryRequirementsKHR"; + return VK_SUCCESS; + case VK_FUNCTION_BIND_VIDEO_SESSION_MEMORY_KHR_MWN: + *pName = "vkBindVideoSessionMemoryKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_DECODE_VIDEO_KHR_MWN: + *pName = "vkCmdDecodeVideoKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_BEGIN_VIDEO_CODING_KHR_MWN: + *pName = "vkCmdBeginVideoCodingKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_CONTROL_VIDEO_CODING_KHR_MWN: + *pName = "vkCmdControlVideoCodingKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_END_VIDEO_CODING_KHR_MWN: + *pName = "vkCmdEndVideoCodingKHR"; + return VK_SUCCESS; + case VK_FUNCTION_CMD_ENCODE_VIDEO_KHR_MWN: + *pName = "vkCmdEncodeVideoKHR"; + return VK_SUCCESS; +#endif // defined(VK_ENABLE_BETA_EXTENSIONS) + +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + +#endif // defined(VK_USE_PLATFORM_SCREEN_QNX) + +#if defined(VK_USE_PLATFORM_VI_NN) + +#endif // defined(VK_USE_PLATFORM_VI_NN) + +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_NV_MWN: + *pName = "vkGetMemoryWin32HandleNV"; + return VK_SUCCESS; + case VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_KHR_MWN: + *pName = "vkGetMemoryWin32HandleKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_PROPERTIES_KHR_MWN: + *pName = "vkGetMemoryWin32HandlePropertiesKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_SEMAPHORE_WIN32_HANDLE_KHR_MWN: + *pName = "vkGetSemaphoreWin32HandleKHR"; + return VK_SUCCESS; + case VK_FUNCTION_IMPORT_SEMAPHORE_WIN32_HANDLE_KHR_MWN: + *pName = "vkImportSemaphoreWin32HandleKHR"; + return VK_SUCCESS; + case VK_FUNCTION_GET_FENCE_WIN32_HANDLE_KHR_MWN: + *pName = "vkGetFenceWin32HandleKHR"; + return VK_SUCCESS; + case VK_FUNCTION_IMPORT_FENCE_WIN32_HANDLE_KHR_MWN: + *pName = "vkImportFenceWin32HandleKHR"; + return VK_SUCCESS; + case VK_FUNCTION_ACQUIRE_FULL_SCREEN_EXCLUSIVE_MODE_EXT_MWN: + *pName = "vkAcquireFullScreenExclusiveModeEXT"; + return VK_SUCCESS; + case VK_FUNCTION_RELEASE_FULL_SCREEN_EXCLUSIVE_MODE_EXT_MWN: + *pName = "vkReleaseFullScreenExclusiveModeEXT"; + return VK_SUCCESS; +#endif // defined(VK_USE_PLATFORM_WIN32_KHR) + +#if defined(VK_USE_PLATFORM_XCB_KHR) + +#endif // defined(VK_USE_PLATFORM_XCB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_KHR) + +#endif // defined(VK_USE_PLATFORM_XLIB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) +#endif // defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) + + default: + return VK_ERROR_UNKNOWN; + } +} + +} // namespace vk_capture diff --git a/source/layer.cpp b/source/layer.cpp index 26dec5b..2f85bc2 100644 --- a/source/layer.cpp +++ b/source/layer.cpp @@ -139,6 +139,12 @@ PFN_vkVoidFunction getLayerFunctionPtr(const char* pName) else if (std::strcmp(pName, "vkGetRecordListItemsMWN") == 0) { return reinterpret_cast(&vkGetRecordListItemsMWN); } + else if (std::strcmp(pName, "vkResetRecordListMWN") == 0) { + return reinterpret_cast(&vkResetRecordListMWN); + } + else if (std::strcmp(pName, "vkGetFunctionNameMWN") == 0) { + return reinterpret_cast(&vkGetFunctionNameMWN); + } else { return getWrappedFunctionPtr(pName); } diff --git a/source/record_list.cpp b/source/record_list.cpp index e651340..fa1098a 100644 --- a/source/record_list.cpp +++ b/source/record_list.cpp @@ -79,6 +79,17 @@ VkResult vkGetRecordListItemsMWN(VkDevice /* device */, VkRecordListMWN recordLi return VK_SUCCESS; } +VkResult vkResetRecordListMWN(VkDevice /* device */, VkRecordListMWN recordList) +{ + assert(recordList); + + recordList->items.clear(); + recordList->values.reset(); + recordList->data.reset(); + + return VK_SUCCESS; +} + VkVariantMWN* allocVariant(std::size_t num) { assert(g_activeRecordList); diff --git a/source/record_list.hpp b/source/record_list.hpp index fd00c54..814f699 100644 --- a/source/record_list.hpp +++ b/source/record_list.hpp @@ -47,11 +47,12 @@ void vkFreeRecordListMWN(VkDevice device, VkRecordListMWN recordList); VkResult vkBeginRecordingMWN(VkDevice device, const VkRecordInfoMWN* pRecordInfo); void vkEndRecordingMWN(VkDevice device); VkResult vkGetRecordListItemsMWN(VkDevice device, VkRecordListMWN recordList, uint32_t* pItemCount, VkRecordListItemMWN** pItems); +VkResult vkResetRecordListMWN(VkDevice device, VkRecordListMWN recordList); +VkResult vkGetFunctionNameMWN(VkDevice device, VkFunctionMWN function, const char** pName); template void recordFunction(VkFunctionMWN function, const TResult& result, const TArgs&... args) { - (void) result; if (!g_activeRecordList) { return; } diff --git a/source/variant_pool.cpp b/source/variant_pool.cpp index 1bcdc6a..4b718fa 100644 --- a/source/variant_pool.cpp +++ b/source/variant_pool.cpp @@ -34,14 +34,16 @@ VkVariantMWN* VariantPool::allocate(std::size_t num) { assert(num > 0 && num <= PAGE_SIZE); const std::size_t remainingOnPage = PAGE_SIZE - (nextIndex % PAGE_SIZE); + const std::size_t page = nextIndex / PAGE_SIZE; + const std::size_t localIndex = nextIndex % PAGE_SIZE; if (remainingOnPage == PAGE_SIZE || remainingOnPage < num) { // next page - pages.push_back(std::make_unique()); + if (page + 1 >= pages.size()) { + pages.push_back(std::make_unique()); + } nextIndex = PAGE_SIZE * (pages.size() - 1); } - const std::size_t page = nextIndex / PAGE_SIZE; - const std::size_t localIndex = nextIndex % PAGE_SIZE; VkVariantMWN* result = &(*pages[page])[localIndex]; nextIndex += num; return result; diff --git a/source/variant_pool.hpp b/source/variant_pool.hpp index 01ea85b..17cb826 100644 --- a/source/variant_pool.hpp +++ b/source/variant_pool.hpp @@ -6,6 +6,7 @@ #include #include +#include #include #include #include "common.hpp" @@ -110,6 +111,16 @@ inline void variantWrap(const void* value, VkVariantMWN& outVariant) outVariant.voidPointerValue = value; } +inline void variantWrap(const char* value, VkVariantMWN& outVariant) +{ + const std::size_t len = std::strlen(value); + outVariant.type = VK_VARIANT_TYPE_STRING_MWN; + + char* copy = allocType(len + 1); + std::memcpy(copy, value, len + 1); + outVariant.stringValue = copy; +} + template inline void variantWrap(const TPointed* value, VkVariantMWN& outVariant);