diff --git a/script/generate_dispatch.py b/script/generate_dispatch.py index 2ec3727..1d86131 100644 --- a/script/generate_dispatch.py +++ b/script/generate_dispatch.py @@ -198,22 +198,41 @@ for level in core_commands: else: if '#text' in t: text = t['#text'] - if 'const' in text: - proxy_definition += 'const ' - proxy_definition += t['type'] - if '*' in text and not '**' in text: + text = text.replace(' ', '') + array = ''; + array_index = text.find('[') + if array_index != -1: + array = text[array_index:] + text = text[0:array_index] + if text == '*': + proxy_definition += t['type'] proxy_definition += '* ' proxy_definition += t['name'] - elif '**' in text: + elif text == '**': + proxy_definition += t['type'] proxy_definition += '** ' proxy_definition += t['name'] + elif text == 'const*': + proxy_definition += 'const ' + proxy_definition += t['type'] + proxy_definition += '* ' + proxy_definition += t['name'] + elif text == 'const**': + proxy_definition += 'const ' + proxy_definition += t['type'] + proxy_definition += '** ' + proxy_definition += t['name'] + elif text == 'const*const*': + proxy_definition += 'const ' + proxy_definition += t['type'] + proxy_definition += '* const* ' + proxy_definition += t['name'] else: + proxy_definition += t['type'] proxy_definition += ' ' proxy_definition += t['name'] - if '[' in text and ']' in text: - start = text.find('[') - end = text.find(']') - proxy_definition += text[start:end+1] + if array != '': + proxy_definition += array else: proxy_definition += t['type'] proxy_definition += ' ' @@ -252,6 +271,7 @@ for extension in extension_commands: if len(extension_commands[extension]) > 0: pfn_declaration += '#if defined(' + extension[0] + ') && defined(' + extension[1] + ')\n'; pfn_loading += '#if defined(' + extension[0] + ') && defined(' + extension[1] + ')\n'; + proxy_definition += '#if defined(' + extension[0] + ') && defined(' + extension[1] + ')\n'; for command in extension_commands[extension]: fptr_name = 'PFN_' + command member_name = 'fp_' + command @@ -266,8 +286,94 @@ for extension in extension_commands: pfn_loading += '#define ' + fptr_name + '_LOAD\n' pfn_loading += '\t\t' + member_name + ' = (' + fptr_name + ')procAddr(device, "' + command + '");\n' pfn_loading += '#endif\n' + #Duplication guards + proxy_definition += '#ifndef ' + fptr_name + '_PROXY\n' + proxy_definition += '#define ' + fptr_name + '_PROXY\n' + #proxy_definition += '\t\tTEST '+ proxy_name +'\n' + types = device_commands[command][0] + names = []; + i = 0 + length = len(types) - 1 + takes_device = False; + proxy_definition += '\t' + return_type = device_commands[command][1]; + proxy_definition += return_type + proxy_definition += ' ' + proxy_definition += proxy_name + proxy_definition += '(' + for t in types: + if i == 0 and t['type'] == 'VkDevice': + takes_device = True + else: + if '#text' in t: + text = t['#text'] + text = text.replace(' ', '') + array = ''; + array_index = text.find('[') + if array_index != -1: + array = text[array_index:] + text = text[0:array_index] + if text == '*': + proxy_definition += t['type'] + proxy_definition += '* ' + proxy_definition += t['name'] + elif text == '**': + proxy_definition += t['type'] + proxy_definition += '** ' + proxy_definition += t['name'] + elif text == 'const*': + proxy_definition += 'const ' + proxy_definition += t['type'] + proxy_definition += '* ' + proxy_definition += t['name'] + elif text == 'const**': + proxy_definition += 'const ' + proxy_definition += t['type'] + proxy_definition += '** ' + proxy_definition += t['name'] + elif text == 'const*const*': + proxy_definition += 'const ' + proxy_definition += t['type'] + proxy_definition += '* const* ' + proxy_definition += t['name'] + else: + proxy_definition += t['type'] + proxy_definition += ' ' + proxy_definition += t['name'] + if array != '': + proxy_definition += array + else: + proxy_definition += t['type'] + proxy_definition += ' ' + proxy_definition += t['name'] + names += [t['name']] + if i < length: + proxy_definition += ', ' + i += 1 + proxy_definition += ') {\n' + proxy_definition += '\t\t' + if return_type != 'void': + proxy_definition += 'return ' + proxy_definition += member_name + proxy_definition += '(' + + if takes_device: + proxy_definition +='_device' + if(len(names) > 0): + proxy_definition += ', ' + i = 0 + length = len(names) - 1 + for name in names: + proxy_definition += name + if i < length: + proxy_definition += ', ' + i += 1 + proxy_definition += ');\n' + proxy_definition += '\t}\n' + proxy_definition += '#endif\n' pfn_declaration += '#endif\n' pfn_loading += '#endif\n' + proxy_definition += '#endif\n' header += pfn_loading header += '\t}\n' diff --git a/src/VkDispatchTable.h b/src/VkDispatchTable.h index d70691a..a7cc1bd 100644 --- a/src/VkDispatchTable.h +++ b/src/VkDispatchTable.h @@ -313,12 +313,6 @@ struct DispatchTable { fp_vkCmdDecodeVideoKHR = (PFN_vkCmdDecodeVideoKHR)procAddr(device, "vkCmdDecodeVideoKHR"); #endif #endif -#if defined(VK_KHR_video_encode_queue) && defined(VK_VERSION_1_0) -#ifndef PFN_vkCmdEncodeVideoKHR_LOAD -#define PFN_vkCmdEncodeVideoKHR_LOAD - fp_vkCmdEncodeVideoKHR = (PFN_vkCmdEncodeVideoKHR)procAddr(device, "vkCmdEncodeVideoKHR"); -#endif -#endif #if defined(VK_EXT_transform_feedback) && defined(VK_VERSION_1_0) #ifndef PFN_vkCmdBindTransformFeedbackBuffersEXT_LOAD #define PFN_vkCmdBindTransformFeedbackBuffersEXT_LOAD @@ -345,6 +339,28 @@ struct DispatchTable { fp_vkCmdDrawIndirectByteCountEXT = (PFN_vkCmdDrawIndirectByteCountEXT)procAddr(device, "vkCmdDrawIndirectByteCountEXT"); #endif #endif +#if defined(VK_NVX_binary_import) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateCuModuleNVX_LOAD +#define PFN_vkCreateCuModuleNVX_LOAD + fp_vkCreateCuModuleNVX = (PFN_vkCreateCuModuleNVX)procAddr(device, "vkCreateCuModuleNVX"); +#endif +#ifndef PFN_vkCreateCuFunctionNVX_LOAD +#define PFN_vkCreateCuFunctionNVX_LOAD + fp_vkCreateCuFunctionNVX = (PFN_vkCreateCuFunctionNVX)procAddr(device, "vkCreateCuFunctionNVX"); +#endif +#ifndef PFN_vkDestroyCuModuleNVX_LOAD +#define PFN_vkDestroyCuModuleNVX_LOAD + fp_vkDestroyCuModuleNVX = (PFN_vkDestroyCuModuleNVX)procAddr(device, "vkDestroyCuModuleNVX"); +#endif +#ifndef PFN_vkDestroyCuFunctionNVX_LOAD +#define PFN_vkDestroyCuFunctionNVX_LOAD + fp_vkDestroyCuFunctionNVX = (PFN_vkDestroyCuFunctionNVX)procAddr(device, "vkDestroyCuFunctionNVX"); +#endif +#ifndef PFN_vkCmdCuLaunchKernelNVX_LOAD +#define PFN_vkCmdCuLaunchKernelNVX_LOAD + fp_vkCmdCuLaunchKernelNVX = (PFN_vkCmdCuLaunchKernelNVX)procAddr(device, "vkCmdCuLaunchKernelNVX"); +#endif +#endif #if defined(VK_NVX_image_view_handle) && defined(VK_VERSION_1_0) #ifndef PFN_vkGetImageViewHandleNVX_LOAD #define PFN_vkGetImageViewHandleNVX_LOAD @@ -1157,6 +1173,12 @@ struct DispatchTable { fp_vkGetPrivateDataEXT = (PFN_vkGetPrivateDataEXT)procAddr(device, "vkGetPrivateDataEXT"); #endif #endif +#if defined(VK_KHR_video_encode_queue) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdEncodeVideoKHR_LOAD +#define PFN_vkCmdEncodeVideoKHR_LOAD + fp_vkCmdEncodeVideoKHR = (PFN_vkCmdEncodeVideoKHR)procAddr(device, "vkCmdEncodeVideoKHR"); +#endif +#endif #if defined(VK_KHR_synchronization2) && defined(VK_VERSION_1_0) #ifndef PFN_vkCmdSetEvent2KHR_LOAD #define PFN_vkCmdSetEvent2KHR_LOAD @@ -1518,7 +1540,7 @@ struct DispatchTable { void cmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { fp_vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); } - void cmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { + void cmdSetBlendConstants(VkCommandBuffer commandBuffer, float blendConstants[4]) { fp_vkCmdSetBlendConstants(commandBuffer, blendConstants); } void cmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { @@ -1722,6 +1744,1604 @@ struct DispatchTable { uint64_t getDeviceMemoryOpaqueCaptureAddress(const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { return fp_vkGetDeviceMemoryOpaqueCaptureAddress(_device, pInfo); } +#if defined(VK_KHR_swapchain) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateSwapchainKHR_PROXY +#define PFN_vkCreateSwapchainKHR_PROXY + VkResult createSwapchainKHR(const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { + return fp_vkCreateSwapchainKHR(_device, pCreateInfo, pAllocator, pSwapchain); + } +#endif +#ifndef PFN_vkDestroySwapchainKHR_PROXY +#define PFN_vkDestroySwapchainKHR_PROXY + void destroySwapchainKHR(VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroySwapchainKHR(_device, swapchain, pAllocator); + } +#endif +#ifndef PFN_vkGetSwapchainImagesKHR_PROXY +#define PFN_vkGetSwapchainImagesKHR_PROXY + VkResult getSwapchainImagesKHR(VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { + return fp_vkGetSwapchainImagesKHR(_device, swapchain, pSwapchainImageCount, pSwapchainImages); + } +#endif +#ifndef PFN_vkAcquireNextImageKHR_PROXY +#define PFN_vkAcquireNextImageKHR_PROXY + VkResult acquireNextImageKHR(VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { + return fp_vkAcquireNextImageKHR(_device, swapchain, timeout, semaphore, fence, pImageIndex); + } +#endif +#ifndef PFN_vkQueuePresentKHR_PROXY +#define PFN_vkQueuePresentKHR_PROXY + VkResult queuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { + return fp_vkQueuePresentKHR(queue, pPresentInfo); + } +#endif +#endif +#if defined(VK_KHR_swapchain) && defined(VK_VERSION_1_1) +#ifndef PFN_vkGetDeviceGroupPresentCapabilitiesKHR_PROXY +#define PFN_vkGetDeviceGroupPresentCapabilitiesKHR_PROXY + VkResult getDeviceGroupPresentCapabilitiesKHR(VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { + return fp_vkGetDeviceGroupPresentCapabilitiesKHR(_device, pDeviceGroupPresentCapabilities); + } +#endif +#ifndef PFN_vkGetDeviceGroupSurfacePresentModesKHR_PROXY +#define PFN_vkGetDeviceGroupSurfacePresentModesKHR_PROXY + VkResult getDeviceGroupSurfacePresentModesKHR(VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { + return fp_vkGetDeviceGroupSurfacePresentModesKHR(_device, surface, pModes); + } +#endif +#ifndef PFN_vkAcquireNextImage2KHR_PROXY +#define PFN_vkAcquireNextImage2KHR_PROXY + VkResult acquireNextImage2KHR(const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { + return fp_vkAcquireNextImage2KHR(_device, pAcquireInfo, pImageIndex); + } +#endif +#endif +#if defined(VK_KHR_display_swapchain) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateSharedSwapchainsKHR_PROXY +#define PFN_vkCreateSharedSwapchainsKHR_PROXY + VkResult createSharedSwapchainsKHR(uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) { + return fp_vkCreateSharedSwapchainsKHR(_device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); + } +#endif +#endif +#if defined(VK_ANDROID_native_buffer) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetSwapchainGrallocUsageANDROID_PROXY +#define PFN_vkGetSwapchainGrallocUsageANDROID_PROXY + VkResult getSwapchainGrallocUsageANDROID(VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage) { + return fp_vkGetSwapchainGrallocUsageANDROID(_device, format, imageUsage, grallocUsage); + } +#endif +#ifndef PFN_vkAcquireImageANDROID_PROXY +#define PFN_vkAcquireImageANDROID_PROXY + VkResult acquireImageANDROID(VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence) { + return fp_vkAcquireImageANDROID(_device, image, nativeFenceFd, semaphore, fence); + } +#endif +#ifndef PFN_vkQueueSignalReleaseImageANDROID_PROXY +#define PFN_vkQueueSignalReleaseImageANDROID_PROXY + VkResult queueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd) { + return fp_vkQueueSignalReleaseImageANDROID(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd); + } +#endif +#ifndef PFN_vkGetSwapchainGrallocUsage2ANDROID_PROXY +#define PFN_vkGetSwapchainGrallocUsage2ANDROID_PROXY + VkResult getSwapchainGrallocUsage2ANDROID(VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage) { + return fp_vkGetSwapchainGrallocUsage2ANDROID(_device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage); + } +#endif +#endif +#if defined(VK_EXT_debug_marker) && defined(VK_VERSION_1_0) +#ifndef PFN_vkDebugMarkerSetObjectTagEXT_PROXY +#define PFN_vkDebugMarkerSetObjectTagEXT_PROXY + VkResult debugMarkerSetObjectTagEXT(const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { + return fp_vkDebugMarkerSetObjectTagEXT(_device, pTagInfo); + } +#endif +#ifndef PFN_vkDebugMarkerSetObjectNameEXT_PROXY +#define PFN_vkDebugMarkerSetObjectNameEXT_PROXY + VkResult debugMarkerSetObjectNameEXT(const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { + return fp_vkDebugMarkerSetObjectNameEXT(_device, pNameInfo); + } +#endif +#ifndef PFN_vkCmdDebugMarkerBeginEXT_PROXY +#define PFN_vkCmdDebugMarkerBeginEXT_PROXY + void cmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { + fp_vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); + } +#endif +#ifndef PFN_vkCmdDebugMarkerEndEXT_PROXY +#define PFN_vkCmdDebugMarkerEndEXT_PROXY + void cmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) { + fp_vkCmdDebugMarkerEndEXT(commandBuffer); + } +#endif +#ifndef PFN_vkCmdDebugMarkerInsertEXT_PROXY +#define PFN_vkCmdDebugMarkerInsertEXT_PROXY + void cmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { + fp_vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); + } +#endif +#endif +#if defined(VK_KHR_video_queue) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateVideoSessionKHR_PROXY +#define PFN_vkCreateVideoSessionKHR_PROXY + VkResult createVideoSessionKHR(const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) { + return fp_vkCreateVideoSessionKHR(_device, pCreateInfo, pAllocator, pVideoSession); + } +#endif +#ifndef PFN_vkDestroyVideoSessionKHR_PROXY +#define PFN_vkDestroyVideoSessionKHR_PROXY + void destroyVideoSessionKHR(VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyVideoSessionKHR(_device, videoSession, pAllocator); + } +#endif +#ifndef PFN_vkGetVideoSessionMemoryRequirementsKHR_PROXY +#define PFN_vkGetVideoSessionMemoryRequirementsKHR_PROXY + VkResult getVideoSessionMemoryRequirementsKHR(VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount, VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) { + return fp_vkGetVideoSessionMemoryRequirementsKHR(_device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements); + } +#endif +#ifndef PFN_vkBindVideoSessionMemoryKHR_PROXY +#define PFN_vkBindVideoSessionMemoryKHR_PROXY + VkResult bindVideoSessionMemoryKHR(VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories) { + return fp_vkBindVideoSessionMemoryKHR(_device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories); + } +#endif +#ifndef PFN_vkCreateVideoSessionParametersKHR_PROXY +#define PFN_vkCreateVideoSessionParametersKHR_PROXY + VkResult createVideoSessionParametersKHR(const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) { + return fp_vkCreateVideoSessionParametersKHR(_device, pCreateInfo, pAllocator, pVideoSessionParameters); + } +#endif +#ifndef PFN_vkUpdateVideoSessionParametersKHR_PROXY +#define PFN_vkUpdateVideoSessionParametersKHR_PROXY + VkResult updateVideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) { + return fp_vkUpdateVideoSessionParametersKHR(_device, videoSessionParameters, pUpdateInfo); + } +#endif +#ifndef PFN_vkDestroyVideoSessionParametersKHR_PROXY +#define PFN_vkDestroyVideoSessionParametersKHR_PROXY + void destroyVideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyVideoSessionParametersKHR(_device, videoSessionParameters, pAllocator); + } +#endif +#ifndef PFN_vkCmdBeginVideoCodingKHR_PROXY +#define PFN_vkCmdBeginVideoCodingKHR_PROXY + void cmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) { + fp_vkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); + } +#endif +#ifndef PFN_vkCmdEndVideoCodingKHR_PROXY +#define PFN_vkCmdEndVideoCodingKHR_PROXY + void cmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) { + fp_vkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); + } +#endif +#ifndef PFN_vkCmdControlVideoCodingKHR_PROXY +#define PFN_vkCmdControlVideoCodingKHR_PROXY + void cmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) { + fp_vkCmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); + } +#endif +#endif +#if defined(VK_KHR_video_decode_queue) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdDecodeVideoKHR_PROXY +#define PFN_vkCmdDecodeVideoKHR_PROXY + void cmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo) { + fp_vkCmdDecodeVideoKHR(commandBuffer, pFrameInfo); + } +#endif +#endif +#if defined(VK_EXT_transform_feedback) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdBindTransformFeedbackBuffersEXT_PROXY +#define PFN_vkCmdBindTransformFeedbackBuffersEXT_PROXY + void cmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) { + fp_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); + } +#endif +#ifndef PFN_vkCmdBeginTransformFeedbackEXT_PROXY +#define PFN_vkCmdBeginTransformFeedbackEXT_PROXY + void cmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { + fp_vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + } +#endif +#ifndef PFN_vkCmdEndTransformFeedbackEXT_PROXY +#define PFN_vkCmdEndTransformFeedbackEXT_PROXY + void cmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) { + fp_vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + } +#endif +#ifndef PFN_vkCmdBeginQueryIndexedEXT_PROXY +#define PFN_vkCmdBeginQueryIndexedEXT_PROXY + void cmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { + fp_vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); + } +#endif +#ifndef PFN_vkCmdEndQueryIndexedEXT_PROXY +#define PFN_vkCmdEndQueryIndexedEXT_PROXY + void cmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) { + fp_vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); + } +#endif +#ifndef PFN_vkCmdDrawIndirectByteCountEXT_PROXY +#define PFN_vkCmdDrawIndirectByteCountEXT_PROXY + void cmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) { + fp_vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); + } +#endif +#endif +#if defined(VK_NVX_binary_import) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateCuModuleNVX_PROXY +#define PFN_vkCreateCuModuleNVX_PROXY + VkResult createCuModuleNVX(const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) { + return fp_vkCreateCuModuleNVX(_device, pCreateInfo, pAllocator, pModule); + } +#endif +#ifndef PFN_vkCreateCuFunctionNVX_PROXY +#define PFN_vkCreateCuFunctionNVX_PROXY + VkResult createCuFunctionNVX(const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) { + return fp_vkCreateCuFunctionNVX(_device, pCreateInfo, pAllocator, pFunction); + } +#endif +#ifndef PFN_vkDestroyCuModuleNVX_PROXY +#define PFN_vkDestroyCuModuleNVX_PROXY + void destroyCuModuleNVX(VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyCuModuleNVX(_device, module, pAllocator); + } +#endif +#ifndef PFN_vkDestroyCuFunctionNVX_PROXY +#define PFN_vkDestroyCuFunctionNVX_PROXY + void destroyCuFunctionNVX(VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyCuFunctionNVX(_device, function, pAllocator); + } +#endif +#ifndef PFN_vkCmdCuLaunchKernelNVX_PROXY +#define PFN_vkCmdCuLaunchKernelNVX_PROXY + void cmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) { + fp_vkCmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo); + } +#endif +#endif +#if defined(VK_NVX_image_view_handle) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetImageViewHandleNVX_PROXY +#define PFN_vkGetImageViewHandleNVX_PROXY + uint32_t getImageViewHandleNVX(const VkImageViewHandleInfoNVX* pInfo) { + return fp_vkGetImageViewHandleNVX(_device, pInfo); + } +#endif +#ifndef PFN_vkGetImageViewAddressNVX_PROXY +#define PFN_vkGetImageViewAddressNVX_PROXY + VkResult getImageViewAddressNVX(VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) { + return fp_vkGetImageViewAddressNVX(_device, imageView, pProperties); + } +#endif +#endif +#if defined(VK_AMD_draw_indirect_count) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdDrawIndirectCountAMD_PROXY +#define PFN_vkCmdDrawIndirectCountAMD_PROXY + void cmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + fp_vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } +#endif +#ifndef PFN_vkCmdDrawIndexedIndirectCountAMD_PROXY +#define PFN_vkCmdDrawIndexedIndirectCountAMD_PROXY + void cmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + fp_vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } +#endif +#endif +#if defined(VK_AMD_shader_info) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetShaderInfoAMD_PROXY +#define PFN_vkGetShaderInfoAMD_PROXY + VkResult getShaderInfoAMD(VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) { + return fp_vkGetShaderInfoAMD(_device, pipeline, shaderStage, infoType, pInfoSize, pInfo); + } +#endif +#endif +#if defined(VK_NV_external_memory_win32) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetMemoryWin32HandleNV_PROXY +#define PFN_vkGetMemoryWin32HandleNV_PROXY + VkResult getMemoryWin32HandleNV(VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) { + return fp_vkGetMemoryWin32HandleNV(_device, memory, handleType, pHandle); + } +#endif +#endif +#if defined(VK_KHR_device_group) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR_PROXY +#define PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR_PROXY + void getDeviceGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { + fp_vkGetDeviceGroupPeerMemoryFeaturesKHR(_device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + } +#endif +#ifndef PFN_vkCmdSetDeviceMaskKHR_PROXY +#define PFN_vkCmdSetDeviceMaskKHR_PROXY + void cmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) { + fp_vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask); + } +#endif +#ifndef PFN_vkCmdDispatchBaseKHR_PROXY +#define PFN_vkCmdDispatchBaseKHR_PROXY + void cmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) { + fp_vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + } +#endif +#ifndef PFN_vkGetDeviceGroupPresentCapabilitiesKHR_PROXY +#define PFN_vkGetDeviceGroupPresentCapabilitiesKHR_PROXY + VkResult getDeviceGroupPresentCapabilitiesKHR(VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { + return fp_vkGetDeviceGroupPresentCapabilitiesKHR(_device, pDeviceGroupPresentCapabilities); + } +#endif +#ifndef PFN_vkGetDeviceGroupSurfacePresentModesKHR_PROXY +#define PFN_vkGetDeviceGroupSurfacePresentModesKHR_PROXY + VkResult getDeviceGroupSurfacePresentModesKHR(VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { + return fp_vkGetDeviceGroupSurfacePresentModesKHR(_device, surface, pModes); + } +#endif +#ifndef PFN_vkAcquireNextImage2KHR_PROXY +#define PFN_vkAcquireNextImage2KHR_PROXY + VkResult acquireNextImage2KHR(const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { + return fp_vkAcquireNextImage2KHR(_device, pAcquireInfo, pImageIndex); + } +#endif +#endif +#if defined(VK_KHR_maintenance1) && defined(VK_VERSION_1_0) +#ifndef PFN_vkTrimCommandPoolKHR_PROXY +#define PFN_vkTrimCommandPoolKHR_PROXY + void trimCommandPoolKHR(VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { + fp_vkTrimCommandPoolKHR(_device, commandPool, flags); + } +#endif +#endif +#if defined(VK_KHR_external_memory_win32) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetMemoryWin32HandleKHR_PROXY +#define PFN_vkGetMemoryWin32HandleKHR_PROXY + VkResult getMemoryWin32HandleKHR(const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { + return fp_vkGetMemoryWin32HandleKHR(_device, pGetWin32HandleInfo, pHandle); + } +#endif +#ifndef PFN_vkGetMemoryWin32HandlePropertiesKHR_PROXY +#define PFN_vkGetMemoryWin32HandlePropertiesKHR_PROXY + VkResult getMemoryWin32HandlePropertiesKHR(VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { + return fp_vkGetMemoryWin32HandlePropertiesKHR(_device, handleType, handle, pMemoryWin32HandleProperties); + } +#endif +#endif +#if defined(VK_KHR_external_memory_fd) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetMemoryFdKHR_PROXY +#define PFN_vkGetMemoryFdKHR_PROXY + VkResult getMemoryFdKHR(const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) { + return fp_vkGetMemoryFdKHR(_device, pGetFdInfo, pFd); + } +#endif +#ifndef PFN_vkGetMemoryFdPropertiesKHR_PROXY +#define PFN_vkGetMemoryFdPropertiesKHR_PROXY + VkResult getMemoryFdPropertiesKHR(VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) { + return fp_vkGetMemoryFdPropertiesKHR(_device, handleType, fd, pMemoryFdProperties); + } +#endif +#endif +#if defined(VK_KHR_external_semaphore_win32) && defined(VK_VERSION_1_0) +#ifndef PFN_vkImportSemaphoreWin32HandleKHR_PROXY +#define PFN_vkImportSemaphoreWin32HandleKHR_PROXY + VkResult importSemaphoreWin32HandleKHR(const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { + return fp_vkImportSemaphoreWin32HandleKHR(_device, pImportSemaphoreWin32HandleInfo); + } +#endif +#ifndef PFN_vkGetSemaphoreWin32HandleKHR_PROXY +#define PFN_vkGetSemaphoreWin32HandleKHR_PROXY + VkResult getSemaphoreWin32HandleKHR(const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { + return fp_vkGetSemaphoreWin32HandleKHR(_device, pGetWin32HandleInfo, pHandle); + } +#endif +#endif +#if defined(VK_KHR_external_semaphore_fd) && defined(VK_VERSION_1_0) +#ifndef PFN_vkImportSemaphoreFdKHR_PROXY +#define PFN_vkImportSemaphoreFdKHR_PROXY + VkResult importSemaphoreFdKHR(const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { + return fp_vkImportSemaphoreFdKHR(_device, pImportSemaphoreFdInfo); + } +#endif +#ifndef PFN_vkGetSemaphoreFdKHR_PROXY +#define PFN_vkGetSemaphoreFdKHR_PROXY + VkResult getSemaphoreFdKHR(const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) { + return fp_vkGetSemaphoreFdKHR(_device, pGetFdInfo, pFd); + } +#endif +#endif +#if defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdPushDescriptorSetKHR_PROXY +#define PFN_vkCmdPushDescriptorSetKHR_PROXY + void cmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { + fp_vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); + } +#endif +#ifndef PFN_vkCmdPushDescriptorSetWithTemplateKHR_PROXY +#define PFN_vkCmdPushDescriptorSetWithTemplateKHR_PROXY + void cmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { + fp_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + } +#endif +#endif +#if defined(VK_KHR_push_descriptor) && defined(VK_VERSION_1_1) +#ifndef PFN_vkCmdPushDescriptorSetWithTemplateKHR_PROXY +#define PFN_vkCmdPushDescriptorSetWithTemplateKHR_PROXY + void cmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { + fp_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + } +#endif +#endif +#if defined(VK_EXT_conditional_rendering) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdBeginConditionalRenderingEXT_PROXY +#define PFN_vkCmdBeginConditionalRenderingEXT_PROXY + void cmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { + fp_vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); + } +#endif +#ifndef PFN_vkCmdEndConditionalRenderingEXT_PROXY +#define PFN_vkCmdEndConditionalRenderingEXT_PROXY + void cmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) { + fp_vkCmdEndConditionalRenderingEXT(commandBuffer); + } +#endif +#endif +#if defined(VK_KHR_descriptor_update_template) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateDescriptorUpdateTemplateKHR_PROXY +#define PFN_vkCreateDescriptorUpdateTemplateKHR_PROXY + VkResult createDescriptorUpdateTemplateKHR(const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { + return fp_vkCreateDescriptorUpdateTemplateKHR(_device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + } +#endif +#ifndef PFN_vkDestroyDescriptorUpdateTemplateKHR_PROXY +#define PFN_vkDestroyDescriptorUpdateTemplateKHR_PROXY + void destroyDescriptorUpdateTemplateKHR(VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyDescriptorUpdateTemplateKHR(_device, descriptorUpdateTemplate, pAllocator); + } +#endif +#ifndef PFN_vkUpdateDescriptorSetWithTemplateKHR_PROXY +#define PFN_vkUpdateDescriptorSetWithTemplateKHR_PROXY + void updateDescriptorSetWithTemplateKHR(VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { + fp_vkUpdateDescriptorSetWithTemplateKHR(_device, descriptorSet, descriptorUpdateTemplate, pData); + } +#endif +#ifndef PFN_vkCmdPushDescriptorSetWithTemplateKHR_PROXY +#define PFN_vkCmdPushDescriptorSetWithTemplateKHR_PROXY + void cmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) { + fp_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + } +#endif +#endif +#if defined(VK_NV_clip_space_w_scaling) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetViewportWScalingNV_PROXY +#define PFN_vkCmdSetViewportWScalingNV_PROXY + void cmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) { + fp_vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); + } +#endif +#endif +#if defined(VK_EXT_display_control) && defined(VK_VERSION_1_0) +#ifndef PFN_vkDisplayPowerControlEXT_PROXY +#define PFN_vkDisplayPowerControlEXT_PROXY + VkResult displayPowerControlEXT(VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { + return fp_vkDisplayPowerControlEXT(_device, display, pDisplayPowerInfo); + } +#endif +#ifndef PFN_vkRegisterDeviceEventEXT_PROXY +#define PFN_vkRegisterDeviceEventEXT_PROXY + VkResult registerDeviceEventEXT(const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { + return fp_vkRegisterDeviceEventEXT(_device, pDeviceEventInfo, pAllocator, pFence); + } +#endif +#ifndef PFN_vkRegisterDisplayEventEXT_PROXY +#define PFN_vkRegisterDisplayEventEXT_PROXY + VkResult registerDisplayEventEXT(VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { + return fp_vkRegisterDisplayEventEXT(_device, display, pDisplayEventInfo, pAllocator, pFence); + } +#endif +#ifndef PFN_vkGetSwapchainCounterEXT_PROXY +#define PFN_vkGetSwapchainCounterEXT_PROXY + VkResult getSwapchainCounterEXT(VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) { + return fp_vkGetSwapchainCounterEXT(_device, swapchain, counter, pCounterValue); + } +#endif +#endif +#if defined(VK_GOOGLE_display_timing) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetRefreshCycleDurationGOOGLE_PROXY +#define PFN_vkGetRefreshCycleDurationGOOGLE_PROXY + VkResult getRefreshCycleDurationGOOGLE(VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { + return fp_vkGetRefreshCycleDurationGOOGLE(_device, swapchain, pDisplayTimingProperties); + } +#endif +#ifndef PFN_vkGetPastPresentationTimingGOOGLE_PROXY +#define PFN_vkGetPastPresentationTimingGOOGLE_PROXY + VkResult getPastPresentationTimingGOOGLE(VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) { + return fp_vkGetPastPresentationTimingGOOGLE(_device, swapchain, pPresentationTimingCount, pPresentationTimings); + } +#endif +#endif +#if defined(VK_EXT_discard_rectangles) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetDiscardRectangleEXT_PROXY +#define PFN_vkCmdSetDiscardRectangleEXT_PROXY + void cmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) { + fp_vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); + } +#endif +#endif +#if defined(VK_EXT_hdr_metadata) && defined(VK_VERSION_1_0) +#ifndef PFN_vkSetHdrMetadataEXT_PROXY +#define PFN_vkSetHdrMetadataEXT_PROXY + void setHdrMetadataEXT(uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) { + fp_vkSetHdrMetadataEXT(_device, swapchainCount, pSwapchains, pMetadata); + } +#endif +#endif +#if defined(VK_KHR_create_renderpass2) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateRenderPass2KHR_PROXY +#define PFN_vkCreateRenderPass2KHR_PROXY + VkResult createRenderPass2KHR(const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { + return fp_vkCreateRenderPass2KHR(_device, pCreateInfo, pAllocator, pRenderPass); + } +#endif +#ifndef PFN_vkCmdBeginRenderPass2KHR_PROXY +#define PFN_vkCmdBeginRenderPass2KHR_PROXY + void cmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { + fp_vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + } +#endif +#ifndef PFN_vkCmdNextSubpass2KHR_PROXY +#define PFN_vkCmdNextSubpass2KHR_PROXY + void cmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) { + fp_vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + } +#endif +#ifndef PFN_vkCmdEndRenderPass2KHR_PROXY +#define PFN_vkCmdEndRenderPass2KHR_PROXY + void cmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) { + fp_vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); + } +#endif +#endif +#if defined(VK_KHR_shared_presentable_image) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetSwapchainStatusKHR_PROXY +#define PFN_vkGetSwapchainStatusKHR_PROXY + VkResult getSwapchainStatusKHR(VkSwapchainKHR swapchain) { + return fp_vkGetSwapchainStatusKHR(_device, swapchain); + } +#endif +#endif +#if defined(VK_KHR_external_fence_win32) && defined(VK_VERSION_1_0) +#ifndef PFN_vkImportFenceWin32HandleKHR_PROXY +#define PFN_vkImportFenceWin32HandleKHR_PROXY + VkResult importFenceWin32HandleKHR(const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { + return fp_vkImportFenceWin32HandleKHR(_device, pImportFenceWin32HandleInfo); + } +#endif +#ifndef PFN_vkGetFenceWin32HandleKHR_PROXY +#define PFN_vkGetFenceWin32HandleKHR_PROXY + VkResult getFenceWin32HandleKHR(const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) { + return fp_vkGetFenceWin32HandleKHR(_device, pGetWin32HandleInfo, pHandle); + } +#endif +#endif +#if defined(VK_KHR_external_fence_fd) && defined(VK_VERSION_1_0) +#ifndef PFN_vkImportFenceFdKHR_PROXY +#define PFN_vkImportFenceFdKHR_PROXY + VkResult importFenceFdKHR(const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { + return fp_vkImportFenceFdKHR(_device, pImportFenceFdInfo); + } +#endif +#ifndef PFN_vkGetFenceFdKHR_PROXY +#define PFN_vkGetFenceFdKHR_PROXY + VkResult getFenceFdKHR(const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) { + return fp_vkGetFenceFdKHR(_device, pGetFdInfo, pFd); + } +#endif +#endif +#if defined(VK_KHR_performance_query) && defined(VK_VERSION_1_0) +#ifndef PFN_vkAcquireProfilingLockKHR_PROXY +#define PFN_vkAcquireProfilingLockKHR_PROXY + VkResult acquireProfilingLockKHR(const VkAcquireProfilingLockInfoKHR* pInfo) { + return fp_vkAcquireProfilingLockKHR(_device, pInfo); + } +#endif +#ifndef PFN_vkReleaseProfilingLockKHR_PROXY +#define PFN_vkReleaseProfilingLockKHR_PROXY + void releaseProfilingLockKHR() { + fp_vkReleaseProfilingLockKHR(_device); + } +#endif +#endif +#if defined(VK_EXT_debug_utils) && defined(VK_VERSION_1_0) +#ifndef PFN_vkSetDebugUtilsObjectNameEXT_PROXY +#define PFN_vkSetDebugUtilsObjectNameEXT_PROXY + VkResult setDebugUtilsObjectNameEXT(const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { + return fp_vkSetDebugUtilsObjectNameEXT(_device, pNameInfo); + } +#endif +#ifndef PFN_vkSetDebugUtilsObjectTagEXT_PROXY +#define PFN_vkSetDebugUtilsObjectTagEXT_PROXY + VkResult setDebugUtilsObjectTagEXT(const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { + return fp_vkSetDebugUtilsObjectTagEXT(_device, pTagInfo); + } +#endif +#ifndef PFN_vkQueueBeginDebugUtilsLabelEXT_PROXY +#define PFN_vkQueueBeginDebugUtilsLabelEXT_PROXY + void queueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { + fp_vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); + } +#endif +#ifndef PFN_vkQueueEndDebugUtilsLabelEXT_PROXY +#define PFN_vkQueueEndDebugUtilsLabelEXT_PROXY + void queueEndDebugUtilsLabelEXT(VkQueue queue) { + fp_vkQueueEndDebugUtilsLabelEXT(queue); + } +#endif +#ifndef PFN_vkQueueInsertDebugUtilsLabelEXT_PROXY +#define PFN_vkQueueInsertDebugUtilsLabelEXT_PROXY + void queueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) { + fp_vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); + } +#endif +#ifndef PFN_vkCmdBeginDebugUtilsLabelEXT_PROXY +#define PFN_vkCmdBeginDebugUtilsLabelEXT_PROXY + void cmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { + fp_vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); + } +#endif +#ifndef PFN_vkCmdEndDebugUtilsLabelEXT_PROXY +#define PFN_vkCmdEndDebugUtilsLabelEXT_PROXY + void cmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) { + fp_vkCmdEndDebugUtilsLabelEXT(commandBuffer); + } +#endif +#ifndef PFN_vkCmdInsertDebugUtilsLabelEXT_PROXY +#define PFN_vkCmdInsertDebugUtilsLabelEXT_PROXY + void cmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) { + fp_vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); + } +#endif +#endif +#if defined(VK_ANDROID_external_memory_android_hardware_buffer) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetAndroidHardwareBufferPropertiesANDROID_PROXY +#define PFN_vkGetAndroidHardwareBufferPropertiesANDROID_PROXY + VkResult getAndroidHardwareBufferPropertiesANDROID(AHardwareBuffer buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) { + return fp_vkGetAndroidHardwareBufferPropertiesANDROID(_device, buffer, pProperties); + } +#endif +#ifndef PFN_vkGetMemoryAndroidHardwareBufferANDROID_PROXY +#define PFN_vkGetMemoryAndroidHardwareBufferANDROID_PROXY + VkResult getMemoryAndroidHardwareBufferANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, AHardwareBuffer pBuffer) { + return fp_vkGetMemoryAndroidHardwareBufferANDROID(_device, pInfo, pBuffer); + } +#endif +#endif +#if defined(VK_EXT_sample_locations) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetSampleLocationsEXT_PROXY +#define PFN_vkCmdSetSampleLocationsEXT_PROXY + void cmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { + fp_vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); + } +#endif +#endif +#if defined(VK_KHR_get_memory_requirements2) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetImageMemoryRequirements2KHR_PROXY +#define PFN_vkGetImageMemoryRequirements2KHR_PROXY + void getImageMemoryRequirements2KHR(const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + fp_vkGetImageMemoryRequirements2KHR(_device, pInfo, pMemoryRequirements); + } +#endif +#ifndef PFN_vkGetBufferMemoryRequirements2KHR_PROXY +#define PFN_vkGetBufferMemoryRequirements2KHR_PROXY + void getBufferMemoryRequirements2KHR(const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + fp_vkGetBufferMemoryRequirements2KHR(_device, pInfo, pMemoryRequirements); + } +#endif +#ifndef PFN_vkGetImageSparseMemoryRequirements2KHR_PROXY +#define PFN_vkGetImageSparseMemoryRequirements2KHR_PROXY + void getImageSparseMemoryRequirements2KHR(const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + fp_vkGetImageSparseMemoryRequirements2KHR(_device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + } +#endif +#endif +#if defined(VK_KHR_acceleration_structure) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateAccelerationStructureKHR_PROXY +#define PFN_vkCreateAccelerationStructureKHR_PROXY + VkResult createAccelerationStructureKHR(const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) { + return fp_vkCreateAccelerationStructureKHR(_device, pCreateInfo, pAllocator, pAccelerationStructure); + } +#endif +#ifndef PFN_vkDestroyAccelerationStructureKHR_PROXY +#define PFN_vkDestroyAccelerationStructureKHR_PROXY + void destroyAccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyAccelerationStructureKHR(_device, accelerationStructure, pAllocator); + } +#endif +#ifndef PFN_vkCmdBuildAccelerationStructuresKHR_PROXY +#define PFN_vkCmdBuildAccelerationStructuresKHR_PROXY + void cmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + fp_vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); + } +#endif +#ifndef PFN_vkCmdBuildAccelerationStructuresIndirectKHR_PROXY +#define PFN_vkCmdBuildAccelerationStructuresIndirectKHR_PROXY + void cmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) { + fp_vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); + } +#endif +#ifndef PFN_vkBuildAccelerationStructuresKHR_PROXY +#define PFN_vkBuildAccelerationStructuresKHR_PROXY + VkResult buildAccelerationStructuresKHR(VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + return fp_vkBuildAccelerationStructuresKHR(_device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); + } +#endif +#ifndef PFN_vkCopyAccelerationStructureKHR_PROXY +#define PFN_vkCopyAccelerationStructureKHR_PROXY + VkResult copyAccelerationStructureKHR(VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) { + return fp_vkCopyAccelerationStructureKHR(_device, deferredOperation, pInfo); + } +#endif +#ifndef PFN_vkCopyAccelerationStructureToMemoryKHR_PROXY +#define PFN_vkCopyAccelerationStructureToMemoryKHR_PROXY + VkResult copyAccelerationStructureToMemoryKHR(VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + return fp_vkCopyAccelerationStructureToMemoryKHR(_device, deferredOperation, pInfo); + } +#endif +#ifndef PFN_vkCopyMemoryToAccelerationStructureKHR_PROXY +#define PFN_vkCopyMemoryToAccelerationStructureKHR_PROXY + VkResult copyMemoryToAccelerationStructureKHR(VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + return fp_vkCopyMemoryToAccelerationStructureKHR(_device, deferredOperation, pInfo); + } +#endif +#ifndef PFN_vkWriteAccelerationStructuresPropertiesKHR_PROXY +#define PFN_vkWriteAccelerationStructuresPropertiesKHR_PROXY + VkResult writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { + return fp_vkWriteAccelerationStructuresPropertiesKHR(_device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); + } +#endif +#ifndef PFN_vkCmdCopyAccelerationStructureKHR_PROXY +#define PFN_vkCmdCopyAccelerationStructureKHR_PROXY + void cmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) { + fp_vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo); + } +#endif +#ifndef PFN_vkCmdCopyAccelerationStructureToMemoryKHR_PROXY +#define PFN_vkCmdCopyAccelerationStructureToMemoryKHR_PROXY + void cmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + fp_vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); + } +#endif +#ifndef PFN_vkCmdCopyMemoryToAccelerationStructureKHR_PROXY +#define PFN_vkCmdCopyMemoryToAccelerationStructureKHR_PROXY + void cmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + fp_vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); + } +#endif +#ifndef PFN_vkGetAccelerationStructureDeviceAddressKHR_PROXY +#define PFN_vkGetAccelerationStructureDeviceAddressKHR_PROXY + VkDeviceAddress getAccelerationStructureDeviceAddressKHR(const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) { + return fp_vkGetAccelerationStructureDeviceAddressKHR(_device, pInfo); + } +#endif +#ifndef PFN_vkCmdWriteAccelerationStructuresPropertiesKHR_PROXY +#define PFN_vkCmdWriteAccelerationStructuresPropertiesKHR_PROXY + void cmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { + fp_vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + } +#endif +#ifndef PFN_vkGetDeviceAccelerationStructureCompatibilityKHR_PROXY +#define PFN_vkGetDeviceAccelerationStructureCompatibilityKHR_PROXY + void getDeviceAccelerationStructureCompatibilityKHR(const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) { + fp_vkGetDeviceAccelerationStructureCompatibilityKHR(_device, pVersionInfo, pCompatibility); + } +#endif +#ifndef PFN_vkGetAccelerationStructureBuildSizesKHR_PROXY +#define PFN_vkGetAccelerationStructureBuildSizesKHR_PROXY + void getAccelerationStructureBuildSizesKHR(VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + fp_vkGetAccelerationStructureBuildSizesKHR(_device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); + } +#endif +#endif +#if defined(VK_KHR_ray_tracing_pipeline) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdTraceRaysKHR_PROXY +#define PFN_vkCmdTraceRaysKHR_PROXY + void cmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) { + fp_vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); + } +#endif +#ifndef PFN_vkCreateRayTracingPipelinesKHR_PROXY +#define PFN_vkCreateRayTracingPipelinesKHR_PROXY + VkResult createRayTracingPipelinesKHR(VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + return fp_vkCreateRayTracingPipelinesKHR(_device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } +#endif +#ifndef PFN_vkGetRayTracingShaderGroupHandlesKHR_PROXY +#define PFN_vkGetRayTracingShaderGroupHandlesKHR_PROXY + VkResult getRayTracingShaderGroupHandlesKHR(VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { + return fp_vkGetRayTracingShaderGroupHandlesKHR(_device, pipeline, firstGroup, groupCount, dataSize, pData); + } +#endif +#ifndef PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_PROXY +#define PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_PROXY + VkResult getRayTracingCaptureReplayShaderGroupHandlesKHR(VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { + return fp_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(_device, pipeline, firstGroup, groupCount, dataSize, pData); + } +#endif +#ifndef PFN_vkCmdTraceRaysIndirectKHR_PROXY +#define PFN_vkCmdTraceRaysIndirectKHR_PROXY + void cmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) { + fp_vkCmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); + } +#endif +#ifndef PFN_vkGetRayTracingShaderGroupStackSizeKHR_PROXY +#define PFN_vkGetRayTracingShaderGroupStackSizeKHR_PROXY + VkDeviceSize getRayTracingShaderGroupStackSizeKHR(VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) { + return fp_vkGetRayTracingShaderGroupStackSizeKHR(_device, pipeline, group, groupShader); + } +#endif +#ifndef PFN_vkCmdSetRayTracingPipelineStackSizeKHR_PROXY +#define PFN_vkCmdSetRayTracingPipelineStackSizeKHR_PROXY + void cmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) { + fp_vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize); + } +#endif +#endif +#if defined(VK_KHR_sampler_ycbcr_conversion) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateSamplerYcbcrConversionKHR_PROXY +#define PFN_vkCreateSamplerYcbcrConversionKHR_PROXY + VkResult createSamplerYcbcrConversionKHR(const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { + return fp_vkCreateSamplerYcbcrConversionKHR(_device, pCreateInfo, pAllocator, pYcbcrConversion); + } +#endif +#ifndef PFN_vkDestroySamplerYcbcrConversionKHR_PROXY +#define PFN_vkDestroySamplerYcbcrConversionKHR_PROXY + void destroySamplerYcbcrConversionKHR(VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroySamplerYcbcrConversionKHR(_device, ycbcrConversion, pAllocator); + } +#endif +#endif +#if defined(VK_KHR_bind_memory2) && defined(VK_VERSION_1_0) +#ifndef PFN_vkBindBufferMemory2KHR_PROXY +#define PFN_vkBindBufferMemory2KHR_PROXY + VkResult bindBufferMemory2KHR(uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { + return fp_vkBindBufferMemory2KHR(_device, bindInfoCount, pBindInfos); + } +#endif +#ifndef PFN_vkBindImageMemory2KHR_PROXY +#define PFN_vkBindImageMemory2KHR_PROXY + VkResult bindImageMemory2KHR(uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { + return fp_vkBindImageMemory2KHR(_device, bindInfoCount, pBindInfos); + } +#endif +#endif +#if defined(VK_EXT_image_drm_format_modifier) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetImageDrmFormatModifierPropertiesEXT_PROXY +#define PFN_vkGetImageDrmFormatModifierPropertiesEXT_PROXY + VkResult getImageDrmFormatModifierPropertiesEXT(VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { + return fp_vkGetImageDrmFormatModifierPropertiesEXT(_device, image, pProperties); + } +#endif +#endif +#if defined(VK_EXT_validation_cache) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateValidationCacheEXT_PROXY +#define PFN_vkCreateValidationCacheEXT_PROXY + VkResult createValidationCacheEXT(const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) { + return fp_vkCreateValidationCacheEXT(_device, pCreateInfo, pAllocator, pValidationCache); + } +#endif +#ifndef PFN_vkDestroyValidationCacheEXT_PROXY +#define PFN_vkDestroyValidationCacheEXT_PROXY + void destroyValidationCacheEXT(VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyValidationCacheEXT(_device, validationCache, pAllocator); + } +#endif +#ifndef PFN_vkMergeValidationCachesEXT_PROXY +#define PFN_vkMergeValidationCachesEXT_PROXY + VkResult mergeValidationCachesEXT(VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) { + return fp_vkMergeValidationCachesEXT(_device, dstCache, srcCacheCount, pSrcCaches); + } +#endif +#ifndef PFN_vkGetValidationCacheDataEXT_PROXY +#define PFN_vkGetValidationCacheDataEXT_PROXY + VkResult getValidationCacheDataEXT(VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) { + return fp_vkGetValidationCacheDataEXT(_device, validationCache, pDataSize, pData); + } +#endif +#endif +#if defined(VK_NV_shading_rate_image) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdBindShadingRateImageNV_PROXY +#define PFN_vkCmdBindShadingRateImageNV_PROXY + void cmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) { + fp_vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); + } +#endif +#ifndef PFN_vkCmdSetViewportShadingRatePaletteNV_PROXY +#define PFN_vkCmdSetViewportShadingRatePaletteNV_PROXY + void cmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) { + fp_vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); + } +#endif +#ifndef PFN_vkCmdSetCoarseSampleOrderNV_PROXY +#define PFN_vkCmdSetCoarseSampleOrderNV_PROXY + void cmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) { + fp_vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); + } +#endif +#endif +#if defined(VK_NV_ray_tracing) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateAccelerationStructureNV_PROXY +#define PFN_vkCreateAccelerationStructureNV_PROXY + VkResult createAccelerationStructureNV(const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) { + return fp_vkCreateAccelerationStructureNV(_device, pCreateInfo, pAllocator, pAccelerationStructure); + } +#endif +#ifndef PFN_vkDestroyAccelerationStructureNV_PROXY +#define PFN_vkDestroyAccelerationStructureNV_PROXY + void destroyAccelerationStructureNV(VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyAccelerationStructureNV(_device, accelerationStructure, pAllocator); + } +#endif +#ifndef PFN_vkGetAccelerationStructureMemoryRequirementsNV_PROXY +#define PFN_vkGetAccelerationStructureMemoryRequirementsNV_PROXY + void getAccelerationStructureMemoryRequirementsNV(const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) { + fp_vkGetAccelerationStructureMemoryRequirementsNV(_device, pInfo, pMemoryRequirements); + } +#endif +#ifndef PFN_vkBindAccelerationStructureMemoryNV_PROXY +#define PFN_vkBindAccelerationStructureMemoryNV_PROXY + VkResult bindAccelerationStructureMemoryNV(uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) { + return fp_vkBindAccelerationStructureMemoryNV(_device, bindInfoCount, pBindInfos); + } +#endif +#ifndef PFN_vkCmdBuildAccelerationStructureNV_PROXY +#define PFN_vkCmdBuildAccelerationStructureNV_PROXY + void cmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) { + fp_vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); + } +#endif +#ifndef PFN_vkCmdCopyAccelerationStructureNV_PROXY +#define PFN_vkCmdCopyAccelerationStructureNV_PROXY + void cmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) { + fp_vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); + } +#endif +#ifndef PFN_vkCmdTraceRaysNV_PROXY +#define PFN_vkCmdTraceRaysNV_PROXY + void cmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) { + fp_vkCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); + } +#endif +#ifndef PFN_vkCreateRayTracingPipelinesNV_PROXY +#define PFN_vkCreateRayTracingPipelinesNV_PROXY + VkResult createRayTracingPipelinesNV(VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { + return fp_vkCreateRayTracingPipelinesNV(_device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } +#endif +#ifndef PFN_vkGetRayTracingShaderGroupHandlesNV_PROXY +#define PFN_vkGetRayTracingShaderGroupHandlesNV_PROXY + VkResult getRayTracingShaderGroupHandlesNV(VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) { + return fp_vkGetRayTracingShaderGroupHandlesNV(_device, pipeline, firstGroup, groupCount, dataSize, pData); + } +#endif +#ifndef PFN_vkGetAccelerationStructureHandleNV_PROXY +#define PFN_vkGetAccelerationStructureHandleNV_PROXY + VkResult getAccelerationStructureHandleNV(VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) { + return fp_vkGetAccelerationStructureHandleNV(_device, accelerationStructure, dataSize, pData); + } +#endif +#ifndef PFN_vkCmdWriteAccelerationStructuresPropertiesNV_PROXY +#define PFN_vkCmdWriteAccelerationStructuresPropertiesNV_PROXY + void cmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { + fp_vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + } +#endif +#ifndef PFN_vkCompileDeferredNV_PROXY +#define PFN_vkCompileDeferredNV_PROXY + VkResult compileDeferredNV(VkPipeline pipeline, uint32_t shader) { + return fp_vkCompileDeferredNV(_device, pipeline, shader); + } +#endif +#endif +#if defined(VK_KHR_maintenance3) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetDescriptorSetLayoutSupportKHR_PROXY +#define PFN_vkGetDescriptorSetLayoutSupportKHR_PROXY + void getDescriptorSetLayoutSupportKHR(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { + fp_vkGetDescriptorSetLayoutSupportKHR(_device, pCreateInfo, pSupport); + } +#endif +#endif +#if defined(VK_EXT_external_memory_host) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetMemoryHostPointerPropertiesEXT_PROXY +#define PFN_vkGetMemoryHostPointerPropertiesEXT_PROXY + VkResult getMemoryHostPointerPropertiesEXT(VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { + return fp_vkGetMemoryHostPointerPropertiesEXT(_device, handleType, pHostPointer, pMemoryHostPointerProperties); + } +#endif +#endif +#if defined(VK_AMD_buffer_marker) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdWriteBufferMarkerAMD_PROXY +#define PFN_vkCmdWriteBufferMarkerAMD_PROXY + void cmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { + fp_vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); + } +#endif +#endif +#if defined(VK_EXT_calibrated_timestamps) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetCalibratedTimestampsEXT_PROXY +#define PFN_vkGetCalibratedTimestampsEXT_PROXY + VkResult getCalibratedTimestampsEXT(uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { + return fp_vkGetCalibratedTimestampsEXT(_device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + } +#endif +#endif +#if defined(VK_NV_mesh_shader) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdDrawMeshTasksNV_PROXY +#define PFN_vkCmdDrawMeshTasksNV_PROXY + void cmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) { + fp_vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); + } +#endif +#ifndef PFN_vkCmdDrawMeshTasksIndirectNV_PROXY +#define PFN_vkCmdDrawMeshTasksIndirectNV_PROXY + void cmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { + fp_vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); + } +#endif +#ifndef PFN_vkCmdDrawMeshTasksIndirectCountNV_PROXY +#define PFN_vkCmdDrawMeshTasksIndirectCountNV_PROXY + void cmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) { + fp_vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + } +#endif +#endif +#if defined(VK_NV_scissor_exclusive) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetExclusiveScissorNV_PROXY +#define PFN_vkCmdSetExclusiveScissorNV_PROXY + void cmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) { + fp_vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); + } +#endif +#endif +#if defined(VK_NV_device_diagnostic_checkpoints) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetCheckpointNV_PROXY +#define PFN_vkCmdSetCheckpointNV_PROXY + void cmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) { + fp_vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker); + } +#endif +#ifndef PFN_vkGetQueueCheckpointDataNV_PROXY +#define PFN_vkGetQueueCheckpointDataNV_PROXY + void getQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) { + fp_vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); + } +#endif +#endif +#if defined(VK_KHR_timeline_semaphore) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetSemaphoreCounterValueKHR_PROXY +#define PFN_vkGetSemaphoreCounterValueKHR_PROXY + VkResult getSemaphoreCounterValueKHR(VkSemaphore semaphore, uint64_t* pValue) { + return fp_vkGetSemaphoreCounterValueKHR(_device, semaphore, pValue); + } +#endif +#ifndef PFN_vkWaitSemaphoresKHR_PROXY +#define PFN_vkWaitSemaphoresKHR_PROXY + VkResult waitSemaphoresKHR(const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { + return fp_vkWaitSemaphoresKHR(_device, pWaitInfo, timeout); + } +#endif +#ifndef PFN_vkSignalSemaphoreKHR_PROXY +#define PFN_vkSignalSemaphoreKHR_PROXY + VkResult signalSemaphoreKHR(const VkSemaphoreSignalInfo* pSignalInfo) { + return fp_vkSignalSemaphoreKHR(_device, pSignalInfo); + } +#endif +#endif +#if defined(VK_INTEL_performance_query) && defined(VK_VERSION_1_0) +#ifndef PFN_vkInitializePerformanceApiINTEL_PROXY +#define PFN_vkInitializePerformanceApiINTEL_PROXY + VkResult initializePerformanceApiINTEL(const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) { + return fp_vkInitializePerformanceApiINTEL(_device, pInitializeInfo); + } +#endif +#ifndef PFN_vkUninitializePerformanceApiINTEL_PROXY +#define PFN_vkUninitializePerformanceApiINTEL_PROXY + void uninitializePerformanceApiINTEL() { + fp_vkUninitializePerformanceApiINTEL(_device); + } +#endif +#ifndef PFN_vkCmdSetPerformanceMarkerINTEL_PROXY +#define PFN_vkCmdSetPerformanceMarkerINTEL_PROXY + VkResult cmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) { + return fp_vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); + } +#endif +#ifndef PFN_vkCmdSetPerformanceStreamMarkerINTEL_PROXY +#define PFN_vkCmdSetPerformanceStreamMarkerINTEL_PROXY + VkResult cmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) { + return fp_vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); + } +#endif +#ifndef PFN_vkCmdSetPerformanceOverrideINTEL_PROXY +#define PFN_vkCmdSetPerformanceOverrideINTEL_PROXY + VkResult cmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) { + return fp_vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); + } +#endif +#ifndef PFN_vkAcquirePerformanceConfigurationINTEL_PROXY +#define PFN_vkAcquirePerformanceConfigurationINTEL_PROXY + VkResult acquirePerformanceConfigurationINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) { + return fp_vkAcquirePerformanceConfigurationINTEL(_device, pAcquireInfo, pConfiguration); + } +#endif +#ifndef PFN_vkReleasePerformanceConfigurationINTEL_PROXY +#define PFN_vkReleasePerformanceConfigurationINTEL_PROXY + VkResult releasePerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL configuration) { + return fp_vkReleasePerformanceConfigurationINTEL(_device, configuration); + } +#endif +#ifndef PFN_vkQueueSetPerformanceConfigurationINTEL_PROXY +#define PFN_vkQueueSetPerformanceConfigurationINTEL_PROXY + VkResult queueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) { + return fp_vkQueueSetPerformanceConfigurationINTEL(queue, configuration); + } +#endif +#ifndef PFN_vkGetPerformanceParameterINTEL_PROXY +#define PFN_vkGetPerformanceParameterINTEL_PROXY + VkResult getPerformanceParameterINTEL(VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) { + return fp_vkGetPerformanceParameterINTEL(_device, parameter, pValue); + } +#endif +#endif +#if defined(VK_AMD_display_native_hdr) && defined(VK_VERSION_1_0) +#ifndef PFN_vkSetLocalDimmingAMD_PROXY +#define PFN_vkSetLocalDimmingAMD_PROXY + void setLocalDimmingAMD(VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) { + fp_vkSetLocalDimmingAMD(_device, swapChain, localDimmingEnable); + } +#endif +#endif +#if defined(VK_KHR_fragment_shading_rate) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetFragmentShadingRateKHR_PROXY +#define PFN_vkCmdSetFragmentShadingRateKHR_PROXY + void cmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { + fp_vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); + } +#endif +#endif +#if defined(VK_EXT_buffer_device_address) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetBufferDeviceAddressEXT_PROXY +#define PFN_vkGetBufferDeviceAddressEXT_PROXY + VkDeviceAddress getBufferDeviceAddressEXT(const VkBufferDeviceAddressInfo* pInfo) { + return fp_vkGetBufferDeviceAddressEXT(_device, pInfo); + } +#endif +#endif +#if defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_0) +#ifndef PFN_vkAcquireFullScreenExclusiveModeEXT_PROXY +#define PFN_vkAcquireFullScreenExclusiveModeEXT_PROXY + VkResult acquireFullScreenExclusiveModeEXT(VkSwapchainKHR swapchain) { + return fp_vkAcquireFullScreenExclusiveModeEXT(_device, swapchain); + } +#endif +#ifndef PFN_vkReleaseFullScreenExclusiveModeEXT_PROXY +#define PFN_vkReleaseFullScreenExclusiveModeEXT_PROXY + VkResult releaseFullScreenExclusiveModeEXT(VkSwapchainKHR swapchain) { + return fp_vkReleaseFullScreenExclusiveModeEXT(_device, swapchain); + } +#endif +#ifndef PFN_vkGetDeviceGroupSurfacePresentModes2EXT_PROXY +#define PFN_vkGetDeviceGroupSurfacePresentModes2EXT_PROXY + VkResult getDeviceGroupSurfacePresentModes2EXT(const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) { + return fp_vkGetDeviceGroupSurfacePresentModes2EXT(_device, pSurfaceInfo, pModes); + } +#endif +#endif +#if defined(VK_EXT_full_screen_exclusive) && defined(VK_VERSION_1_1) +#ifndef PFN_vkGetDeviceGroupSurfacePresentModes2EXT_PROXY +#define PFN_vkGetDeviceGroupSurfacePresentModes2EXT_PROXY + VkResult getDeviceGroupSurfacePresentModes2EXT(const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) { + return fp_vkGetDeviceGroupSurfacePresentModes2EXT(_device, pSurfaceInfo, pModes); + } +#endif +#endif +#if defined(VK_KHR_buffer_device_address) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetBufferOpaqueCaptureAddressKHR_PROXY +#define PFN_vkGetBufferOpaqueCaptureAddressKHR_PROXY + uint64_t getBufferOpaqueCaptureAddressKHR(const VkBufferDeviceAddressInfo* pInfo) { + return fp_vkGetBufferOpaqueCaptureAddressKHR(_device, pInfo); + } +#endif +#ifndef PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR_PROXY +#define PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR_PROXY + uint64_t getDeviceMemoryOpaqueCaptureAddressKHR(const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { + return fp_vkGetDeviceMemoryOpaqueCaptureAddressKHR(_device, pInfo); + } +#endif +#endif +#if defined(VK_EXT_line_rasterization) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetLineStippleEXT_PROXY +#define PFN_vkCmdSetLineStippleEXT_PROXY + void cmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) { + fp_vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); + } +#endif +#endif +#if defined(VK_EXT_host_query_reset) && defined(VK_VERSION_1_0) +#ifndef PFN_vkResetQueryPoolEXT_PROXY +#define PFN_vkResetQueryPoolEXT_PROXY + void resetQueryPoolEXT(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { + fp_vkResetQueryPoolEXT(_device, queryPool, firstQuery, queryCount); + } +#endif +#endif +#if defined(VK_EXT_extended_dynamic_state) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetCullModeEXT_PROXY +#define PFN_vkCmdSetCullModeEXT_PROXY + void cmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + fp_vkCmdSetCullModeEXT(commandBuffer, cullMode); + } +#endif +#ifndef PFN_vkCmdSetFrontFaceEXT_PROXY +#define PFN_vkCmdSetFrontFaceEXT_PROXY + void cmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + fp_vkCmdSetFrontFaceEXT(commandBuffer, frontFace); + } +#endif +#ifndef PFN_vkCmdSetPrimitiveTopologyEXT_PROXY +#define PFN_vkCmdSetPrimitiveTopologyEXT_PROXY + void cmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + fp_vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology); + } +#endif +#ifndef PFN_vkCmdSetViewportWithCountEXT_PROXY +#define PFN_vkCmdSetViewportWithCountEXT_PROXY + void cmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { + fp_vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports); + } +#endif +#ifndef PFN_vkCmdSetScissorWithCountEXT_PROXY +#define PFN_vkCmdSetScissorWithCountEXT_PROXY + void cmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { + fp_vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors); + } +#endif +#ifndef PFN_vkCmdBindVertexBuffers2EXT_PROXY +#define PFN_vkCmdBindVertexBuffers2EXT_PROXY + void cmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { + fp_vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); + } +#endif +#ifndef PFN_vkCmdSetDepthTestEnableEXT_PROXY +#define PFN_vkCmdSetDepthTestEnableEXT_PROXY + void cmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + fp_vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable); + } +#endif +#ifndef PFN_vkCmdSetDepthWriteEnableEXT_PROXY +#define PFN_vkCmdSetDepthWriteEnableEXT_PROXY + void cmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + fp_vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable); + } +#endif +#ifndef PFN_vkCmdSetDepthCompareOpEXT_PROXY +#define PFN_vkCmdSetDepthCompareOpEXT_PROXY + void cmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + fp_vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp); + } +#endif +#ifndef PFN_vkCmdSetDepthBoundsTestEnableEXT_PROXY +#define PFN_vkCmdSetDepthBoundsTestEnableEXT_PROXY + void cmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + fp_vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable); + } +#endif +#ifndef PFN_vkCmdSetStencilTestEnableEXT_PROXY +#define PFN_vkCmdSetStencilTestEnableEXT_PROXY + void cmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + fp_vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable); + } +#endif +#ifndef PFN_vkCmdSetStencilOpEXT_PROXY +#define PFN_vkCmdSetStencilOpEXT_PROXY + void cmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + fp_vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + } +#endif +#endif +#if defined(VK_KHR_deferred_host_operations) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateDeferredOperationKHR_PROXY +#define PFN_vkCreateDeferredOperationKHR_PROXY + VkResult createDeferredOperationKHR(const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) { + return fp_vkCreateDeferredOperationKHR(_device, pAllocator, pDeferredOperation); + } +#endif +#ifndef PFN_vkDestroyDeferredOperationKHR_PROXY +#define PFN_vkDestroyDeferredOperationKHR_PROXY + void destroyDeferredOperationKHR(VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyDeferredOperationKHR(_device, operation, pAllocator); + } +#endif +#ifndef PFN_vkGetDeferredOperationMaxConcurrencyKHR_PROXY +#define PFN_vkGetDeferredOperationMaxConcurrencyKHR_PROXY + uint32_t getDeferredOperationMaxConcurrencyKHR(VkDeferredOperationKHR operation) { + return fp_vkGetDeferredOperationMaxConcurrencyKHR(_device, operation); + } +#endif +#ifndef PFN_vkGetDeferredOperationResultKHR_PROXY +#define PFN_vkGetDeferredOperationResultKHR_PROXY + VkResult getDeferredOperationResultKHR(VkDeferredOperationKHR operation) { + return fp_vkGetDeferredOperationResultKHR(_device, operation); + } +#endif +#ifndef PFN_vkDeferredOperationJoinKHR_PROXY +#define PFN_vkDeferredOperationJoinKHR_PROXY + VkResult deferredOperationJoinKHR(VkDeferredOperationKHR operation) { + return fp_vkDeferredOperationJoinKHR(_device, operation); + } +#endif +#endif +#if defined(VK_KHR_pipeline_executable_properties) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetPipelineExecutablePropertiesKHR_PROXY +#define PFN_vkGetPipelineExecutablePropertiesKHR_PROXY + VkResult getPipelineExecutablePropertiesKHR(const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) { + return fp_vkGetPipelineExecutablePropertiesKHR(_device, pPipelineInfo, pExecutableCount, pProperties); + } +#endif +#ifndef PFN_vkGetPipelineExecutableStatisticsKHR_PROXY +#define PFN_vkGetPipelineExecutableStatisticsKHR_PROXY + VkResult getPipelineExecutableStatisticsKHR(const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) { + return fp_vkGetPipelineExecutableStatisticsKHR(_device, pExecutableInfo, pStatisticCount, pStatistics); + } +#endif +#ifndef PFN_vkGetPipelineExecutableInternalRepresentationsKHR_PROXY +#define PFN_vkGetPipelineExecutableInternalRepresentationsKHR_PROXY + VkResult getPipelineExecutableInternalRepresentationsKHR(const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) { + return fp_vkGetPipelineExecutableInternalRepresentationsKHR(_device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); + } +#endif +#endif +#if defined(VK_NV_device_generated_commands) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetGeneratedCommandsMemoryRequirementsNV_PROXY +#define PFN_vkGetGeneratedCommandsMemoryRequirementsNV_PROXY + void getGeneratedCommandsMemoryRequirementsNV(const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + fp_vkGetGeneratedCommandsMemoryRequirementsNV(_device, pInfo, pMemoryRequirements); + } +#endif +#ifndef PFN_vkCmdPreprocessGeneratedCommandsNV_PROXY +#define PFN_vkCmdPreprocessGeneratedCommandsNV_PROXY + void cmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { + fp_vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo); + } +#endif +#ifndef PFN_vkCmdExecuteGeneratedCommandsNV_PROXY +#define PFN_vkCmdExecuteGeneratedCommandsNV_PROXY + void cmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) { + fp_vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); + } +#endif +#ifndef PFN_vkCmdBindPipelineShaderGroupNV_PROXY +#define PFN_vkCmdBindPipelineShaderGroupNV_PROXY + void cmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) { + fp_vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex); + } +#endif +#ifndef PFN_vkCreateIndirectCommandsLayoutNV_PROXY +#define PFN_vkCreateIndirectCommandsLayoutNV_PROXY + VkResult createIndirectCommandsLayoutNV(const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) { + return fp_vkCreateIndirectCommandsLayoutNV(_device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + } +#endif +#ifndef PFN_vkDestroyIndirectCommandsLayoutNV_PROXY +#define PFN_vkDestroyIndirectCommandsLayoutNV_PROXY + void destroyIndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyIndirectCommandsLayoutNV(_device, indirectCommandsLayout, pAllocator); + } +#endif +#endif +#if defined(VK_EXT_private_data) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreatePrivateDataSlotEXT_PROXY +#define PFN_vkCreatePrivateDataSlotEXT_PROXY + VkResult createPrivateDataSlotEXT(const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot) { + return fp_vkCreatePrivateDataSlotEXT(_device, pCreateInfo, pAllocator, pPrivateDataSlot); + } +#endif +#ifndef PFN_vkDestroyPrivateDataSlotEXT_PROXY +#define PFN_vkDestroyPrivateDataSlotEXT_PROXY + void destroyPrivateDataSlotEXT(VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks* pAllocator) { + fp_vkDestroyPrivateDataSlotEXT(_device, privateDataSlot, pAllocator); + } +#endif +#ifndef PFN_vkSetPrivateDataEXT_PROXY +#define PFN_vkSetPrivateDataEXT_PROXY + VkResult setPrivateDataEXT(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data) { + return fp_vkSetPrivateDataEXT(_device, objectType, objectHandle, privateDataSlot, data); + } +#endif +#ifndef PFN_vkGetPrivateDataEXT_PROXY +#define PFN_vkGetPrivateDataEXT_PROXY + void getPrivateDataEXT(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData) { + fp_vkGetPrivateDataEXT(_device, objectType, objectHandle, privateDataSlot, pData); + } +#endif +#endif +#if defined(VK_KHR_video_encode_queue) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdEncodeVideoKHR_PROXY +#define PFN_vkCmdEncodeVideoKHR_PROXY + void cmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) { + fp_vkCmdEncodeVideoKHR(commandBuffer, pEncodeInfo); + } +#endif +#endif +#if defined(VK_KHR_synchronization2) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetEvent2KHR_PROXY +#define PFN_vkCmdSetEvent2KHR_PROXY + void cmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo) { + fp_vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo); + } +#endif +#ifndef PFN_vkCmdResetEvent2KHR_PROXY +#define PFN_vkCmdResetEvent2KHR_PROXY + void cmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask) { + fp_vkCmdResetEvent2KHR(commandBuffer, event, stageMask); + } +#endif +#ifndef PFN_vkCmdWaitEvents2KHR_PROXY +#define PFN_vkCmdWaitEvents2KHR_PROXY + void cmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfos) { + fp_vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos); + } +#endif +#ifndef PFN_vkCmdPipelineBarrier2KHR_PROXY +#define PFN_vkCmdPipelineBarrier2KHR_PROXY + void cmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo) { + fp_vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo); + } +#endif +#ifndef PFN_vkCmdWriteTimestamp2KHR_PROXY +#define PFN_vkCmdWriteTimestamp2KHR_PROXY + void cmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query) { + fp_vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query); + } +#endif +#ifndef PFN_vkQueueSubmit2KHR_PROXY +#define PFN_vkQueueSubmit2KHR_PROXY + VkResult queueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence) { + return fp_vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence); + } +#endif +#ifndef PFN_vkCmdWriteBufferMarker2AMD_PROXY +#define PFN_vkCmdWriteBufferMarker2AMD_PROXY + void cmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) { + fp_vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); + } +#endif +#ifndef PFN_vkGetQueueCheckpointData2NV_PROXY +#define PFN_vkGetQueueCheckpointData2NV_PROXY + void getQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) { + fp_vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData); + } +#endif +#endif +#if defined(VK_NV_fragment_shading_rate_enums) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetFragmentShadingRateEnumNV_PROXY +#define PFN_vkCmdSetFragmentShadingRateEnumNV_PROXY + void cmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { + fp_vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps); + } +#endif +#endif +#if defined(VK_KHR_copy_commands2) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdCopyBuffer2KHR_PROXY +#define PFN_vkCmdCopyBuffer2KHR_PROXY + void cmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo) { + fp_vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo); + } +#endif +#ifndef PFN_vkCmdCopyImage2KHR_PROXY +#define PFN_vkCmdCopyImage2KHR_PROXY + void cmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo) { + fp_vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo); + } +#endif +#ifndef PFN_vkCmdCopyBufferToImage2KHR_PROXY +#define PFN_vkCmdCopyBufferToImage2KHR_PROXY + void cmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) { + fp_vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo); + } +#endif +#ifndef PFN_vkCmdCopyImageToBuffer2KHR_PROXY +#define PFN_vkCmdCopyImageToBuffer2KHR_PROXY + void cmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) { + fp_vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo); + } +#endif +#ifndef PFN_vkCmdBlitImage2KHR_PROXY +#define PFN_vkCmdBlitImage2KHR_PROXY + void cmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo) { + fp_vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo); + } +#endif +#ifndef PFN_vkCmdResolveImage2KHR_PROXY +#define PFN_vkCmdResolveImage2KHR_PROXY + void cmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo) { + fp_vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo); + } +#endif +#endif +#if defined(VK_EXT_vertex_input_dynamic_state) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetVertexInputEXT_PROXY +#define PFN_vkCmdSetVertexInputEXT_PROXY + void cmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) { + fp_vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); + } +#endif +#endif +#if defined(VK_FUCHSIA_external_memory) && defined(VK_VERSION_1_0) +#ifndef PFN_vkGetMemoryZirconHandleFUCHSIA_PROXY +#define PFN_vkGetMemoryZirconHandleFUCHSIA_PROXY + VkResult getMemoryZirconHandleFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { + return fp_vkGetMemoryZirconHandleFUCHSIA(_device, pGetZirconHandleInfo, pZirconHandle); + } +#endif +#ifndef PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA_PROXY +#define PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA_PROXY + VkResult getMemoryZirconHandlePropertiesFUCHSIA(VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) { + return fp_vkGetMemoryZirconHandlePropertiesFUCHSIA(_device, handleType, zirconHandle, pMemoryZirconHandleProperties); + } +#endif +#endif +#if defined(VK_FUCHSIA_external_semaphore) && defined(VK_VERSION_1_0) +#ifndef PFN_vkImportSemaphoreZirconHandleFUCHSIA_PROXY +#define PFN_vkImportSemaphoreZirconHandleFUCHSIA_PROXY + VkResult importSemaphoreZirconHandleFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) { + return fp_vkImportSemaphoreZirconHandleFUCHSIA(_device, pImportSemaphoreZirconHandleInfo); + } +#endif +#ifndef PFN_vkGetSemaphoreZirconHandleFUCHSIA_PROXY +#define PFN_vkGetSemaphoreZirconHandleFUCHSIA_PROXY + VkResult getSemaphoreZirconHandleFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { + return fp_vkGetSemaphoreZirconHandleFUCHSIA(_device, pGetZirconHandleInfo, pZirconHandle); + } +#endif +#endif +#if defined(VK_EXT_extended_dynamic_state2) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetPatchControlPointsEXT_PROXY +#define PFN_vkCmdSetPatchControlPointsEXT_PROXY + void cmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) { + fp_vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); + } +#endif +#ifndef PFN_vkCmdSetRasterizerDiscardEnableEXT_PROXY +#define PFN_vkCmdSetRasterizerDiscardEnableEXT_PROXY + void cmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { + fp_vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable); + } +#endif +#ifndef PFN_vkCmdSetDepthBiasEnableEXT_PROXY +#define PFN_vkCmdSetDepthBiasEnableEXT_PROXY + void cmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + fp_vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable); + } +#endif +#ifndef PFN_vkCmdSetLogicOpEXT_PROXY +#define PFN_vkCmdSetLogicOpEXT_PROXY + void cmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) { + fp_vkCmdSetLogicOpEXT(commandBuffer, logicOp); + } +#endif +#ifndef PFN_vkCmdSetPrimitiveRestartEnableEXT_PROXY +#define PFN_vkCmdSetPrimitiveRestartEnableEXT_PROXY + void cmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + fp_vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); + } +#endif +#endif +#if defined(VK_EXT_color_write_enable) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdSetColorWriteEnableEXT_PROXY +#define PFN_vkCmdSetColorWriteEnableEXT_PROXY + void cmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) { + fp_vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); + } +#endif +#endif private: VkDevice _device = VK_NULL_HANDLE; @@ -2010,12 +3630,6 @@ private: PFN_vkCmdDecodeVideoKHR fp_vkCmdDecodeVideoKHR = nullptr; #endif #endif -#if defined(VK_KHR_video_encode_queue) && defined(VK_VERSION_1_0) -#ifndef PFN_vkCmdEncodeVideoKHR_DECLARE -#define PFN_vkCmdEncodeVideoKHR_DECLARE - PFN_vkCmdEncodeVideoKHR fp_vkCmdEncodeVideoKHR = nullptr; -#endif -#endif #if defined(VK_EXT_transform_feedback) && defined(VK_VERSION_1_0) #ifndef PFN_vkCmdBindTransformFeedbackBuffersEXT_DECLARE #define PFN_vkCmdBindTransformFeedbackBuffersEXT_DECLARE @@ -2042,6 +3656,28 @@ private: PFN_vkCmdDrawIndirectByteCountEXT fp_vkCmdDrawIndirectByteCountEXT = nullptr; #endif #endif +#if defined(VK_NVX_binary_import) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCreateCuModuleNVX_DECLARE +#define PFN_vkCreateCuModuleNVX_DECLARE + PFN_vkCreateCuModuleNVX fp_vkCreateCuModuleNVX = nullptr; +#endif +#ifndef PFN_vkCreateCuFunctionNVX_DECLARE +#define PFN_vkCreateCuFunctionNVX_DECLARE + PFN_vkCreateCuFunctionNVX fp_vkCreateCuFunctionNVX = nullptr; +#endif +#ifndef PFN_vkDestroyCuModuleNVX_DECLARE +#define PFN_vkDestroyCuModuleNVX_DECLARE + PFN_vkDestroyCuModuleNVX fp_vkDestroyCuModuleNVX = nullptr; +#endif +#ifndef PFN_vkDestroyCuFunctionNVX_DECLARE +#define PFN_vkDestroyCuFunctionNVX_DECLARE + PFN_vkDestroyCuFunctionNVX fp_vkDestroyCuFunctionNVX = nullptr; +#endif +#ifndef PFN_vkCmdCuLaunchKernelNVX_DECLARE +#define PFN_vkCmdCuLaunchKernelNVX_DECLARE + PFN_vkCmdCuLaunchKernelNVX fp_vkCmdCuLaunchKernelNVX = nullptr; +#endif +#endif #if defined(VK_NVX_image_view_handle) && defined(VK_VERSION_1_0) #ifndef PFN_vkGetImageViewHandleNVX_DECLARE #define PFN_vkGetImageViewHandleNVX_DECLARE @@ -2854,6 +4490,12 @@ private: PFN_vkGetPrivateDataEXT fp_vkGetPrivateDataEXT = nullptr; #endif #endif +#if defined(VK_KHR_video_encode_queue) && defined(VK_VERSION_1_0) +#ifndef PFN_vkCmdEncodeVideoKHR_DECLARE +#define PFN_vkCmdEncodeVideoKHR_DECLARE + PFN_vkCmdEncodeVideoKHR fp_vkCmdEncodeVideoKHR = nullptr; +#endif +#endif #if defined(VK_KHR_synchronization2) && defined(VK_VERSION_1_0) #ifndef PFN_vkCmdSetEvent2KHR_DECLARE #define PFN_vkCmdSetEvent2KHR_DECLARE