diff options
Diffstat (limited to 'layers/parameter_validation.cpp')
| -rw-r--r-- | layers/parameter_validation.cpp | 585 |
1 files changed, 356 insertions, 229 deletions
diff --git a/layers/parameter_validation.cpp b/layers/parameter_validation.cpp index c933a595..e5a12941 100644 --- a/layers/parameter_validation.cpp +++ b/layers/parameter_validation.cpp @@ -4665,6 +4665,115 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance, return result; } +// Definitions for the VK_KHR_descriptor_update_template extension + +VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device, + const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, + const VkAllocationCallbacks *pAllocator, + VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); + + skip |= parameter_validation_vkCreateDescriptorUpdateTemplateKHR(my_data, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + + if (!skip) { + result = + my_data->dispatch_table.CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + validate_result(my_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", {}, result); + } + + return result; +} + +VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const VkAllocationCallbacks *pAllocator) { + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); + + skip |= parameter_validation_vkDestroyDescriptorUpdateTemplateKHR(my_data, descriptorUpdateTemplate, pAllocator); + + if (!skip) { + my_data->dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); + } +} + +VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const void *pData) { + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); + + skip |= parameter_validation_vkUpdateDescriptorSetWithTemplateKHR(my_data, descriptorSet, descriptorUpdateTemplate, pData); + + if (!skip) { + my_data->dispatch_table.UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); + } +} + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + VkPipelineLayout layout, uint32_t set, const void *pData) { + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + assert(my_data != NULL); + + skip |= parameter_validation_vkCmdPushDescriptorSetWithTemplateKHR(my_data, descriptorUpdateTemplate, layout, set, pData); + + if (!skip) { + my_data->dispatch_table.CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + } +} + +VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { + bool skip = false; + layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + + skip = parameter_validation_vkGetSwapchainStatusKHR(dev_data, swapchain); + + if (!skip) { + result = dev_data->dispatch_table.GetSwapchainStatusKHR(device, swapchain); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, + VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { + bool skip = false; + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + + skip = parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2KHR(instance_data, pSurfaceInfo, pSurfaceCapabilities); + + if (!skip) { + result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, + pSurfaceCapabilities); + } + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, + uint32_t *pSurfaceFormatCount, + VkSurfaceFormat2KHR *pSurfaceFormats) { + bool skip = false; + instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + skip = parameter_validation_vkGetPhysicalDeviceSurfaceFormats2KHR(instance_data, pSurfaceInfo, pSurfaceFormatCount, + pSurfaceFormats); + if (!skip) { + result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, + pSurfaceFormatCount, pSurfaceFormats); + } + return result; +} + // Definitions for the VK_KHR_get_physical_device_properties2 extension VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures) { @@ -4794,493 +4903,511 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( } } -// Definitions for the VK_KHR_maintenance1 extension +// Definitions for the VK_KHR_external_fence_capabilities extension -VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) { +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR *pExternalFenceInfo, + VkExternalFencePropertiesKHR *pExternalFenceProperties) { + auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + bool skip = false; + skip |= + parameter_validation_vkGetPhysicalDeviceExternalFencePropertiesKHR(my_data, pExternalFenceInfo, pExternalFenceProperties); + if (!skip) { + my_data->dispatch_table.GetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, + pExternalFenceProperties); + } +} + +// Definitions for the VK_KHR_external_fence_fd extension + +VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkTrimCommandPoolKHR(my_data, commandPool, flags); + skip |= parameter_validation_vkImportFenceFdKHR(my_data, pImportFenceFdInfo); if (!skip) { - my_data->dispatch_table.TrimCommandPoolKHR(device, commandPool, flags); + result = my_data->dispatch_table.ImportFenceFdKHR(device, pImportFenceFdInfo); + validate_result(my_data->report_data, "vkImportFenceFdKHR", {}, result); } -} -// Definitions for the VK_KHR_push_descriptor extension + return result; +} -VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, - const VkWriteDescriptorSet *pDescriptorWrites) { +VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdPushDescriptorSetKHR(my_data, pipelineBindPoint, layout, set, - descriptorWriteCount, pDescriptorWrites); + skip |= parameter_validation_vkGetFenceFdKHR(my_data, pGetFdInfo, pFd); if (!skip) { - my_data->dispatch_table.CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, - pDescriptorWrites); + result = my_data->dispatch_table.GetFenceFdKHR(device, pGetFdInfo, pFd); + validate_result(my_data->report_data, "vkGetFenceFdKHR", {}, result); } + + return result; } -// Definitions for the VK_KHR_descriptor_update_template extension +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Definitions for the VK_KHR_external_fence_win32 extension -VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device, - const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) { +VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(VkDevice device, + const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateDescriptorUpdateTemplateKHR(my_data, pCreateInfo, pAllocator, - pDescriptorUpdateTemplate); + skip |= parameter_validation_vkImportFenceWin32HandleKHR(my_data, pImportFenceWin32HandleInfo); if (!skip) { - result = - my_data->dispatch_table.CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); - validate_result(my_data->report_data, "vkCreateDescriptorUpdateTemplateKHR", {}, result); + result = my_data->dispatch_table.ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); + validate_result(my_data->report_data, "vkImportFenceWin32HandleKHR", {}, result); } return result; } -VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const VkAllocationCallbacks *pAllocator) { +VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, + HANDLE *pHandle) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyDescriptorUpdateTemplateKHR(my_data, descriptorUpdateTemplate, pAllocator); + skip |= parameter_validation_vkGetFenceWin32HandleKHR(my_data, pGetWin32HandleInfo, pHandle); if (!skip) { - my_data->dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); + result = my_data->dispatch_table.GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + validate_result(my_data->report_data, "vkGetFenceWin32HandleKHR", {}, result); } + + return result; } +#endif // VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - const void *pData) { +// Definitions for the VK_KHR_external_memory_capabilities extension + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo, + VkExternalBufferPropertiesKHR *pExternalBufferProperties) { + auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); + bool skip = false; + skip |= parameter_validation_vkGetPhysicalDeviceExternalBufferPropertiesKHR(my_data, pExternalBufferInfo, + pExternalBufferProperties); + if (!skip) { + my_data->dispatch_table.GetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, + pExternalBufferProperties); + } +} + +// Definitions for the VK_KHR_external_memory_fd extension + +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int *pFd) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkUpdateDescriptorSetWithTemplateKHR(my_data, descriptorSet, descriptorUpdateTemplate, - pData); + skip |= parameter_validation_vkGetMemoryFdKHR(my_data, pGetFdInfo, pFd); if (!skip) { - my_data->dispatch_table.UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); + result = my_data->dispatch_table.GetMemoryFdKHR(device, pGetFdInfo, pFd); + validate_result(my_data->report_data, "vkGetMemoryFdKHR", {}, result); } + + return result; } -VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, - VkPipelineLayout layout, uint32_t set, const void *pData) { +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, + VkMemoryFdPropertiesKHR *pMemoryFdProperties) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdPushDescriptorSetWithTemplateKHR(my_data, descriptorUpdateTemplate, layout, set, - pData); + skip |= parameter_validation_vkGetMemoryFdPropertiesKHR(my_data, handleType, fd, pMemoryFdProperties); if (!skip) { - my_data->dispatch_table.CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + result = my_data->dispatch_table.GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); + validate_result(my_data->report_data, "vkGetMemoryFdPropertiesKHR", {}, result); } + + return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) { - bool skip = false; - layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); +// Definitions for the VK_KHR_external_memory_win32 extension + +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, + HANDLE *pHandle) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); - skip = parameter_validation_vkGetSwapchainStatusKHR(dev_data, swapchain); + skip |= parameter_validation_vkGetMemoryWin32HandleKHR(my_data, pGetWin32HandleInfo, pHandle); if (!skip) { - result = dev_data->dispatch_table.GetSwapchainStatusKHR(device, swapchain); + result = my_data->dispatch_table.GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + validate_result(my_data->report_data, "vkGetMemoryWin32HandleKHR", {}, result); } return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, - VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { - bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + bool skip = false; + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); - skip = parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2KHR(instance_data, pSurfaceInfo, - pSurfaceCapabilities); + skip |= parameter_validation_vkGetMemoryWin32HandlePropertiesKHR(my_data, handleType, handle, pMemoryWin32HandleProperties); if (!skip) { - result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, - pSurfaceCapabilities); + result = + my_data->dispatch_table.GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); + validate_result(my_data->report_data, "vkGetMemoryWin32HandlePropertiesKHR", {}, result); } return result; } +#endif // VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, - uint32_t *pSurfaceFormatCount, - VkSurfaceFormat2KHR *pSurfaceFormats) { +// Definitions for the VK_KHR_external_semaphore_capabilities extension + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR *pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR *pExternalSemaphoreProperties) { + auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + assert(my_data != NULL); bool skip = false; - instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - skip = parameter_validation_vkGetPhysicalDeviceSurfaceFormats2KHR(instance_data, pSurfaceInfo, pSurfaceFormatCount, - pSurfaceFormats); + skip |= parameter_validation_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(my_data, pExternalSemaphoreInfo, + pExternalSemaphoreProperties); if (!skip) { - result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, - pSurfaceFormatCount, pSurfaceFormats); + my_data->dispatch_table.GetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, + pExternalSemaphoreProperties); } - return result; } -// Definitions for the VK_KHX_device_group_creation extension +// Definitions for the VK_KHR_external_semaphore_fd extension -VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX( - VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) { +VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkEnumeratePhysicalDeviceGroupsKHX(my_data, pPhysicalDeviceGroupCount, - pPhysicalDeviceGroupProperties); + skip |= parameter_validation_vkImportSemaphoreFdKHR(my_data, pImportSemaphoreFdInfo); if (!skip) { - result = my_data->dispatch_table.EnumeratePhysicalDeviceGroupsKHX(instance, pPhysicalDeviceGroupCount, - pPhysicalDeviceGroupProperties); - validate_result(my_data->report_data, "vkEnumeratePhysicalDeviceGroupsKHX", {}, result); + result = my_data->dispatch_table.ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); + validate_result(my_data->report_data, "vkImportSemaphoreFdKHR", {}, result); } + return result; } -// Definitions for the VK_KHX_device_group extension - -VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlagsKHX *pPeerMemoryFeatures) { +VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int *pFd) { + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetDeviceGroupPeerMemoryFeaturesKHX(my_data, heapIndex, localDeviceIndex, - remoteDeviceIndex, pPeerMemoryFeatures); + skip |= parameter_validation_vkGetSemaphoreFdKHR(my_data, pGetFdInfo, pFd); if (!skip) { - my_data->dispatch_table.GetDeviceGroupPeerMemoryFeaturesKHX(device, heapIndex, localDeviceIndex, remoteDeviceIndex, - pPeerMemoryFeatures); + result = my_data->dispatch_table.GetSemaphoreFdKHR(device, pGetFdInfo, pFd); + validate_result(my_data->report_data, "vkGetSemaphoreFdKHR", {}, result); } + + return result; } -VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(VkDevice device, uint32_t bindInfoCount, - const VkBindBufferMemoryInfoKHX *pBindInfos) { +// Definitions for the VK_KHR_external_semaphore_win32 extension + +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL +ImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkBindBufferMemory2KHX(my_data, bindInfoCount, pBindInfos); - + skip |= parameter_validation_vkImportSemaphoreWin32HandleKHR(my_data, pImportSemaphoreWin32HandleInfo); if (!skip) { - result = my_data->dispatch_table.BindBufferMemory2KHX(device, bindInfoCount, pBindInfos); - validate_result(my_data->report_data, "vkBindBufferMemory2KHX", {}, result); + result = my_data->dispatch_table.ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); + validate_result(my_data->report_data, "vkImportSemaphoreWin32HandleKHR", {}, result); } - return result; } -VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(VkDevice device, uint32_t bindInfoCount, - const VkBindImageMemoryInfoKHX *pBindInfos) { +VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, + HANDLE *pHandle) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkBindImageMemory2KHX(my_data, bindInfoCount, pBindInfos); - + skip |= parameter_validation_vkGetSemaphoreWin32HandleKHR(my_data, pGetWin32HandleInfo, pHandle); if (!skip) { - result = my_data->dispatch_table.BindImageMemory2KHX(device, bindInfoCount, pBindInfos); - validate_result(my_data->report_data, "vkBindImageMemory2KHX", {}, result); + result = my_data->dispatch_table.GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + validate_result(my_data->report_data, "vkGetSemaphoreWin32HandleKHR", {}, result); } - return result; } +#endif // VK_USE_PLATFORM_WIN32_KHR -VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(VkCommandBuffer commandBuffer, uint32_t deviceMask) { +// Definitions for the VK_KHR_get_memory_requirements2 extension + +VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2KHR *pInfo, + VkMemoryRequirements2KHR *pMemoryRequirements) { bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdSetDeviceMaskKHX(my_data, deviceMask); + skip |= parameter_validation_vkGetImageMemoryRequirements2KHR(my_data, pInfo, pMemoryRequirements); if (!skip) { - my_data->dispatch_table.CmdSetDeviceMaskKHX(commandBuffer, deviceMask); + my_data->dispatch_table.GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } } -VKAPI_ATTR VkResult VKAPI_CALL -GetDeviceGroupPresentCapabilitiesKHX(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX *pDeviceGroupPresentCapabilities) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR *pInfo, + VkMemoryRequirements2KHR *pMemoryRequirements) { bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetDeviceGroupPresentCapabilitiesKHX(my_data, pDeviceGroupPresentCapabilities); + skip |= parameter_validation_vkGetBufferMemoryRequirements2KHR(my_data, pInfo, pMemoryRequirements); if (!skip) { - result = my_data->dispatch_table.GetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities); - validate_result(my_data->report_data, "vkGetDeviceGroupPresentCapabilitiesKHX", {}, result); + my_data->dispatch_table.GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } - - return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(VkDevice device, VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHX *pModes) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(VkDevice device, + const VkImageSparseMemoryRequirementsInfo2KHR *pInfo, + uint32_t *pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR *pSparseMemoryRequirements) { bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetDeviceGroupSurfacePresentModesKHX(my_data, surface, pModes); + skip |= parameter_validation_vkGetImageSparseMemoryRequirements2KHR(my_data, pInfo, pSparseMemoryRequirementCount, + pSparseMemoryRequirements); if (!skip) { - result = my_data->dispatch_table.GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes); - validate_result(my_data->report_data, "vkGetDeviceGroupSurfacePresentModesKHX", {}, result); + my_data->dispatch_table.GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, + pSparseMemoryRequirements); } - return result; } -VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(VkDevice device, const VkAcquireNextImageInfoKHX *pAcquireInfo, - uint32_t *pImageIndex) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +// Definitions for the VK_KHR_maintenance1 extension + +VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) { bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkAcquireNextImage2KHX(my_data, pAcquireInfo, pImageIndex); + skip |= parameter_validation_vkTrimCommandPoolKHR(my_data, commandPool, flags); if (!skip) { - result = my_data->dispatch_table.AcquireNextImage2KHX(device, pAcquireInfo, pImageIndex); - validate_result(my_data->report_data, "vkAcquireNextImage2KHX", {}, result); + my_data->dispatch_table.TrimCommandPoolKHR(device, commandPool, flags); } - return result; } -VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, - uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, - uint32_t groupCountZ) { +// Definitions for the VK_KHR_push_descriptor extension + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, + const VkWriteDescriptorSet *pDescriptorWrites) { bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdDispatchBaseKHX(my_data, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, - groupCountZ); + skip |= parameter_validation_vkCmdPushDescriptorSetKHR(my_data, pipelineBindPoint, layout, set, descriptorWriteCount, + pDescriptorWrites); if (!skip) { - my_data->dispatch_table.CmdDispatchBaseKHX(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, - groupCountZ); + my_data->dispatch_table.CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, + pDescriptorWrites); } } -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, - uint32_t *pRectCount, VkRect2D *pRects) { +// Definitions for the VK_KHX_device_group_creation extension + +VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX( + VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDevicePresentRectanglesKHX(my_data, surface, pRectCount, pRects); + skip |= parameter_validation_vkEnumeratePhysicalDeviceGroupsKHX(my_data, pPhysicalDeviceGroupCount, + pPhysicalDeviceGroupProperties); if (!skip) { - result = my_data->dispatch_table.GetPhysicalDevicePresentRectanglesKHX(physicalDevice, surface, pRectCount, pRects); - - validate_result(my_data->report_data, "vkGetPhysicalDevicePresentRectanglesKHX", {}, result); + result = my_data->dispatch_table.EnumeratePhysicalDeviceGroupsKHX(instance, pPhysicalDeviceGroupCount, + pPhysicalDeviceGroupProperties); + validate_result(my_data->report_data, "vkEnumeratePhysicalDeviceGroupsKHX", {}, result); } - return result; } -// Definitions for the VK_KHX_external_memory_capabilities extension +// Definitions for the VK_KHX_device_group extension -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHX( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX *pExternalBufferInfo, - VkExternalBufferPropertiesKHX *pExternalBufferProperties) { - auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - assert(my_data != NULL); +VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlagsKHX *pPeerMemoryFeatures) { bool skip = false; - skip |= parameter_validation_vkGetPhysicalDeviceExternalBufferPropertiesKHX(my_data, pExternalBufferInfo, - pExternalBufferProperties); + auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + assert(my_data != NULL); + + skip |= parameter_validation_vkGetDeviceGroupPeerMemoryFeaturesKHX(my_data, heapIndex, localDeviceIndex, + remoteDeviceIndex, pPeerMemoryFeatures); + if (!skip) { - my_data->dispatch_table.GetPhysicalDeviceExternalBufferPropertiesKHX(physicalDevice, pExternalBufferInfo, - pExternalBufferProperties); + my_data->dispatch_table.GetDeviceGroupPeerMemoryFeaturesKHX(device, heapIndex, localDeviceIndex, remoteDeviceIndex, + pPeerMemoryFeatures); } } -// Definitions for the VK_KHX_external_memory_fd extension - -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHX(VkDevice device, VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, int *pFd) { +VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(VkDevice device, uint32_t bindInfoCount, + const VkBindBufferMemoryInfoKHX *pBindInfos) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetMemoryFdKHX(my_data, memory, handleType, pFd); + skip |= parameter_validation_vkBindBufferMemory2KHX(my_data, bindInfoCount, pBindInfos); if (!skip) { - result = my_data->dispatch_table.GetMemoryFdKHX(device, memory, handleType, pFd); - validate_result(my_data->report_data, "vkGetMemoryFdKHX", {}, result); + result = my_data->dispatch_table.BindBufferMemory2KHX(device, bindInfoCount, pBindInfos); + validate_result(my_data->report_data, "vkBindBufferMemory2KHX", {}, result); } return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHX(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, - VkMemoryFdPropertiesKHX *pMemoryFdProperties) { +VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(VkDevice device, uint32_t bindInfoCount, + const VkBindImageMemoryInfoKHX *pBindInfos) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetMemoryFdPropertiesKHX(my_data, handleType, fd, pMemoryFdProperties); + skip |= parameter_validation_vkBindImageMemory2KHX(my_data, bindInfoCount, pBindInfos); if (!skip) { - result = my_data->dispatch_table.GetMemoryFdPropertiesKHX(device, handleType, fd, pMemoryFdProperties); - validate_result(my_data->report_data, "vkGetMemoryFdPropertiesKHX", {}, result); + result = my_data->dispatch_table.BindImageMemory2KHX(device, bindInfoCount, pBindInfos); + validate_result(my_data->report_data, "vkBindImageMemory2KHX", {}, result); } return result; } -// Definitions for the VK_KHX_external_memory_win32 extension - -#ifdef VK_USE_PLATFORM_WIN32_KHX -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHX(VkDevice device, VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE *pHandle) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(VkCommandBuffer commandBuffer, uint32_t deviceMask) { bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetMemoryWin32HandleKHX(my_data, memory, handleType, pHandle); + skip |= parameter_validation_vkCmdSetDeviceMaskKHX(my_data, deviceMask); if (!skip) { - result = my_data->dispatch_table.GetMemoryWin32HandleKHX(device, memory, handleType, pHandle); - validate_result(my_data->report_data, "vkGetMemoryWin32HandleKHX", {}, result); + my_data->dispatch_table.CmdSetDeviceMaskKHX(commandBuffer, deviceMask); } - return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHX(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHX *pMemoryWin32HandleProperties) { +VKAPI_ATTR VkResult VKAPI_CALL +GetDeviceGroupPresentCapabilitiesKHX(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX *pDeviceGroupPresentCapabilities) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetMemoryWin32HandlePropertiesKHX(my_data, handleType, handle, - pMemoryWin32HandleProperties); + skip |= parameter_validation_vkGetDeviceGroupPresentCapabilitiesKHX(my_data, pDeviceGroupPresentCapabilities); if (!skip) { - result = - my_data->dispatch_table.GetMemoryWin32HandlePropertiesKHX(device, handleType, handle, pMemoryWin32HandleProperties); - validate_result(my_data->report_data, "vkGetMemoryWin32HandlePropertiesKHX", {}, result); + result = my_data->dispatch_table.GetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities); + validate_result(my_data->report_data, "vkGetDeviceGroupPresentCapabilitiesKHX", {}, result); } - return result; -} -#endif // VK_USE_PLATFORM_WIN32_KHX - -// Definitions for the VK_KHX_external_semaphore_capabilities extension -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHX( - VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX *pExternalSemaphoreInfo, - VkExternalSemaphorePropertiesKHX *pExternalSemaphoreProperties) { - auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - assert(my_data != NULL); - bool skip = false; - skip |= parameter_validation_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(my_data, pExternalSemaphoreInfo, - pExternalSemaphoreProperties); - if (!skip) { - my_data->dispatch_table.GetPhysicalDeviceExternalSemaphorePropertiesKHX(physicalDevice, pExternalSemaphoreInfo, - pExternalSemaphoreProperties); - } + return result; } -// Definitions for the VK_KHX_external_semaphore_fd extension - -VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHX(VkDevice device, const VkImportSemaphoreFdInfoKHX *pImportSemaphoreFdInfo) { +VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(VkDevice device, VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHX *pModes) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkImportSemaphoreFdKHX(my_data, pImportSemaphoreFdInfo); + skip |= parameter_validation_vkGetDeviceGroupSurfacePresentModesKHX(my_data, surface, pModes); if (!skip) { - result = my_data->dispatch_table.ImportSemaphoreFdKHX(device, pImportSemaphoreFdInfo); - validate_result(my_data->report_data, "vkImportSemaphoreFdKHX", {}, result); + result = my_data->dispatch_table.GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes); + validate_result(my_data->report_data, "vkGetDeviceGroupSurfacePresentModesKHX", {}, result); } - return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHX(VkDevice device, VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int *pFd) { +VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(VkDevice device, const VkAcquireNextImageInfoKHX *pAcquireInfo, + uint32_t *pImageIndex) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetSemaphoreFdKHX(my_data, semaphore, handleType, pFd); + skip |= parameter_validation_vkAcquireNextImage2KHX(my_data, pAcquireInfo, pImageIndex); if (!skip) { - result = my_data->dispatch_table.GetSemaphoreFdKHX(device, semaphore, handleType, pFd); - validate_result(my_data->report_data, "vkGetSemaphoreFdKHX", {}, result); + result = my_data->dispatch_table.AcquireNextImage2KHX(device, pAcquireInfo, pImageIndex); + validate_result(my_data->report_data, "vkAcquireNextImage2KHX", {}, result); } - return result; } -// Definitions for the VK_KHX_external_semaphore_win32 extension - -#ifdef VK_USE_PLATFORM_WIN32_KHX -VKAPI_ATTR VkResult VKAPI_CALL -ImportSemaphoreWin32HandleKHX(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX *pImportSemaphoreWin32HandleInfo) { - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, + uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, + uint32_t groupCountZ) { bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkImportSemaphoreWin32HandleKHX(my_data, pImportSemaphoreWin32HandleInfo); + skip |= parameter_validation_vkCmdDispatchBaseKHX(my_data, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, + groupCountZ); + if (!skip) { - result = my_data->dispatch_table.ImportSemaphoreWin32HandleKHX(device, pImportSemaphoreWin32HandleInfo); - validate_result(my_data->report_data, "vkImportSemaphoreWin32HandleKHX", {}, result); + my_data->dispatch_table.CmdDispatchBaseKHX(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, + groupCountZ); } - return result; } -VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHX(VkDevice device, VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE *pHandle) { +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t *pRectCount, VkRect2D *pRects) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); + auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetSemaphoreWin32HandleKHX(my_data, semaphore, handleType, pHandle); + skip |= parameter_validation_vkGetPhysicalDevicePresentRectanglesKHX(my_data, surface, pRectCount, pRects); + if (!skip) { - result = my_data->dispatch_table.GetSemaphoreWin32HandleKHX(device, semaphore, handleType, pHandle); - validate_result(my_data->report_data, "vkGetSemaphoreWin32HandleKHX", {}, result); + result = my_data->dispatch_table.GetPhysicalDevicePresentRectanglesKHX(physicalDevice, surface, pRectCount, pRects); + + validate_result(my_data->report_data, "vkGetPhysicalDevicePresentRectanglesKHX", {}, result); } + return result; } -#endif // VK_USE_PLATFORM_WIN32_KHX // Definitions for the VK_EXT_acquire_xlib_display extension |