| // *** THIS FILE IS GENERATED - DO NOT EDIT *** |
| // See object_tracker_generator.py for modifications |
| |
| |
| /*************************************************************************** |
| * |
| * Copyright (c) 2015-2017 The Khronos Group Inc. |
| * Copyright (c) 2015-2017 Valve Corporation |
| * Copyright (c) 2015-2017 LunarG, Inc. |
| * Copyright (c) 2015-2017 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| * Author: Mark Lobodzinski <mark@lunarg.com> |
| * |
| ****************************************************************************/ |
| |
| |
| #include "object_tracker.h" |
| |
| namespace object_tracker { |
| |
| |
| // ObjectTracker undestroyed objects validation function |
| void ReportUndestroyedObjects(VkDevice device, enum UNIQUE_VALIDATION_ERROR_CODE error_code) { |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeCommandBuffer, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSemaphore, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFence, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDeviceMemory, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBuffer, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImage, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeEvent, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeQueryPool, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBufferView, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeImageView, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeShaderModule, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineCache, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipelineLayout, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeRenderPass, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypePipeline, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSetLayout, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSampler, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorPool, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorSet, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeFramebuffer, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeCommandPool, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSamplerYcbcrConversion, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDescriptorUpdateTemplate, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSurfaceKHR, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeSwapchainKHR, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayKHR, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDisplayModeKHR, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDebugReportCallbackEXT, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeObjectTableNVX, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeIndirectCommandsLayoutNVX, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeDebugUtilsMessengerEXT, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeValidationCacheEXT, error_code); |
| DeviceReportUndestroyedObjects(device, kVulkanObjectTypeBufferCollectionFUCHSIA, error_code); |
| } |
| |
| void DestroyUndestroyedObjects(VkDevice device) { |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeCommandBuffer); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeSemaphore); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeFence); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDeviceMemory); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeBuffer); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeImage); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeEvent); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeQueryPool); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeBufferView); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeImageView); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeShaderModule); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypePipelineCache); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypePipelineLayout); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeRenderPass); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypePipeline); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDescriptorSetLayout); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeSampler); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDescriptorPool); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDescriptorSet); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeFramebuffer); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeCommandPool); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeSamplerYcbcrConversion); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDescriptorUpdateTemplate); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeSurfaceKHR); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeSwapchainKHR); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDisplayKHR); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDisplayModeKHR); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDebugReportCallbackEXT); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeObjectTableNVX); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeIndirectCommandsLayoutNVX); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeDebugUtilsMessengerEXT); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeValidationCacheEXT); |
| DeviceDestroyUndestroyedObjects(device, kVulkanObjectTypeBufferCollectionFUCHSIA); |
| } |
| |
| |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( |
| const VkInstanceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkInstance* pInstance); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL DestroyInstance( |
| VkInstance instance, |
| const VkAllocationCallbacks* pAllocator); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceCount, |
| VkPhysicalDevice* pPhysicalDevices); |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures* pFeatures) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2c027a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties( |
| VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkFormatProperties* pFormatProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2c427a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties( |
| VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkImageType type, |
| VkImageTiling tiling, |
| VkImageUsageFlags usage, |
| VkImageCreateFlags flags, |
| VkImageFormatProperties* pImageFormatProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ca27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties* pProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2d627a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties); |
| |
| } |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, |
| VkQueueFamilyProperties* pQueueFamilyProperties); |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties* pMemoryProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ce27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); |
| |
| } |
| |
| // Declare only |
| VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr( |
| VkInstance instance, |
| const char* pName); |
| |
| // Declare only |
| VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr( |
| VkDevice device, |
| const char* pName); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL CreateDevice( |
| VkPhysicalDevice physicalDevice, |
| const VkDeviceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDevice* pDevice); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL DestroyDevice( |
| VkDevice device, |
| const VkAllocationCallbacks* pAllocator); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties( |
| const char* pLayerName, |
| uint32_t* pPropertyCount, |
| VkExtensionProperties* pProperties); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( |
| VkPhysicalDevice physicalDevice, |
| const char* pLayerName, |
| uint32_t* pPropertyCount, |
| VkExtensionProperties* pProperties); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties( |
| uint32_t* pPropertyCount, |
| VkLayerProperties* pProperties); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pPropertyCount, |
| VkLayerProperties* pProperties); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( |
| VkDevice device, |
| uint32_t queueFamilyIndex, |
| uint32_t queueIndex, |
| VkQueue* pQueue); |
| |
| VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( |
| VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo* pSubmits, |
| VkFence fence) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_31a29c01, VALIDATION_ERROR_31a00009); |
| if (pSubmits) { |
| for (uint32_t index0 = 0; index0 < submitCount; ++index0) { |
| for (uint32_t index1 = 0; index1 < pSubmits[index0].waitSemaphoreCount; ++index1) { |
| skip |= ValidateObject(queue, pSubmits[index0].pWaitSemaphores[index1], kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_13c27601, VALIDATION_ERROR_13c00009); |
| } |
| for (uint32_t index1 = 0; index1 < pSubmits[index0].commandBufferCount; ++index1) { |
| skip |= ValidateObject(queue, pSubmits[index0].pCommandBuffers[index1], kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_13c11401, VALIDATION_ERROR_13c00009); |
| } |
| for (uint32_t index1 = 0; index1 < pSubmits[index0].signalSemaphoreCount; ++index1) { |
| skip |= ValidateObject(queue, pSubmits[index0].pSignalSemaphores[index1], kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_13c23401, VALIDATION_ERROR_13c00009); |
| } |
| } |
| } |
| skip |= ValidateObject(queue, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_31a08801, VALIDATION_ERROR_31a00009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, queue)->QueueSubmit(queue, submitCount, pSubmits, fence); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( |
| VkQueue queue) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_31c29c01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, queue)->QueueWaitIdle(queue); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( |
| VkDevice device) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_27005601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->DeviceWaitIdle(device); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( |
| VkDevice device, |
| const VkMemoryAllocateInfo* pAllocateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDeviceMemory* pMemory) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_16c05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pMemory, kVulkanObjectTypeDeviceMemory, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL FreeMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28805601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, true, VALIDATION_ERROR_2880c601, VALIDATION_ERROR_2880c607); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, memory, kVulkanObjectTypeDeviceMemory, pAllocator, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->FreeMemory(device, memory, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL MapMemory( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize offset, |
| VkDeviceSize size, |
| VkMemoryMapFlags flags, |
| void** ppData) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_31205601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_3120c601, VALIDATION_ERROR_3120c607); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->MapMemory(device, memory, offset, size, flags, ppData); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL UnmapMemory( |
| VkDevice device, |
| VkDeviceMemory memory) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33605601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_3360c601, VALIDATION_ERROR_3360c607); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->UnmapMemory(device, memory); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28205601, VALIDATION_ERROR_UNDEFINED); |
| if (pMemoryRanges) { |
| for (uint32_t index0 = 0; index0 < memoryRangeCount; ++index0) { |
| skip |= ValidateObject(device, pMemoryRanges[index0].memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_0c20c601, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( |
| VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_31005601, VALIDATION_ERROR_UNDEFINED); |
| if (pMemoryRanges) { |
| for (uint32_t index0 = 0; index0 < memoryRangeCount; ++index0) { |
| skip |= ValidateObject(device, pMemoryRanges[index0].memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_0c20c601, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize* pCommittedMemoryInBytes) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_29205601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_2920c601, VALIDATION_ERROR_2920c607); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( |
| VkDevice device, |
| VkBuffer buffer, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_17005601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_17001a01, VALIDATION_ERROR_17001a07); |
| skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_1700c601, VALIDATION_ERROR_1700c607); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->BindBufferMemory(device, buffer, memory, memoryOffset); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( |
| VkDevice device, |
| VkImage image, |
| VkDeviceMemory memory, |
| VkDeviceSize memoryOffset) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_17405601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1740a001, VALIDATION_ERROR_1740a007); |
| skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_1740c601, VALIDATION_ERROR_1740c607); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->BindImageMemory(device, image, memory, memoryOffset); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( |
| VkDevice device, |
| VkBuffer buffer, |
| VkMemoryRequirements* pMemoryRequirements) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28a05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_28a01a01, VALIDATION_ERROR_28a01a07); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| VkMemoryRequirements* pMemoryRequirements) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2a205601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_2a20a001, VALIDATION_ERROR_2a20a007); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetImageMemoryRequirements(device, image, pMemoryRequirements); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( |
| VkDevice device, |
| VkImage image, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements* pSparseMemoryRequirements) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2a405601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_2a40a001, VALIDATION_ERROR_2a40a007); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties( |
| VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkImageType type, |
| VkSampleCountFlagBits samples, |
| VkImageUsageFlags usage, |
| VkImageTiling tiling, |
| uint32_t* pPropertyCount, |
| VkSparseImageFormatProperties* pProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2de27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( |
| VkQueue queue, |
| uint32_t bindInfoCount, |
| const VkBindSparseInfo* pBindInfo, |
| VkFence fence) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_31629c01, VALIDATION_ERROR_31600009); |
| if (pBindInfo) { |
| for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) { |
| for (uint32_t index1 = 0; index1 < pBindInfo[index0].waitSemaphoreCount; ++index1) { |
| skip |= ValidateObject(queue, pBindInfo[index0].pWaitSemaphores[index1], kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_01227601, VALIDATION_ERROR_01200009); |
| } |
| if (pBindInfo[index0].pBufferBinds) { |
| for (uint32_t index1 = 0; index1 < pBindInfo[index0].bufferBindCount; ++index1) { |
| skip |= ValidateObject(queue, pBindInfo[index0].pBufferBinds[index1].buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_12c01a01, VALIDATION_ERROR_UNDEFINED); |
| if (pBindInfo[index0].pBufferBinds[index1].pBinds) { |
| for (uint32_t index2 = 0; index2 < pBindInfo[index0].pBufferBinds[index1].bindCount; ++index2) { |
| skip |= ValidateObject(queue, pBindInfo[index0].pBufferBinds[index1].pBinds[index2].memory, kVulkanObjectTypeDeviceMemory, true, VALIDATION_ERROR_1340c601, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| } |
| } |
| if (pBindInfo[index0].pImageOpaqueBinds) { |
| for (uint32_t index1 = 0; index1 < pBindInfo[index0].imageOpaqueBindCount; ++index1) { |
| skip |= ValidateObject(queue, pBindInfo[index0].pImageOpaqueBinds[index1].image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1320a001, VALIDATION_ERROR_UNDEFINED); |
| if (pBindInfo[index0].pImageOpaqueBinds[index1].pBinds) { |
| for (uint32_t index2 = 0; index2 < pBindInfo[index0].pImageOpaqueBinds[index1].bindCount; ++index2) { |
| skip |= ValidateObject(queue, pBindInfo[index0].pImageOpaqueBinds[index1].pBinds[index2].memory, kVulkanObjectTypeDeviceMemory, true, VALIDATION_ERROR_1340c601, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| } |
| } |
| if (pBindInfo[index0].pImageBinds) { |
| for (uint32_t index1 = 0; index1 < pBindInfo[index0].imageBindCount; ++index1) { |
| skip |= ValidateObject(queue, pBindInfo[index0].pImageBinds[index1].image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1300a001, VALIDATION_ERROR_UNDEFINED); |
| if (pBindInfo[index0].pImageBinds[index1].pBinds) { |
| for (uint32_t index2 = 0; index2 < pBindInfo[index0].pImageBinds[index1].bindCount; ++index2) { |
| skip |= ValidateObject(queue, pBindInfo[index0].pImageBinds[index1].pBinds[index2].memory, kVulkanObjectTypeDeviceMemory, true, VALIDATION_ERROR_12e0c601, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| } |
| } |
| for (uint32_t index1 = 0; index1 < pBindInfo[index0].signalSemaphoreCount; ++index1) { |
| skip |= ValidateObject(queue, pBindInfo[index0].pSignalSemaphores[index1], kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_01223401, VALIDATION_ERROR_01200009); |
| } |
| } |
| } |
| skip |= ValidateObject(queue, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_31608801, VALIDATION_ERROR_31600009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateFence( |
| VkDevice device, |
| const VkFenceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20405601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateFence(device, pCreateInfo, pAllocator, pFence); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pFence, kVulkanObjectTypeFence, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyFence( |
| VkDevice device, |
| VkFence fence, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24e05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_24e08801, VALIDATION_ERROR_24e08807); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, fence, kVulkanObjectTypeFence, pAllocator, VALIDATION_ERROR_24e008c2, VALIDATION_ERROR_24e008c4); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyFence(device, fence, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL ResetFences( |
| VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_32e05601, VALIDATION_ERROR_UNDEFINED); |
| for (uint32_t index0 = 0; index0 < fenceCount; ++index0) { |
| skip |= ValidateObject(device, pFences[index0], kVulkanObjectTypeFence, false, VALIDATION_ERROR_32e17201, VALIDATION_ERROR_32e17207); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->ResetFences(device, fenceCount, pFences); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( |
| VkDevice device, |
| VkFence fence) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2a005601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_2a008801, VALIDATION_ERROR_2a008807); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetFenceStatus(device, fence); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( |
| VkDevice device, |
| uint32_t fenceCount, |
| const VkFence* pFences, |
| VkBool32 waitAll, |
| uint64_t timeout) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33e05601, VALIDATION_ERROR_UNDEFINED); |
| for (uint32_t index0 = 0; index0 < fenceCount; ++index0) { |
| skip |= ValidateObject(device, pFences[index0], kVulkanObjectTypeFence, false, VALIDATION_ERROR_33e17201, VALIDATION_ERROR_33e17207); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( |
| VkDevice device, |
| const VkSemaphoreCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSemaphore* pSemaphore) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22405601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pSemaphore, kVulkanObjectTypeSemaphore, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroySemaphore( |
| VkDevice device, |
| VkSemaphore semaphore, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26805601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, semaphore, kVulkanObjectTypeSemaphore, true, VALIDATION_ERROR_2682b801, VALIDATION_ERROR_2682b807); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, semaphore, kVulkanObjectTypeSemaphore, pAllocator, VALIDATION_ERROR_268008e4, VALIDATION_ERROR_268008e6); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroySemaphore(device, semaphore, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( |
| VkDevice device, |
| const VkEventCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkEvent* pEvent) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20205601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pEvent, kVulkanObjectTypeEvent, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyEvent( |
| VkDevice device, |
| VkEvent event, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24c05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, true, VALIDATION_ERROR_24c07e01, VALIDATION_ERROR_24c07e07); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, event, kVulkanObjectTypeEvent, pAllocator, VALIDATION_ERROR_24c008f4, VALIDATION_ERROR_24c008f6); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyEvent(device, event, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( |
| VkDevice device, |
| VkEvent event) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_29e05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_29e07e01, VALIDATION_ERROR_29e07e07); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetEventStatus(device, event); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL SetEvent( |
| VkDevice device, |
| VkEvent event) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33005601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_33007e01, VALIDATION_ERROR_33007e07); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->SetEvent(device, event); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( |
| VkDevice device, |
| VkEvent event) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_32c05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_32c07e01, VALIDATION_ERROR_32c07e07); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->ResetEvent(device, event); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( |
| VkDevice device, |
| const VkQueryPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkQueryPool* pQueryPool) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_21e05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pQueryPool, kVulkanObjectTypeQueryPool, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( |
| VkDevice device, |
| VkQueryPool queryPool, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26205601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, queryPool, kVulkanObjectTypeQueryPool, true, VALIDATION_ERROR_26229801, VALIDATION_ERROR_26229807); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, queryPool, kVulkanObjectTypeQueryPool, pAllocator, VALIDATION_ERROR_26200634, VALIDATION_ERROR_26200636); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyQueryPool(device, queryPool, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults( |
| VkDevice device, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| size_t dataSize, |
| void* pData, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2fa05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_2fa29801, VALIDATION_ERROR_2fa29807); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( |
| VkDevice device, |
| const VkBufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBuffer* pBuffer) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1ec05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pBuffer, kVulkanObjectTypeBuffer, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyBuffer( |
| VkDevice device, |
| VkBuffer buffer, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_23c05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, buffer, kVulkanObjectTypeBuffer, true, VALIDATION_ERROR_23c01a01, VALIDATION_ERROR_23c01a07); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, buffer, kVulkanObjectTypeBuffer, pAllocator, VALIDATION_ERROR_23c00736, VALIDATION_ERROR_23c00738); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyBuffer(device, buffer, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( |
| VkDevice device, |
| const VkBufferViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBufferView* pView) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1ee05601, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfo) { |
| skip |= ValidateObject(device, pCreateInfo->buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01a01a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateBufferView(device, pCreateInfo, pAllocator, pView); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pView, kVulkanObjectTypeBufferView, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyBufferView( |
| VkDevice device, |
| VkBufferView bufferView, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_23e05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, bufferView, kVulkanObjectTypeBufferView, true, VALIDATION_ERROR_23e01c01, VALIDATION_ERROR_23e01c07); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, bufferView, kVulkanObjectTypeBufferView, pAllocator, VALIDATION_ERROR_23e00752, VALIDATION_ERROR_23e00754); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyBufferView(device, bufferView, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateImage( |
| VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImage* pImage) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20c05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateImage(device, pCreateInfo, pAllocator, pImage); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pImage, kVulkanObjectTypeImage, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyImage( |
| VkDevice device, |
| VkImage image, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25205601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, image, kVulkanObjectTypeImage, true, VALIDATION_ERROR_2520a001, VALIDATION_ERROR_2520a007); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, image, kVulkanObjectTypeImage, pAllocator, VALIDATION_ERROR_252007d2, VALIDATION_ERROR_252007d4); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyImage(device, image, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( |
| VkDevice device, |
| VkImage image, |
| const VkImageSubresource* pSubresource, |
| VkSubresourceLayout* pLayout) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2a605601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_2a60a001, VALIDATION_ERROR_2a60a007); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( |
| VkDevice device, |
| const VkImageViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImageView* pView) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20e05601, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfo) { |
| skip |= ValidateObject(device, pCreateInfo->image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_0ac0a001, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateImageView(device, pCreateInfo, pAllocator, pView); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pView, kVulkanObjectTypeImageView, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyImageView( |
| VkDevice device, |
| VkImageView imageView, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25405601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, imageView, kVulkanObjectTypeImageView, true, VALIDATION_ERROR_2540b001, VALIDATION_ERROR_2540b007); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, imageView, kVulkanObjectTypeImageView, pAllocator, VALIDATION_ERROR_25400806, VALIDATION_ERROR_25400808); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyImageView(device, imageView, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( |
| VkDevice device, |
| const VkShaderModuleCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkShaderModule* pShaderModule) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22605601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pShaderModule, kVulkanObjectTypeShaderModule, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( |
| VkDevice device, |
| VkShaderModule shaderModule, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26a05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, shaderModule, kVulkanObjectTypeShaderModule, true, VALIDATION_ERROR_26a2be01, VALIDATION_ERROR_26a2be07); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, shaderModule, kVulkanObjectTypeShaderModule, pAllocator, VALIDATION_ERROR_26a00888, VALIDATION_ERROR_26a0088a); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyShaderModule(device, shaderModule, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( |
| VkDevice device, |
| const VkPipelineCacheCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineCache* pPipelineCache) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_21a05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pPipelineCache, kVulkanObjectTypePipelineCache, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25e05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, VALIDATION_ERROR_25e28001, VALIDATION_ERROR_25e28007); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, pipelineCache, kVulkanObjectTypePipelineCache, pAllocator, VALIDATION_ERROR_25e00606, VALIDATION_ERROR_25e00608); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyPipelineCache(device, pipelineCache, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| size_t* pDataSize, |
| void* pData) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2f805601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, false, VALIDATION_ERROR_2f828001, VALIDATION_ERROR_2f828007); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( |
| VkDevice device, |
| VkPipelineCache dstCache, |
| uint32_t srcCacheCount, |
| const VkPipelineCache* pSrcCaches) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_31405601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, dstCache, kVulkanObjectTypePipelineCache, false, VALIDATION_ERROR_31406e01, VALIDATION_ERROR_31406e07); |
| for (uint32_t index0 = 0; index0 < srcCacheCount; ++index0) { |
| skip |= ValidateObject(device, pSrcCaches[index0], kVulkanObjectTypePipelineCache, false, VALIDATION_ERROR_31423c01, VALIDATION_ERROR_31423c07); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20805601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, VALIDATION_ERROR_20828001, VALIDATION_ERROR_20828007); |
| if (pCreateInfos) { |
| for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) { |
| if (pCreateInfos[index0].pStages) { |
| for (uint32_t index1 = 0; index1 < pCreateInfos[index0].stageCount; ++index1) { |
| skip |= ValidateObject(device, pCreateInfos[index0].pStages[index1].module, kVulkanObjectTypeShaderModule, false, VALIDATION_ERROR_1060d201, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| skip |= ValidateObject(device, pCreateInfos[index0].layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_0960be01, VALIDATION_ERROR_09600009); |
| skip |= ValidateObject(device, pCreateInfos[index0].renderPass, kVulkanObjectTypeRenderPass, false, VALIDATION_ERROR_0962ae01, VALIDATION_ERROR_09600009); |
| skip |= ValidateObject(device, pCreateInfos[index0].basePipelineHandle, kVulkanObjectTypePipeline, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_09600009); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| for (uint32_t index = 0; index < createInfoCount; index++) { |
| CreateObject(device, pPipelines[index], kVulkanObjectTypePipeline, pAllocator); |
| } |
| } |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( |
| VkDevice device, |
| VkPipelineCache pipelineCache, |
| uint32_t createInfoCount, |
| const VkComputePipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines); |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyPipeline( |
| VkDevice device, |
| VkPipeline pipeline, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25c05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, pipeline, kVulkanObjectTypePipeline, true, VALIDATION_ERROR_25c27c01, VALIDATION_ERROR_25c27c07); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, pipeline, kVulkanObjectTypePipeline, pAllocator, VALIDATION_ERROR_25c005fc, VALIDATION_ERROR_25c005fe); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyPipeline(device, pipeline, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( |
| VkDevice device, |
| const VkPipelineLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineLayout* pPipelineLayout) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_21c05601, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfo) { |
| for (uint32_t index1 = 0; index1 < pCreateInfo->setLayoutCount; ++index1) { |
| skip |= ValidateObject(device, pCreateInfo->pSetLayouts[index1], kVulkanObjectTypeDescriptorSetLayout, false, VALIDATION_ERROR_0fe22c01, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pPipelineLayout, kVulkanObjectTypePipelineLayout, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( |
| VkDevice device, |
| VkPipelineLayout pipelineLayout, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26005601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, pipelineLayout, kVulkanObjectTypePipelineLayout, true, VALIDATION_ERROR_26028201, VALIDATION_ERROR_26028207); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, pipelineLayout, kVulkanObjectTypePipelineLayout, pAllocator, VALIDATION_ERROR_26000256, VALIDATION_ERROR_26000258); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( |
| VkDevice device, |
| const VkSamplerCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSampler* pSampler) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22205601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pSampler, kVulkanObjectTypeSampler, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroySampler( |
| VkDevice device, |
| VkSampler sampler, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26605601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, sampler, kVulkanObjectTypeSampler, true, VALIDATION_ERROR_2662b201, VALIDATION_ERROR_2662b207); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, sampler, kVulkanObjectTypeSampler, pAllocator, VALIDATION_ERROR_26600876, VALIDATION_ERROR_26600878); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroySampler(device, sampler, pAllocator); |
| |
| } |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorSetLayout* pSetLayout); |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( |
| VkDevice device, |
| VkDescriptorSetLayout descriptorSetLayout, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24605601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, true, VALIDATION_ERROR_24604c01, VALIDATION_ERROR_24604c07); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, pAllocator, VALIDATION_ERROR_24600238, VALIDATION_ERROR_2460023a); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( |
| VkDevice device, |
| const VkDescriptorPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorPool* pDescriptorPool) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1f605601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pDescriptorPool, kVulkanObjectTypeDescriptorPool, pAllocator); |
| } |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| VkDescriptorPoolResetFlags flags); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( |
| VkDevice device, |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, |
| VkDescriptorSet* pDescriptorSets); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( |
| VkDevice device, |
| VkDescriptorPool descriptorPool, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( |
| VkDevice device, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites, |
| uint32_t descriptorCopyCount, |
| const VkCopyDescriptorSet* pDescriptorCopies); |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( |
| VkDevice device, |
| const VkFramebufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFramebuffer* pFramebuffer) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_20605601, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfo) { |
| skip |= ValidateObject(device, pCreateInfo->renderPass, kVulkanObjectTypeRenderPass, false, VALIDATION_ERROR_0942ae01, VALIDATION_ERROR_09400009); |
| for (uint32_t index1 = 0; index1 < pCreateInfo->attachmentCount; ++index1) { |
| skip |= ValidateObject(device, pCreateInfo->pAttachments[index1], kVulkanObjectTypeImageView, false, VALIDATION_ERROR_0940f201, VALIDATION_ERROR_09400009); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pFramebuffer, kVulkanObjectTypeFramebuffer, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( |
| VkDevice device, |
| VkFramebuffer framebuffer, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25005601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, framebuffer, kVulkanObjectTypeFramebuffer, true, VALIDATION_ERROR_25009401, VALIDATION_ERROR_25009407); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, framebuffer, kVulkanObjectTypeFramebuffer, pAllocator, VALIDATION_ERROR_250006fa, VALIDATION_ERROR_250006fc); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyFramebuffer(device, framebuffer, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( |
| VkDevice device, |
| const VkRenderPassCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22005601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pRenderPass, kVulkanObjectTypeRenderPass, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( |
| VkDevice device, |
| VkRenderPass renderPass, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_26405601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, renderPass, kVulkanObjectTypeRenderPass, true, VALIDATION_ERROR_2642ae01, VALIDATION_ERROR_2642ae07); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, renderPass, kVulkanObjectTypeRenderPass, pAllocator, VALIDATION_ERROR_264006d4, VALIDATION_ERROR_264006d6); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyRenderPass(device, renderPass, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( |
| VkDevice device, |
| VkRenderPass renderPass, |
| VkExtent2D* pGranularity) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30005601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, renderPass, kVulkanObjectTypeRenderPass, false, VALIDATION_ERROR_3002ae01, VALIDATION_ERROR_3002ae07); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetRenderAreaGranularity(device, renderPass, pGranularity); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( |
| VkDevice device, |
| const VkCommandPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCommandPool* pCommandPool) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1f005601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pCommandPool, kVulkanObjectTypeCommandPool, pAllocator); |
| } |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| const VkAllocationCallbacks* pAllocator); |
| |
| VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolResetFlags flags) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_32805601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_32802801, VALIDATION_ERROR_32802807); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->ResetCommandPool(device, commandPool, flags); |
| |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( |
| VkDevice device, |
| const VkCommandBufferAllocateInfo* pAllocateInfo, |
| VkCommandBuffer* pCommandBuffers); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( |
| VkDevice device, |
| VkCommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo); |
| |
| VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( |
| VkCommandBuffer commandBuffer) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_27402401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, commandBuffer)->EndCommandBuffer(commandBuffer); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( |
| VkCommandBuffer commandBuffer, |
| VkCommandBufferResetFlags flags) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_32602401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, commandBuffer)->ResetCommandBuffer(commandBuffer, flags); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18002401, VALIDATION_ERROR_18000009); |
| skip |= ValidateObject(commandBuffer, pipeline, kVulkanObjectTypePipeline, false, VALIDATION_ERROR_18027c01, VALIDATION_ERROR_18000009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetViewport( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewport* pViewports) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1e002401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetScissor( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstScissor, |
| uint32_t scissorCount, |
| const VkRect2D* pScissors) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1d802401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( |
| VkCommandBuffer commandBuffer, |
| float lineWidth) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1d602401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetLineWidth(commandBuffer, lineWidth); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( |
| VkCommandBuffer commandBuffer, |
| float depthBiasConstantFactor, |
| float depthBiasClamp, |
| float depthBiasSlopeFactor) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1cc02401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( |
| VkCommandBuffer commandBuffer, |
| const float blendConstants[4]) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1ca02401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( |
| VkCommandBuffer commandBuffer, |
| float minDepthBounds, |
| float maxDepthBounds) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1ce02401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t compareMask) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1da02401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t writeMask) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1de02401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, |
| uint32_t reference) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1dc02401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetStencilReference(commandBuffer, faceMask, reference); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t firstSet, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets, |
| uint32_t dynamicOffsetCount, |
| const uint32_t* pDynamicOffsets) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_17c02401, VALIDATION_ERROR_17c00009); |
| skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_17c0be01, VALIDATION_ERROR_17c00009); |
| for (uint32_t index0 = 0; index0 < descriptorSetCount; ++index0) { |
| skip |= ValidateObject(commandBuffer, pDescriptorSets[index0], kVulkanObjectTypeDescriptorSet, false, VALIDATION_ERROR_17c13001, VALIDATION_ERROR_17c00009); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkIndexType indexType) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_17e02401, VALIDATION_ERROR_17e00009); |
| skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_17e01a01, VALIDATION_ERROR_17e00009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, |
| uint32_t bindingCount, |
| const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18202401, VALIDATION_ERROR_18200009); |
| for (uint32_t index0 = 0; index0 < bindingCount; ++index0) { |
| skip |= ValidateObject(commandBuffer, pBuffers[index0], kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_18210601, VALIDATION_ERROR_18200009); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDraw( |
| VkCommandBuffer commandBuffer, |
| uint32_t vertexCount, |
| uint32_t instanceCount, |
| uint32_t firstVertex, |
| uint32_t firstInstance) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1a202401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( |
| VkCommandBuffer commandBuffer, |
| uint32_t indexCount, |
| uint32_t instanceCount, |
| uint32_t firstIndex, |
| int32_t vertexOffset, |
| uint32_t firstInstance) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1a402401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1aa02401, VALIDATION_ERROR_1aa00009); |
| skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1aa01a01, VALIDATION_ERROR_1aa00009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| uint32_t drawCount, |
| uint32_t stride) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1a602401, VALIDATION_ERROR_1a600009); |
| skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1a601a01, VALIDATION_ERROR_1a600009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDispatch( |
| VkCommandBuffer commandBuffer, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19c02401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1a002401, VALIDATION_ERROR_1a000009); |
| skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1a001a01, VALIDATION_ERROR_1a000009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDispatchIndirect(commandBuffer, buffer, offset); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferCopy* pRegions) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18c02401, VALIDATION_ERROR_18c00009); |
| skip |= ValidateObject(commandBuffer, srcBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_18c2c801, VALIDATION_ERROR_18c00009); |
| skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_18c06c01, VALIDATION_ERROR_18c00009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdCopyImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageCopy* pRegions) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19002401, VALIDATION_ERROR_19000009); |
| skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1902ce01, VALIDATION_ERROR_19000009); |
| skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_19007201, VALIDATION_ERROR_19000009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdBlitImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageBlit* pRegions, |
| VkFilter filter) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18402401, VALIDATION_ERROR_18400009); |
| skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1842ce01, VALIDATION_ERROR_18400009); |
| skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_18407201, VALIDATION_ERROR_18400009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( |
| VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18e02401, VALIDATION_ERROR_18e00009); |
| skip |= ValidateObject(commandBuffer, srcBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_18e2c801, VALIDATION_ERROR_18e00009); |
| skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_18e07201, VALIDATION_ERROR_18e00009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkBuffer dstBuffer, |
| uint32_t regionCount, |
| const VkBufferImageCopy* pRegions) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19202401, VALIDATION_ERROR_19200009); |
| skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1922ce01, VALIDATION_ERROR_19200009); |
| skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_19206c01, VALIDATION_ERROR_19200009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize dataSize, |
| const void* pData) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1e402401, VALIDATION_ERROR_1e400009); |
| skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1e406c01, VALIDATION_ERROR_1e400009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( |
| VkCommandBuffer commandBuffer, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize size, |
| uint32_t data) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b402401, VALIDATION_ERROR_1b400009); |
| skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1b406c01, VALIDATION_ERROR_1b400009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearColorValue* pColor, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18802401, VALIDATION_ERROR_18800009); |
| skip |= ValidateObject(commandBuffer, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1880a001, VALIDATION_ERROR_18800009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( |
| VkCommandBuffer commandBuffer, |
| VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearDepthStencilValue* pDepthStencil, |
| uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18a02401, VALIDATION_ERROR_18a00009); |
| skip |= ValidateObject(commandBuffer, image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_18a0a001, VALIDATION_ERROR_18a00009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( |
| VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, |
| const VkClearAttachment* pAttachments, |
| uint32_t rectCount, |
| const VkClearRect* pRects) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_18602401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdResolveImage( |
| VkCommandBuffer commandBuffer, |
| VkImage srcImage, |
| VkImageLayout srcImageLayout, |
| VkImage dstImage, |
| VkImageLayout dstImageLayout, |
| uint32_t regionCount, |
| const VkImageResolve* pRegions) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1c802401, VALIDATION_ERROR_1c800009); |
| skip |= ValidateObject(commandBuffer, srcImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1c82ce01, VALIDATION_ERROR_1c800009); |
| skip |= ValidateObject(commandBuffer, dstImage, kVulkanObjectTypeImage, false, VALIDATION_ERROR_1c807201, VALIDATION_ERROR_1c800009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1d402401, VALIDATION_ERROR_1d400009); |
| skip |= ValidateObject(commandBuffer, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_1d407e01, VALIDATION_ERROR_1d400009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetEvent(commandBuffer, event, stageMask); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdResetEvent( |
| VkCommandBuffer commandBuffer, |
| VkEvent event, |
| VkPipelineStageFlags stageMask) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1c402401, VALIDATION_ERROR_1c400009); |
| skip |= ValidateObject(commandBuffer, event, kVulkanObjectTypeEvent, false, VALIDATION_ERROR_1c407e01, VALIDATION_ERROR_1c400009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdResetEvent(commandBuffer, event, stageMask); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdWaitEvents( |
| VkCommandBuffer commandBuffer, |
| uint32_t eventCount, |
| const VkEvent* pEvents, |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| uint32_t memoryBarrierCount, |
| const VkMemoryBarrier* pMemoryBarriers, |
| uint32_t bufferMemoryBarrierCount, |
| const VkBufferMemoryBarrier* pBufferMemoryBarriers, |
| uint32_t imageMemoryBarrierCount, |
| const VkImageMemoryBarrier* pImageMemoryBarriers) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1e602401, VALIDATION_ERROR_1e600009); |
| for (uint32_t index0 = 0; index0 < eventCount; ++index0) { |
| skip |= ValidateObject(commandBuffer, pEvents[index0], kVulkanObjectTypeEvent, false, VALIDATION_ERROR_1e616001, VALIDATION_ERROR_1e600009); |
| } |
| if (pBufferMemoryBarriers) { |
| for (uint32_t index0 = 0; index0 < bufferMemoryBarrierCount; ++index0) { |
| skip |= ValidateObject(commandBuffer, pBufferMemoryBarriers[index0].buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01801a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (pImageMemoryBarriers) { |
| for (uint32_t index0 = 0; index0 < imageMemoryBarrierCount; ++index0) { |
| skip |= ValidateObject(commandBuffer, pImageMemoryBarriers[index0].image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_0a00a001, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags srcStageMask, |
| VkPipelineStageFlags dstStageMask, |
| VkDependencyFlags dependencyFlags, |
| uint32_t memoryBarrierCount, |
| const VkMemoryBarrier* pMemoryBarriers, |
| uint32_t bufferMemoryBarrierCount, |
| const VkBufferMemoryBarrier* pBufferMemoryBarriers, |
| uint32_t imageMemoryBarrierCount, |
| const VkImageMemoryBarrier* pImageMemoryBarriers) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b802401, VALIDATION_ERROR_UNDEFINED); |
| if (pBufferMemoryBarriers) { |
| for (uint32_t index0 = 0; index0 < bufferMemoryBarrierCount; ++index0) { |
| skip |= ValidateObject(commandBuffer, pBufferMemoryBarriers[index0].buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_01801a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (pImageMemoryBarriers) { |
| for (uint32_t index0 = 0; index0 < imageMemoryBarrierCount; ++index0) { |
| skip |= ValidateObject(commandBuffer, pImageMemoryBarriers[index0].image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_0a00a001, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query, |
| VkQueryControlFlags flags) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_17802401, VALIDATION_ERROR_17800009); |
| skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_17829801, VALIDATION_ERROR_17800009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBeginQuery(commandBuffer, queryPool, query, flags); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdEndQuery( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t query) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1ae02401, VALIDATION_ERROR_1ae00009); |
| skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_1ae29801, VALIDATION_ERROR_1ae00009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdEndQuery(commandBuffer, queryPool, query); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1c602401, VALIDATION_ERROR_1c600009); |
| skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_1c629801, VALIDATION_ERROR_1c600009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkQueryPool queryPool, |
| uint32_t query) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1e802401, VALIDATION_ERROR_1e800009); |
| skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_1e829801, VALIDATION_ERROR_1e800009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults( |
| VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, |
| uint32_t firstQuery, |
| uint32_t queryCount, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| VkDeviceSize stride, |
| VkQueryResultFlags flags) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19402401, VALIDATION_ERROR_19400009); |
| skip |= ValidateObject(commandBuffer, queryPool, kVulkanObjectTypeQueryPool, false, VALIDATION_ERROR_19429801, VALIDATION_ERROR_19400009); |
| skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_19406c01, VALIDATION_ERROR_19400009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdPushConstants( |
| VkCommandBuffer commandBuffer, |
| VkPipelineLayout layout, |
| VkShaderStageFlags stageFlags, |
| uint32_t offset, |
| uint32_t size, |
| const void* pValues) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1bc02401, VALIDATION_ERROR_1bc00009); |
| skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_1bc0be01, VALIDATION_ERROR_1bc00009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| VkSubpassContents contents) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_17a02401, VALIDATION_ERROR_UNDEFINED); |
| if (pRenderPassBegin) { |
| skip |= ValidateObject(commandBuffer, pRenderPassBegin->renderPass, kVulkanObjectTypeRenderPass, false, VALIDATION_ERROR_1202ae01, VALIDATION_ERROR_12000009); |
| skip |= ValidateObject(commandBuffer, pRenderPassBegin->framebuffer, kVulkanObjectTypeFramebuffer, false, VALIDATION_ERROR_12009401, VALIDATION_ERROR_12000009); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( |
| VkCommandBuffer commandBuffer, |
| VkSubpassContents contents) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b602401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdNextSubpass(commandBuffer, contents); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( |
| VkCommandBuffer commandBuffer) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b002401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdEndRenderPass(commandBuffer); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( |
| VkCommandBuffer commandBuffer, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b202401, VALIDATION_ERROR_1b200009); |
| for (uint32_t index0 = 0; index0 < commandBufferCount; ++index0) { |
| skip |= ValidateObject(commandBuffer, pCommandBuffers[index0], kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1b211401, VALIDATION_ERROR_1b200009); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_17205601, VALIDATION_ERROR_UNDEFINED); |
| if (pBindInfos) { |
| for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) { |
| skip |= ValidateObject(device, pBindInfos[index0].buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_00c01a01, VALIDATION_ERROR_00c00009); |
| skip |= ValidateObject(device, pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_00c0c601, VALIDATION_ERROR_00c00009); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->BindBufferMemory2(device, bindInfoCount, pBindInfos); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_17605601, VALIDATION_ERROR_UNDEFINED); |
| if (pBindInfos) { |
| for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) { |
| skip |= ValidateObject(device, pBindInfos[index0].image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_00e0a001, VALIDATION_ERROR_00e00009); |
| skip |= ValidateObject(device, pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_00e00009); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->BindImageMemory2(device, bindInfoCount, pBindInfos); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures( |
| VkDevice device, |
| uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28c05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask( |
| VkCommandBuffer commandBuffer, |
| uint32_t deviceMask) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1d002401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetDeviceMask(commandBuffer, deviceMask); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDispatchBase( |
| VkCommandBuffer commandBuffer, |
| uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19e02401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_27e0bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->EnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3c405601, VALIDATION_ERROR_UNDEFINED); |
| if (pInfo) { |
| skip |= ValidateObject(device, pInfo->image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_3bc0a001, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3c605601, VALIDATION_ERROR_UNDEFINED); |
| if (pInfo) { |
| skip |= ValidateObject(device, pInfo->buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_3ba01a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2( |
| VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3c805601, VALIDATION_ERROR_UNDEFINED); |
| if (pInfo) { |
| skip |= ValidateObject(device, pInfo->image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_3be0a001, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures2* pFeatures) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2c227a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures2(physicalDevice, pFeatures); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties2* pProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2d827a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties2(physicalDevice, pProperties); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2( |
| VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkFormatProperties2* pFormatProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2c627a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, |
| VkImageFormatProperties2* pImageFormatProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2cc27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); |
| |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, |
| VkQueueFamilyProperties2* pQueueFamilyProperties); |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties2* pMemoryProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2d027a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, |
| uint32_t* pPropertyCount, |
| VkSparseImageFormatProperties2* pProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2e027a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL TrimCommandPool( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33405601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_33402801, VALIDATION_ERROR_33402807); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->TrimCommandPool(device, commandPool, flags); |
| |
| } |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2( |
| VkDevice device, |
| const VkDeviceQueueInfo2* pQueueInfo, |
| VkQueue* pQueue); |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion( |
| VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3fe05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pYcbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion( |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_40405601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, true, VALIDATION_ERROR_4043e201, VALIDATION_ERROR_4043e207); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate( |
| VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1fa05601, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfo) { |
| skip |= ValidateObject(device, pCreateInfo->descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, true, VALIDATION_ERROR_05204c01, VALIDATION_ERROR_05200009); |
| skip |= ValidateObject(device, pCreateInfo->pipelineLayout, kVulkanObjectTypePipelineLayout, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_05200009); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pDescriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate( |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24805601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, true, VALIDATION_ERROR_24805201, VALIDATION_ERROR_24805207); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, pAllocator, VALIDATION_ERROR_248002c8, VALIDATION_ERROR_248002ca); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33a05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, descriptorSet, kVulkanObjectTypeDescriptorSet, false, VALIDATION_ERROR_33a04801, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, false, VALIDATION_ERROR_33a05201, VALIDATION_ERROR_33a05207); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, |
| VkExternalBufferProperties* pExternalBufferProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ba27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, |
| VkExternalFenceProperties* pExternalFenceProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_39a27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, |
| VkExternalSemaphoreProperties* pExternalSemaphoreProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2be27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_43205601, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfo) { |
| if (pCreateInfo->pBindings) { |
| for (uint32_t index1 = 0; index1 < pCreateInfo->bindingCount; ++index1) { |
| for (uint32_t index2 = 0; index2 < pCreateInfo->pBindings[index1].descriptorCount; ++index2) { |
| skip |= ValidateObject(device, pCreateInfo->pBindings[index1].pImmutableSamplers[index2], kVulkanObjectTypeSampler, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| } |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR( |
| VkInstance instance, |
| VkSurfaceKHR surface, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_26c0bc01, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(instance, surface, kVulkanObjectTypeSurfaceKHR, true, VALIDATION_ERROR_26c2ec01, VALIDATION_ERROR_26c2ec07); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(instance, surface, kVulkanObjectTypeSurfaceKHR, pAllocator, VALIDATION_ERROR_26c009e6, VALIDATION_ERROR_26c009e8); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, instance)->DestroySurfaceKHR(instance, surface, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex, |
| VkSurfaceKHR surface, |
| VkBool32* pSupported) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ee27a01, VALIDATION_ERROR_2ee00009); |
| skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2ee2ec01, VALIDATION_ERROR_2ee00009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2e627a01, VALIDATION_ERROR_2e600009); |
| skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2e62ec01, VALIDATION_ERROR_2e600009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pSurfaceFormatCount, |
| VkSurfaceFormatKHR* pSurfaceFormats) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ea27a01, VALIDATION_ERROR_2ea00009); |
| skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2ea2ec01, VALIDATION_ERROR_2ea00009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pPresentModeCount, |
| VkPresentModeKHR* pPresentModes) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ec27a01, VALIDATION_ERROR_2ec00009); |
| skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2ec2ec01, VALIDATION_ERROR_2ec00009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR( |
| VkDevice device, |
| const VkSwapchainCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchain) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22a05601, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfo) { |
| skip |= ValidateObject(device, pCreateInfo->surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_1462ec01, VALIDATION_ERROR_14600009); |
| skip |= ValidateObject(device, pCreateInfo->oldSwapchain, kVulkanObjectTypeSwapchainKHR, true, VALIDATION_ERROR_1460de01, VALIDATION_ERROR_1460de07); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pSwapchain, kVulkanObjectTypeSwapchainKHR, pAllocator); |
| } |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| const VkAllocationCallbacks* pAllocator); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pSwapchainImageCount, |
| VkImage* pSwapchainImages); |
| |
| VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint64_t timeout, |
| VkSemaphore semaphore, |
| VkFence fence, |
| uint32_t* pImageIndex) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_16405601, VALIDATION_ERROR_16400009); |
| skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_1642f001, VALIDATION_ERROR_16400009); |
| skip |= ValidateObject(device, semaphore, kVulkanObjectTypeSemaphore, true, VALIDATION_ERROR_1642b801, VALIDATION_ERROR_1642b807); |
| skip |= ValidateObject(device, fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_16408801, VALIDATION_ERROR_16408807); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR( |
| VkQueue queue, |
| const VkPresentInfoKHR* pPresentInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, VALIDATION_ERROR_31829c01, VALIDATION_ERROR_UNDEFINED); |
| if (pPresentInfo) { |
| for (uint32_t index1 = 0; index1 < pPresentInfo->waitSemaphoreCount; ++index1) { |
| skip |= ValidateObject(queue, pPresentInfo->pWaitSemaphores[index1], kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_11227601, VALIDATION_ERROR_11200009); |
| } |
| for (uint32_t index1 = 0; index1 < pPresentInfo->swapchainCount; ++index1) { |
| skip |= ValidateObject(queue, pPresentInfo->pSwapchains[index1], kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_11225801, VALIDATION_ERROR_11200009); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, queue)->QueuePresentKHR(queue, pPresentInfo); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR( |
| VkDevice device, |
| VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28e05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR( |
| VkDevice device, |
| VkSurfaceKHR surface, |
| VkDeviceGroupPresentModeFlagsKHR* pModes) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_29005601, VALIDATION_ERROR_29000009); |
| skip |= ValidateObject(device, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2902ec01, VALIDATION_ERROR_29000009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| uint32_t* pRectCount, |
| VkRect2D* pRects) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2d427a01, VALIDATION_ERROR_2d400009); |
| skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2d42ec01, VALIDATION_ERROR_2d400009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR( |
| VkDevice device, |
| const VkAcquireNextImageInfoKHR* pAcquireInfo, |
| uint32_t* pImageIndex) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_16205601, VALIDATION_ERROR_UNDEFINED); |
| if (pAcquireInfo) { |
| skip |= ValidateObject(device, pAcquireInfo->swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_0002f001, VALIDATION_ERROR_00000009); |
| skip |= ValidateObject(device, pAcquireInfo->semaphore, kVulkanObjectTypeSemaphore, true, VALIDATION_ERROR_0002b801, VALIDATION_ERROR_00000009); |
| skip |= ValidateObject(device, pAcquireInfo->fence, kVulkanObjectTypeFence, true, VALIDATION_ERROR_00008801, VALIDATION_ERROR_00000009); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); |
| |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pPropertyCount, |
| VkDisplayPropertiesKHR* pProperties); |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pPropertyCount, |
| VkDisplayPlanePropertiesKHR* pProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2b627a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t planeIndex, |
| uint32_t* pDisplayCount, |
| VkDisplayKHR* pDisplays) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_29c27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); |
| |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| uint32_t* pPropertyCount, |
| VkDisplayModePropertiesKHR* pProperties); |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display, |
| const VkDisplayModeCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDisplayModeKHR* pMode) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_1fe27a01, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, VALIDATION_ERROR_1fe06001, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(physicalDevice, *pMode, kVulkanObjectTypeDisplayModeKHR, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayModeKHR mode, |
| uint32_t planeIndex, |
| VkDisplayPlaneCapabilitiesKHR* pCapabilities) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_29a27a01, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(physicalDevice, mode, kVulkanObjectTypeDisplayModeKHR, false, VALIDATION_ERROR_29a0ce01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR( |
| VkInstance instance, |
| const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2000bc01, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfo) { |
| skip |= ValidateObject(instance, pCreateInfo->displayMode, kVulkanObjectTypeDisplayModeKHR, false, VALIDATION_ERROR_07806401, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR( |
| VkDevice device, |
| uint32_t swapchainCount, |
| const VkSwapchainCreateInfoKHR* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchains) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_22805601, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfos) { |
| for (uint32_t index0 = 0; index0 < swapchainCount; ++index0) { |
| skip |= ValidateObject(device, pCreateInfos[index0].surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_1462ec01, VALIDATION_ERROR_14600009); |
| skip |= ValidateObject(device, pCreateInfos[index0].oldSwapchain, kVulkanObjectTypeSwapchainKHR, true, VALIDATION_ERROR_1460de01, VALIDATION_ERROR_1460de07); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| for (uint32_t index = 0; index < swapchainCount; index++) { |
| CreateObject(device, pSwapchains[index], kVulkanObjectTypeSwapchainKHR, pAllocator); |
| } |
| } |
| return result; |
| } |
| |
| #ifdef VK_USE_PLATFORM_XLIB_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR( |
| VkInstance instance, |
| const VkXlibSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2340bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_XLIB_KHR |
| |
| #ifdef VK_USE_PLATFORM_XLIB_KHR |
| |
| VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex, |
| Display* dpy, |
| VisualID visualID) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2f627a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_FALSE; |
| VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_XLIB_KHR |
| |
| #ifdef VK_USE_PLATFORM_XCB_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR( |
| VkInstance instance, |
| const VkXcbSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2320bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_XCB_KHR |
| |
| #ifdef VK_USE_PLATFORM_XCB_KHR |
| |
| VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex, |
| xcb_connection_t* connection, |
| xcb_visualid_t visual_id) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2f427a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_FALSE; |
| VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_XCB_KHR |
| |
| #ifdef VK_USE_PLATFORM_WAYLAND_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR( |
| VkInstance instance, |
| const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_22e0bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WAYLAND_KHR |
| |
| #ifdef VK_USE_PLATFORM_WAYLAND_KHR |
| |
| VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex, |
| struct wl_display* display) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2f027a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_FALSE; |
| VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WAYLAND_KHR |
| |
| #ifdef VK_USE_PLATFORM_MIR_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateMirSurfaceKHR( |
| VkInstance instance, |
| const VkMirSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2160bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_MIR_KHR |
| |
| #ifdef VK_USE_PLATFORM_MIR_KHR |
| |
| VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceMirPresentationSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex, |
| MirConnection* connection) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2d227a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_FALSE; |
| VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceMirPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_MIR_KHR |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR( |
| VkInstance instance, |
| const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_1ea0bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR( |
| VkInstance instance, |
| const VkWin32SurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2300bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2f227a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_FALSE; |
| VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures2* pFeatures) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2c227a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties2* pProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2d827a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkFormatProperties2* pFormatProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2c627a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, |
| VkImageFormatProperties2* pImageFormatProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2cc27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); |
| |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, |
| VkQueueFamilyProperties2* pQueueFamilyProperties); |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties2* pMemoryProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2d027a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, |
| uint32_t* pPropertyCount, |
| VkSparseImageFormatProperties2* pProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2e027a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR( |
| VkDevice device, |
| uint32_t heapIndex, |
| uint32_t localDeviceIndex, |
| uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_28c05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t deviceMask) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1d002401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetDeviceMaskKHR(commandBuffer, deviceMask); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR( |
| VkCommandBuffer commandBuffer, |
| uint32_t baseGroupX, |
| uint32_t baseGroupY, |
| uint32_t baseGroupZ, |
| uint32_t groupCountX, |
| uint32_t groupCountY, |
| uint32_t groupCountZ) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19e02401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( |
| VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33405601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false, VALIDATION_ERROR_33402801, VALIDATION_ERROR_33402807); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->TrimCommandPoolKHR(device, commandPool, flags); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_27e0bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, |
| VkExternalBufferProperties* pExternalBufferProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2ba27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); |
| |
| } |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( |
| VkDevice device, |
| const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2ae05601, VALIDATION_ERROR_UNDEFINED); |
| if (pGetWin32HandleInfo) { |
| skip |= ValidateObject(device, pGetWin32HandleInfo->memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_3b40c601, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| HANDLE handle, |
| VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2b205601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( |
| VkDevice device, |
| const VkMemoryGetFdInfoKHR* pGetFdInfo, |
| int* pFd) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2aa05601, VALIDATION_ERROR_UNDEFINED); |
| if (pGetFdInfo) { |
| skip |= ValidateObject(device, pGetFdInfo->memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_3b20c601, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetMemoryFdKHR(device, pGetFdInfo, pFd); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| int fd, |
| VkMemoryFdPropertiesKHR* pMemoryFdProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2ac05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, |
| VkExternalSemaphoreProperties* pExternalSemaphoreProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2be27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); |
| |
| } |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( |
| VkDevice device, |
| const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30e05601, VALIDATION_ERROR_UNDEFINED); |
| if (pImportSemaphoreWin32HandleInfo) { |
| skip |= ValidateObject(device, pImportSemaphoreWin32HandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_0b62b801, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( |
| VkDevice device, |
| const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30405601, VALIDATION_ERROR_UNDEFINED); |
| if (pGetWin32HandleInfo) { |
| skip |= ValidateObject(device, pGetWin32HandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_3b02b801, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( |
| VkDevice device, |
| const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30c05601, VALIDATION_ERROR_UNDEFINED); |
| if (pImportSemaphoreFdInfo) { |
| skip |= ValidateObject(device, pImportSemaphoreFdInfo->semaphore, kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_0b42b801, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( |
| VkDevice device, |
| const VkSemaphoreGetFdInfoKHR* pGetFdInfo, |
| int* pFd) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30205601, VALIDATION_ERROR_UNDEFINED); |
| if (pGetFdInfo) { |
| skip |= ValidateObject(device, pGetFdInfo->semaphore, kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_3ae2b801, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetSemaphoreFdKHR(device, pGetFdInfo, pFd); |
| |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipelineLayout layout, |
| uint32_t set, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites); |
| |
| VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( |
| VkCommandBuffer commandBuffer, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| VkPipelineLayout layout, |
| uint32_t set, |
| const void* pData) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1c002401, VALIDATION_ERROR_1c000009); |
| skip |= ValidateObject(commandBuffer, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, false, VALIDATION_ERROR_1c005201, VALIDATION_ERROR_1c000009); |
| skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false, VALIDATION_ERROR_1c00be01, VALIDATION_ERROR_1c000009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR( |
| VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_1fa05601, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfo) { |
| skip |= ValidateObject(device, pCreateInfo->descriptorSetLayout, kVulkanObjectTypeDescriptorSetLayout, true, VALIDATION_ERROR_05204c01, VALIDATION_ERROR_05200009); |
| skip |= ValidateObject(device, pCreateInfo->pipelineLayout, kVulkanObjectTypePipelineLayout, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_05200009); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pDescriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR( |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_24805601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, true, VALIDATION_ERROR_24805201, VALIDATION_ERROR_24805207); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, pAllocator, VALIDATION_ERROR_248002c8, VALIDATION_ERROR_248002ca); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR( |
| VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33a05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, descriptorSet, kVulkanObjectTypeDescriptorSet, false, VALIDATION_ERROR_33a04801, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, descriptorUpdateTemplate, kVulkanObjectTypeDescriptorUpdateTemplate, false, VALIDATION_ERROR_33a05201, VALIDATION_ERROR_33a05207); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( |
| VkDevice device, |
| VkSwapchainKHR swapchain) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30a05601, VALIDATION_ERROR_30a00009); |
| skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_30a2f001, VALIDATION_ERROR_30a00009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetSwapchainStatusKHR(device, swapchain); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, |
| VkExternalFenceProperties* pExternalFenceProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_39a27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); |
| |
| } |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( |
| VkDevice device, |
| const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3aa05601, VALIDATION_ERROR_UNDEFINED); |
| if (pImportFenceWin32HandleInfo) { |
| skip |= ValidateObject(device, pImportFenceWin32HandleInfo->fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_3a408801, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( |
| VkDevice device, |
| const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, |
| HANDLE* pHandle) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3ac05601, VALIDATION_ERROR_UNDEFINED); |
| if (pGetWin32HandleInfo) { |
| skip |= ValidateObject(device, pGetWin32HandleInfo->fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_3a808801, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( |
| VkDevice device, |
| const VkImportFenceFdInfoKHR* pImportFenceFdInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3a005601, VALIDATION_ERROR_UNDEFINED); |
| if (pImportFenceFdInfo) { |
| skip |= ValidateObject(device, pImportFenceFdInfo->fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_39c08801, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->ImportFenceFdKHR(device, pImportFenceFdInfo); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( |
| VkDevice device, |
| const VkFenceGetFdInfoKHR* pGetFdInfo, |
| int* pFd) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3a205601, VALIDATION_ERROR_UNDEFINED); |
| if (pGetFdInfo) { |
| skip |= ValidateObject(device, pGetFdInfo->fence, kVulkanObjectTypeFence, false, VALIDATION_ERROR_39e08801, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetFenceFdKHR(device, pGetFdInfo, pFd); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR( |
| VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, |
| VkSurfaceCapabilities2KHR* pSurfaceCapabilities) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2e427a01, VALIDATION_ERROR_UNDEFINED); |
| if (pSurfaceInfo) { |
| skip |= ValidateObject(physicalDevice, pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_0ee2ec01, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->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; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2e827a01, VALIDATION_ERROR_UNDEFINED); |
| if (pSurfaceInfo) { |
| skip |= ValidateObject(physicalDevice, pSurfaceInfo->surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_0ee2ec01, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3c405601, VALIDATION_ERROR_UNDEFINED); |
| if (pInfo) { |
| skip |= ValidateObject(device, pInfo->image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_3bc0a001, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3c605601, VALIDATION_ERROR_UNDEFINED); |
| if (pInfo) { |
| skip |= ValidateObject(device, pInfo->buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_3ba01a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( |
| VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3c805601, VALIDATION_ERROR_UNDEFINED); |
| if (pInfo) { |
| skip |= ValidateObject(device, pInfo->image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_3be0a001, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR( |
| VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3fe05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pYcbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR( |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_40405601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, true, VALIDATION_ERROR_4043e201, VALIDATION_ERROR_4043e207); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, ycbcrConversion, kVulkanObjectTypeSamplerYcbcrConversion, pAllocator, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_17205601, VALIDATION_ERROR_UNDEFINED); |
| if (pBindInfos) { |
| for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) { |
| skip |= ValidateObject(device, pBindInfos[index0].buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_00c01a01, VALIDATION_ERROR_00c00009); |
| skip |= ValidateObject(device, pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_00c0c601, VALIDATION_ERROR_00c00009); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->BindBufferMemory2KHR(device, bindInfoCount, pBindInfos); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR( |
| VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_17605601, VALIDATION_ERROR_UNDEFINED); |
| if (pBindInfos) { |
| for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) { |
| skip |= ValidateObject(device, pBindInfos[index0].image, kVulkanObjectTypeImage, false, VALIDATION_ERROR_00e0a001, VALIDATION_ERROR_00e00009); |
| skip |= ValidateObject(device, pBindInfos[index0].memory, kVulkanObjectTypeDeviceMemory, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_00e00009); |
| } |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->BindImageMemory2KHR(device, bindInfoCount, pBindInfos); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR( |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_43205601, VALIDATION_ERROR_UNDEFINED); |
| if (pCreateInfo) { |
| if (pCreateInfo->pBindings) { |
| for (uint32_t index1 = 0; index1 < pCreateInfo->bindingCount; ++index1) { |
| for (uint32_t index2 = 0; index2 < pCreateInfo->pBindings[index1].descriptorCount; ++index2) { |
| skip |= ValidateObject(device, pCreateInfo->pBindings[index1].pImmutableSamplers[index2], kVulkanObjectTypeSampler, true, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| } |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->GetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); |
| |
| } |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateMagmaSurfaceKHR( |
| VkInstance instance, |
| const VkMagmaSurfaceCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateMagmaSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceMagmaPresentationSupportKHR( |
| VkPhysicalDevice physicalDevice, |
| uint32_t queueFamilyIndex) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_FALSE; |
| VkBool32 result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceMagmaPresentationSupportKHR(physicalDevice, queueFamilyIndex); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( |
| VkInstance instance, |
| const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugReportCallbackEXT* pCallback); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( |
| VkInstance instance, |
| VkDebugReportCallbackEXT callback, |
| const VkAllocationCallbacks* pAllocator); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT( |
| VkInstance instance, |
| VkDebugReportFlagsEXT flags, |
| VkDebugReportObjectTypeEXT objectType, |
| uint64_t object, |
| size_t location, |
| int32_t messageCode, |
| const char* pLayerPrefix, |
| const char* pMessage); |
| |
| VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( |
| VkDevice device, |
| const VkDebugMarkerObjectTagInfoEXT* pTagInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_23805601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->DebugMarkerSetObjectTagEXT(device, pTagInfo); |
| |
| return result; |
| } |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( |
| VkDevice device, |
| const VkDebugMarkerObjectNameInfoEXT* pNameInfo); |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19602401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT( |
| VkCommandBuffer commandBuffer) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19802401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDebugMarkerEndEXT(commandBuffer); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_19a02401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1ac02401, VALIDATION_ERROR_1ac00009); |
| skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1ac01a01, VALIDATION_ERROR_1ac00009); |
| skip |= ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1ac03401, VALIDATION_ERROR_1ac00009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD( |
| VkCommandBuffer commandBuffer, |
| VkBuffer buffer, |
| VkDeviceSize offset, |
| VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, |
| uint32_t stride) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1a802401, VALIDATION_ERROR_1a800009); |
| skip |= ValidateObject(commandBuffer, buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1a801a01, VALIDATION_ERROR_1a800009); |
| skip |= ValidateObject(commandBuffer, countBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_1a803401, VALIDATION_ERROR_1a800009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD( |
| VkDevice device, |
| VkPipeline pipeline, |
| VkShaderStageFlagBits shaderStage, |
| VkShaderInfoTypeAMD infoType, |
| size_t* pInfoSize, |
| void* pInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_40e05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, pipeline, kVulkanObjectTypePipeline, false, VALIDATION_ERROR_40e27c01, VALIDATION_ERROR_40e27c07); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( |
| VkPhysicalDevice physicalDevice, |
| VkFormat format, |
| VkImageType type, |
| VkImageTiling tiling, |
| VkImageUsageFlags usage, |
| VkImageCreateFlags flags, |
| VkExternalMemoryHandleTypeFlagsNV externalHandleType, |
| VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2bc27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); |
| |
| return result; |
| } |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV( |
| VkDevice device, |
| VkDeviceMemory memory, |
| VkExternalMemoryHandleTypeFlagsNV handleType, |
| HANDLE* pHandle) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2b005601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_2b00c601, VALIDATION_ERROR_2b00c607); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetMemoryWin32HandleNV(device, memory, handleType, pHandle); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| #ifdef VK_USE_PLATFORM_VI_NN |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN( |
| VkInstance instance, |
| const VkViSurfaceCreateInfoNN* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_22c0bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_VI_NN |
| |
| VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX( |
| VkCommandBuffer commandBuffer, |
| const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1ba02401, VALIDATION_ERROR_UNDEFINED); |
| if (pProcessCommandsInfo) { |
| skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->objectTable, kVulkanObjectTypeObjectTableNVX, false, VALIDATION_ERROR_0220d801, VALIDATION_ERROR_02200009); |
| skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX, false, VALIDATION_ERROR_0220b401, VALIDATION_ERROR_02200009); |
| if (pProcessCommandsInfo->pIndirectCommandsTokens) { |
| for (uint32_t index1 = 0; index1 < pProcessCommandsInfo->indirectCommandsTokenCount; ++index1) { |
| skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->pIndirectCommandsTokens[index1].buffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_0bc01a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->targetCommandBuffer, kVulkanObjectTypeCommandBuffer, true, VALIDATION_ERROR_0222f601, VALIDATION_ERROR_02200009); |
| skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->sequencesCountBuffer, kVulkanObjectTypeBuffer, true, VALIDATION_ERROR_0222ba01, VALIDATION_ERROR_02200009); |
| skip |= ValidateObject(commandBuffer, pProcessCommandsInfo->sequencesIndexBuffer, kVulkanObjectTypeBuffer, true, VALIDATION_ERROR_0222bc01, VALIDATION_ERROR_02200009); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX( |
| VkCommandBuffer commandBuffer, |
| const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1c202401, VALIDATION_ERROR_UNDEFINED); |
| if (pReserveSpaceInfo) { |
| skip |= ValidateObject(commandBuffer, pReserveSpaceInfo->objectTable, kVulkanObjectTypeObjectTableNVX, false, VALIDATION_ERROR_0240d801, VALIDATION_ERROR_02400009); |
| skip |= ValidateObject(commandBuffer, pReserveSpaceInfo->indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX, false, VALIDATION_ERROR_0240b401, VALIDATION_ERROR_02400009); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX( |
| VkDevice device, |
| const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_21005601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pIndirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX( |
| VkDevice device, |
| VkIndirectCommandsLayoutNVX indirectCommandsLayout, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25605601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX, false, VALIDATION_ERROR_2560b401, VALIDATION_ERROR_2560b407); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, indirectCommandsLayout, kVulkanObjectTypeIndirectCommandsLayoutNVX, pAllocator, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX( |
| VkDevice device, |
| const VkObjectTableCreateInfoNVX* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkObjectTableNVX* pObjectTable) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_21805601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pObjectTable, kVulkanObjectTypeObjectTableNVX, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX( |
| VkDevice device, |
| VkObjectTableNVX objectTable, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_25a05601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, objectTable, kVulkanObjectTypeObjectTableNVX, false, VALIDATION_ERROR_25a0d801, VALIDATION_ERROR_25a0d807); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, objectTable, kVulkanObjectTypeObjectTableNVX, pAllocator, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyObjectTableNVX(device, objectTable, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX( |
| VkDevice device, |
| VkObjectTableNVX objectTable, |
| uint32_t objectCount, |
| const VkObjectTableEntryNVX* const* ppObjectTableEntries, |
| const uint32_t* pObjectIndices) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_32205601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, objectTable, kVulkanObjectTypeObjectTableNVX, false, VALIDATION_ERROR_3220d801, VALIDATION_ERROR_3220d807); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX( |
| VkDevice device, |
| VkObjectTableNVX objectTable, |
| uint32_t objectCount, |
| const VkObjectEntryTypeNVX* pObjectEntryTypes, |
| const uint32_t* pObjectIndices) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33805601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, objectTable, kVulkanObjectTypeObjectTableNVX, false, VALIDATION_ERROR_3380d801, VALIDATION_ERROR_3380d807); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX( |
| VkPhysicalDevice physicalDevice, |
| VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, |
| VkDeviceGeneratedCommandsLimitsNVX* pLimits) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2c827a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstViewport, |
| uint32_t viewportCount, |
| const VkViewportWScalingNV* pViewportWScalings) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1e202401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| VkDisplayKHR display) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_32427a01, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, VALIDATION_ERROR_32406001, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->ReleaseDisplayEXT(physicalDevice, display); |
| |
| return result; |
| } |
| |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| Display* dpy, |
| VkDisplayKHR display) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_16627a01, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false, VALIDATION_ERROR_16606001, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->AcquireXlibDisplayEXT(physicalDevice, dpy, display); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( |
| VkPhysicalDevice physicalDevice, |
| Display* dpy, |
| RROutput rrOutput, |
| VkDisplayKHR* pDisplay) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2fc27a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, |
| VkSurfaceCapabilities2EXT* pSurfaceCapabilities) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_2e227a01, VALIDATION_ERROR_2e200009); |
| skip |= ValidateObject(physicalDevice, surface, kVulkanObjectTypeSurfaceKHR, false, VALIDATION_ERROR_2e22ec01, VALIDATION_ERROR_2e200009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( |
| VkDevice device, |
| VkDisplayKHR display, |
| const VkDisplayPowerInfoEXT* pDisplayPowerInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_27205601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, display, kVulkanObjectTypeDisplayKHR, false, VALIDATION_ERROR_27206001, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->DisplayPowerControlEXT(device, display, pDisplayPowerInfo); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT( |
| VkDevice device, |
| const VkDeviceEventInfoEXT* pDeviceEventInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_31e05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pFence, kVulkanObjectTypeFence, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT( |
| VkDevice device, |
| VkDisplayKHR display, |
| const VkDisplayEventInfoEXT* pDisplayEventInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFence* pFence) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_32005601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, display, kVulkanObjectTypeDisplayKHR, false, VALIDATION_ERROR_32006001, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pFence, kVulkanObjectTypeFence, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkSurfaceCounterFlagBitsEXT counter, |
| uint64_t* pCounterValue) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_30605601, VALIDATION_ERROR_30600009); |
| skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_3062f001, VALIDATION_ERROR_30600009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2fe05601, VALIDATION_ERROR_2fe00009); |
| skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_2fe2f001, VALIDATION_ERROR_2fe00009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE( |
| VkDevice device, |
| VkSwapchainKHR swapchain, |
| uint32_t* pPresentationTimingCount, |
| VkPastPresentationTimingGOOGLE* pPresentationTimings) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_2b405601, VALIDATION_ERROR_2b400009); |
| skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_2b42f001, VALIDATION_ERROR_2b400009); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT( |
| VkCommandBuffer commandBuffer, |
| uint32_t firstDiscardRectangle, |
| uint32_t discardRectangleCount, |
| const VkRect2D* pDiscardRectangles) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_1d202401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT( |
| VkDevice device, |
| uint32_t swapchainCount, |
| const VkSwapchainKHR* pSwapchains, |
| const VkHdrMetadataEXT* pMetadata) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_33205601, VALIDATION_ERROR_33200009); |
| for (uint32_t index0 = 0; index0 < swapchainCount; ++index0) { |
| skip |= ValidateObject(device, pSwapchains[index0], kVulkanObjectTypeSwapchainKHR, false, VALIDATION_ERROR_33225801, VALIDATION_ERROR_33200009); |
| } |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); |
| |
| } |
| |
| #ifdef VK_USE_PLATFORM_IOS_MVK |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK( |
| VkInstance instance, |
| const VkIOSSurfaceCreateInfoMVK* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_20a0bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_IOS_MVK |
| |
| #ifdef VK_USE_PLATFORM_MACOS_MVK |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK( |
| VkInstance instance, |
| const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_2140bc01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_MACOS_MVK |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT( |
| VkDevice device, |
| const VkDebugUtilsObjectNameInfoEXT* pNameInfo); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT( |
| VkDevice device, |
| const VkDebugUtilsObjectTagInfoEXT* pTagInfo); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT( |
| VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT( |
| VkQueue queue); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT( |
| VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT( |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo); |
| |
| // Declare only |
| VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT( |
| VkInstance instance, |
| const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugUtilsMessengerEXT* pMessenger); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT( |
| VkInstance instance, |
| VkDebugUtilsMessengerEXT messenger, |
| const VkAllocationCallbacks* pAllocator); |
| |
| // Declare only |
| VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT( |
| VkInstance instance, |
| VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VkDebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID( |
| VkDevice device, |
| const struct AHardwareBuffer* buffer, |
| VkAndroidHardwareBufferPropertiesANDROID* pProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_45205601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID( |
| VkDevice device, |
| const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, |
| struct AHardwareBuffer** pBuffer) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_45a05601, VALIDATION_ERROR_UNDEFINED); |
| if (pInfo) { |
| skip |= ValidateObject(device, pInfo->memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_ANDROID_KHR |
| |
| VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT( |
| VkCommandBuffer commandBuffer, |
| const VkSampleLocationsInfoEXT* pSampleLocationsInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_3e202401, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); |
| |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT( |
| VkPhysicalDevice physicalDevice, |
| VkSampleCountFlagBits samples, |
| VkMultisamplePropertiesEXT* pMultisampleProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false, VALIDATION_ERROR_3d827a01, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_instance_table_map, physicalDevice)->GetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT( |
| VkDevice device, |
| const VkValidationCacheCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkValidationCacheEXT* pValidationCache) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3de05601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pValidationCache, kVulkanObjectTypeValidationCacheEXT, pAllocator); |
| } |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT( |
| VkDevice device, |
| VkValidationCacheEXT validationCache, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3e405601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, validationCache, kVulkanObjectTypeValidationCacheEXT, true, VALIDATION_ERROR_3e43c401, VALIDATION_ERROR_3e43c407); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, validationCache, kVulkanObjectTypeValidationCacheEXT, pAllocator, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyValidationCacheEXT(device, validationCache, pAllocator); |
| |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT( |
| VkDevice device, |
| VkValidationCacheEXT dstCache, |
| uint32_t srcCacheCount, |
| const VkValidationCacheEXT* pSrcCaches) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3e605601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, dstCache, kVulkanObjectTypeValidationCacheEXT, false, VALIDATION_ERROR_3e606e01, VALIDATION_ERROR_3e606e07); |
| for (uint32_t index0 = 0; index0 < srcCacheCount; ++index0) { |
| skip |= ValidateObject(device, pSrcCaches[index0], kVulkanObjectTypeValidationCacheEXT, false, VALIDATION_ERROR_3e623c01, VALIDATION_ERROR_3e623c07); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->MergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT( |
| VkDevice device, |
| VkValidationCacheEXT validationCache, |
| size_t* pDataSize, |
| void* pData) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_3e005601, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, validationCache, kVulkanObjectTypeValidationCacheEXT, false, VALIDATION_ERROR_3e03c401, VALIDATION_ERROR_3e03c407); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetValidationCacheDataEXT(device, validationCache, pDataSize, pData); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| const void* pHostPointer, |
| VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_41805601, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); |
| |
| return result; |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, |
| uint32_t marker) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, VALIDATION_ERROR_41e02401, VALIDATION_ERROR_41e00009); |
| skip |= ValidateObject(commandBuffer, dstBuffer, kVulkanObjectTypeBuffer, false, VALIDATION_ERROR_41e06c01, VALIDATION_ERROR_41e00009); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, commandBuffer)->CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); |
| |
| } |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA( |
| VkInstance instance, |
| const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSurfaceKHR* pSurface) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_instance_table_map, instance)->CreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(instance, *pSurface, kVulkanObjectTypeSurfaceKHR, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA( |
| VkDevice device, |
| const VkBufferCollectionCreateInfoFUCHSIA* pImportInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBufferCollectionFUCHSIA* pCollection) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->CreateBufferCollectionFUCHSIA(device, pImportInfo, pAllocator, pCollection); |
| if (VK_SUCCESS == result) { |
| std::lock_guard<std::mutex> lock(global_lock); |
| CreateObject(device, *pCollection, kVulkanObjectTypeBufferCollectionFUCHSIA, pAllocator); |
| } |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionConstraintsFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| const VkImageCreateInfo* pImageInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, collection, kVulkanObjectTypeBufferCollectionFUCHSIA, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->SetBufferCollectionConstraintsFUCHSIA(device, collection, pImageInfo); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| bool skip = false; |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, collection, kVulkanObjectTypeBufferCollectionFUCHSIA, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| if (skip) return; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| DestroyObject(device, collection, kVulkanObjectTypeBufferCollectionFUCHSIA, pAllocator, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return; |
| get_dispatch_table(ot_device_table_map, device)->DestroyBufferCollectionFUCHSIA(device, collection, pAllocator); |
| |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA( |
| VkDevice device, |
| VkBufferCollectionFUCHSIA collection, |
| VkBufferCollectionPropertiesFUCHSIA* pProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| skip |= ValidateObject(device, collection, kVulkanObjectTypeBufferCollectionFUCHSIA, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA( |
| VkDevice device, |
| const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, |
| zx_handle_t* pZirconHandle) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| if (pGetZirconHandleInfo) { |
| skip |= ValidateObject(device, pGetZirconHandleInfo->memory, kVulkanObjectTypeDeviceMemory, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA( |
| VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, |
| zx_handle_t ZirconHandle, |
| VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, ZirconHandle, pMemoryZirconHandleProperties); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA( |
| VkDevice device, |
| const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| if (pImportSemaphoreZirconHandleInfo) { |
| skip |= ValidateObject(device, pImportSemaphoreZirconHandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->ImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| |
| VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA( |
| VkDevice device, |
| const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, |
| zx_handle_t* pZirconHandle) |
| { |
| bool skip = false; |
| { |
| std::lock_guard<std::mutex> lock(global_lock); |
| skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| if (pGetZirconHandleInfo) { |
| skip |= ValidateObject(device, pGetZirconHandleInfo->semaphore, kVulkanObjectTypeSemaphore, false, VALIDATION_ERROR_UNDEFINED, VALIDATION_ERROR_UNDEFINED); |
| } |
| } |
| if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; |
| VkResult result = get_dispatch_table(ot_device_table_map, device)->GetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); |
| |
| return result; |
| } |
| #endif // VK_USE_PLATFORM_FUCHSIA |
| // Map of all APIs to be intercepted by this layer |
| const std::unordered_map<std::string, void*> name_to_funcptr_map = { |
| {"vkCreateInstance", (void *)CreateInstance}, |
| {"vkDestroyInstance", (void *)DestroyInstance}, |
| {"vkEnumeratePhysicalDevices", (void *)EnumeratePhysicalDevices}, |
| {"vkGetPhysicalDeviceFeatures", (void*)GetPhysicalDeviceFeatures}, |
| {"vkGetPhysicalDeviceFormatProperties", (void*)GetPhysicalDeviceFormatProperties}, |
| {"vkGetPhysicalDeviceImageFormatProperties", (void*)GetPhysicalDeviceImageFormatProperties}, |
| {"vkGetPhysicalDeviceProperties", (void*)GetPhysicalDeviceProperties}, |
| {"vkGetPhysicalDeviceQueueFamilyProperties", (void *)GetPhysicalDeviceQueueFamilyProperties}, |
| {"vkGetPhysicalDeviceMemoryProperties", (void*)GetPhysicalDeviceMemoryProperties}, |
| {"vkGetInstanceProcAddr", (void *)GetInstanceProcAddr}, |
| {"vkGetDeviceProcAddr", (void *)GetDeviceProcAddr}, |
| {"vkCreateDevice", (void *)CreateDevice}, |
| {"vkDestroyDevice", (void *)DestroyDevice}, |
| {"vkEnumerateInstanceExtensionProperties", (void *)EnumerateInstanceExtensionProperties}, |
| {"vkEnumerateDeviceExtensionProperties", (void *)EnumerateDeviceExtensionProperties}, |
| {"vkEnumerateInstanceLayerProperties", (void *)EnumerateInstanceLayerProperties}, |
| {"vkEnumerateDeviceLayerProperties", (void *)EnumerateDeviceLayerProperties}, |
| {"vkGetDeviceQueue", (void *)GetDeviceQueue}, |
| {"vkQueueSubmit", (void*)QueueSubmit}, |
| {"vkQueueWaitIdle", (void*)QueueWaitIdle}, |
| {"vkDeviceWaitIdle", (void*)DeviceWaitIdle}, |
| {"vkAllocateMemory", (void*)AllocateMemory}, |
| {"vkFreeMemory", (void*)FreeMemory}, |
| {"vkMapMemory", (void*)MapMemory}, |
| {"vkUnmapMemory", (void*)UnmapMemory}, |
| {"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges}, |
| {"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges}, |
| {"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment}, |
| {"vkBindBufferMemory", (void*)BindBufferMemory}, |
| {"vkBindImageMemory", (void*)BindImageMemory}, |
| {"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements}, |
| {"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements}, |
| {"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements}, |
| {"vkGetPhysicalDeviceSparseImageFormatProperties", (void*)GetPhysicalDeviceSparseImageFormatProperties}, |
| {"vkQueueBindSparse", (void*)QueueBindSparse}, |
| {"vkCreateFence", (void*)CreateFence}, |
| {"vkDestroyFence", (void*)DestroyFence}, |
| {"vkResetFences", (void*)ResetFences}, |
| {"vkGetFenceStatus", (void*)GetFenceStatus}, |
| {"vkWaitForFences", (void*)WaitForFences}, |
| {"vkCreateSemaphore", (void*)CreateSemaphore}, |
| {"vkDestroySemaphore", (void*)DestroySemaphore}, |
| {"vkCreateEvent", (void*)CreateEvent}, |
| {"vkDestroyEvent", (void*)DestroyEvent}, |
| {"vkGetEventStatus", (void*)GetEventStatus}, |
| {"vkSetEvent", (void*)SetEvent}, |
| {"vkResetEvent", (void*)ResetEvent}, |
| {"vkCreateQueryPool", (void*)CreateQueryPool}, |
| {"vkDestroyQueryPool", (void*)DestroyQueryPool}, |
| {"vkGetQueryPoolResults", (void*)GetQueryPoolResults}, |
| {"vkCreateBuffer", (void*)CreateBuffer}, |
| {"vkDestroyBuffer", (void*)DestroyBuffer}, |
| {"vkCreateBufferView", (void*)CreateBufferView}, |
| {"vkDestroyBufferView", (void*)DestroyBufferView}, |
| {"vkCreateImage", (void*)CreateImage}, |
| {"vkDestroyImage", (void*)DestroyImage}, |
| {"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout}, |
| {"vkCreateImageView", (void*)CreateImageView}, |
| {"vkDestroyImageView", (void*)DestroyImageView}, |
| {"vkCreateShaderModule", (void*)CreateShaderModule}, |
| {"vkDestroyShaderModule", (void*)DestroyShaderModule}, |
| {"vkCreatePipelineCache", (void*)CreatePipelineCache}, |
| {"vkDestroyPipelineCache", (void*)DestroyPipelineCache}, |
| {"vkGetPipelineCacheData", (void*)GetPipelineCacheData}, |
| {"vkMergePipelineCaches", (void*)MergePipelineCaches}, |
| {"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines}, |
| {"vkCreateComputePipelines", (void *)CreateComputePipelines}, |
| {"vkDestroyPipeline", (void*)DestroyPipeline}, |
| {"vkCreatePipelineLayout", (void*)CreatePipelineLayout}, |
| {"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout}, |
| {"vkCreateSampler", (void*)CreateSampler}, |
| {"vkDestroySampler", (void*)DestroySampler}, |
| {"vkCreateDescriptorSetLayout", (void *)CreateDescriptorSetLayout}, |
| {"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout}, |
| {"vkCreateDescriptorPool", (void*)CreateDescriptorPool}, |
| {"vkDestroyDescriptorPool", (void *)DestroyDescriptorPool}, |
| {"vkResetDescriptorPool", (void *)ResetDescriptorPool}, |
| {"vkAllocateDescriptorSets", (void *)AllocateDescriptorSets}, |
| {"vkFreeDescriptorSets", (void *)FreeDescriptorSets}, |
| {"vkUpdateDescriptorSets", (void *)UpdateDescriptorSets}, |
| {"vkCreateFramebuffer", (void*)CreateFramebuffer}, |
| {"vkDestroyFramebuffer", (void*)DestroyFramebuffer}, |
| {"vkCreateRenderPass", (void*)CreateRenderPass}, |
| {"vkDestroyRenderPass", (void*)DestroyRenderPass}, |
| {"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity}, |
| {"vkCreateCommandPool", (void*)CreateCommandPool}, |
| {"vkDestroyCommandPool", (void *)DestroyCommandPool}, |
| {"vkResetCommandPool", (void*)ResetCommandPool}, |
| {"vkAllocateCommandBuffers", (void *)AllocateCommandBuffers}, |
| {"vkFreeCommandBuffers", (void *)FreeCommandBuffers}, |
| {"vkBeginCommandBuffer", (void *)BeginCommandBuffer}, |
| {"vkEndCommandBuffer", (void*)EndCommandBuffer}, |
| {"vkResetCommandBuffer", (void*)ResetCommandBuffer}, |
| {"vkCmdBindPipeline", (void*)CmdBindPipeline}, |
| {"vkCmdSetViewport", (void*)CmdSetViewport}, |
| {"vkCmdSetScissor", (void*)CmdSetScissor}, |
| {"vkCmdSetLineWidth", (void*)CmdSetLineWidth}, |
| {"vkCmdSetDepthBias", (void*)CmdSetDepthBias}, |
| {"vkCmdSetBlendConstants", (void*)CmdSetBlendConstants}, |
| {"vkCmdSetDepthBounds", (void*)CmdSetDepthBounds}, |
| {"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask}, |
| {"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask}, |
| {"vkCmdSetStencilReference", (void*)CmdSetStencilReference}, |
| {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets}, |
| {"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer}, |
| {"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers}, |
| {"vkCmdDraw", (void*)CmdDraw}, |
| {"vkCmdDrawIndexed", (void*)CmdDrawIndexed}, |
| {"vkCmdDrawIndirect", (void*)CmdDrawIndirect}, |
| {"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect}, |
| {"vkCmdDispatch", (void*)CmdDispatch}, |
| {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect}, |
| {"vkCmdCopyBuffer", (void*)CmdCopyBuffer}, |
| {"vkCmdCopyImage", (void*)CmdCopyImage}, |
| {"vkCmdBlitImage", (void*)CmdBlitImage}, |
| {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage}, |
| {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer}, |
| {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer}, |
| {"vkCmdFillBuffer", (void*)CmdFillBuffer}, |
| {"vkCmdClearColorImage", (void*)CmdClearColorImage}, |
| {"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage}, |
| {"vkCmdClearAttachments", (void*)CmdClearAttachments}, |
| {"vkCmdResolveImage", (void*)CmdResolveImage}, |
| {"vkCmdSetEvent", (void*)CmdSetEvent}, |
| {"vkCmdResetEvent", (void*)CmdResetEvent}, |
| {"vkCmdWaitEvents", (void*)CmdWaitEvents}, |
| {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier}, |
| {"vkCmdBeginQuery", (void*)CmdBeginQuery}, |
| {"vkCmdEndQuery", (void*)CmdEndQuery}, |
| {"vkCmdResetQueryPool", (void*)CmdResetQueryPool}, |
| {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp}, |
| {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults}, |
| {"vkCmdPushConstants", (void*)CmdPushConstants}, |
| {"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass}, |
| {"vkCmdNextSubpass", (void*)CmdNextSubpass}, |
| {"vkCmdEndRenderPass", (void*)CmdEndRenderPass}, |
| {"vkCmdExecuteCommands", (void*)CmdExecuteCommands}, |
| {"vkBindBufferMemory2", (void*)BindBufferMemory2}, |
| {"vkBindImageMemory2", (void*)BindImageMemory2}, |
| {"vkGetDeviceGroupPeerMemoryFeatures", (void*)GetDeviceGroupPeerMemoryFeatures}, |
| {"vkCmdSetDeviceMask", (void*)CmdSetDeviceMask}, |
| {"vkCmdDispatchBase", (void*)CmdDispatchBase}, |
| {"vkEnumeratePhysicalDeviceGroups", (void*)EnumeratePhysicalDeviceGroups}, |
| {"vkGetImageMemoryRequirements2", (void*)GetImageMemoryRequirements2}, |
| {"vkGetBufferMemoryRequirements2", (void*)GetBufferMemoryRequirements2}, |
| {"vkGetImageSparseMemoryRequirements2", (void*)GetImageSparseMemoryRequirements2}, |
| {"vkGetPhysicalDeviceFeatures2", (void*)GetPhysicalDeviceFeatures2}, |
| {"vkGetPhysicalDeviceProperties2", (void*)GetPhysicalDeviceProperties2}, |
| {"vkGetPhysicalDeviceFormatProperties2", (void*)GetPhysicalDeviceFormatProperties2}, |
| {"vkGetPhysicalDeviceImageFormatProperties2", (void*)GetPhysicalDeviceImageFormatProperties2}, |
| {"vkGetPhysicalDeviceQueueFamilyProperties2", (void *)GetPhysicalDeviceQueueFamilyProperties2}, |
| {"vkGetPhysicalDeviceMemoryProperties2", (void*)GetPhysicalDeviceMemoryProperties2}, |
| {"vkGetPhysicalDeviceSparseImageFormatProperties2", (void*)GetPhysicalDeviceSparseImageFormatProperties2}, |
| {"vkTrimCommandPool", (void*)TrimCommandPool}, |
| {"vkGetDeviceQueue2", (void *)GetDeviceQueue2}, |
| {"vkCreateSamplerYcbcrConversion", (void*)CreateSamplerYcbcrConversion}, |
| {"vkDestroySamplerYcbcrConversion", (void*)DestroySamplerYcbcrConversion}, |
| {"vkCreateDescriptorUpdateTemplate", (void*)CreateDescriptorUpdateTemplate}, |
| {"vkDestroyDescriptorUpdateTemplate", (void*)DestroyDescriptorUpdateTemplate}, |
| {"vkUpdateDescriptorSetWithTemplate", (void*)UpdateDescriptorSetWithTemplate}, |
| {"vkGetPhysicalDeviceExternalBufferProperties", (void*)GetPhysicalDeviceExternalBufferProperties}, |
| {"vkGetPhysicalDeviceExternalFenceProperties", (void*)GetPhysicalDeviceExternalFenceProperties}, |
| {"vkGetPhysicalDeviceExternalSemaphoreProperties", (void*)GetPhysicalDeviceExternalSemaphoreProperties}, |
| {"vkGetDescriptorSetLayoutSupport", (void*)GetDescriptorSetLayoutSupport}, |
| {"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR}, |
| {"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR}, |
| {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR}, |
| {"vkGetPhysicalDeviceSurfaceFormatsKHR", (void*)GetPhysicalDeviceSurfaceFormatsKHR}, |
| {"vkGetPhysicalDeviceSurfacePresentModesKHR", (void*)GetPhysicalDeviceSurfacePresentModesKHR}, |
| {"vkCreateSwapchainKHR", (void*)CreateSwapchainKHR}, |
| {"vkDestroySwapchainKHR", (void *)DestroySwapchainKHR}, |
| {"vkGetSwapchainImagesKHR", (void *)GetSwapchainImagesKHR}, |
| {"vkAcquireNextImageKHR", (void*)AcquireNextImageKHR}, |
| {"vkQueuePresentKHR", (void*)QueuePresentKHR}, |
| {"vkGetDeviceGroupPresentCapabilitiesKHR", (void*)GetDeviceGroupPresentCapabilitiesKHR}, |
| {"vkGetDeviceGroupSurfacePresentModesKHR", (void*)GetDeviceGroupSurfacePresentModesKHR}, |
| {"vkGetPhysicalDevicePresentRectanglesKHR", (void*)GetPhysicalDevicePresentRectanglesKHR}, |
| {"vkAcquireNextImage2KHR", (void*)AcquireNextImage2KHR}, |
| {"vkGetPhysicalDeviceDisplayPropertiesKHR", (void *)GetPhysicalDeviceDisplayPropertiesKHR}, |
| {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", (void*)GetPhysicalDeviceDisplayPlanePropertiesKHR}, |
| {"vkGetDisplayPlaneSupportedDisplaysKHR", (void*)GetDisplayPlaneSupportedDisplaysKHR}, |
| {"vkGetDisplayModePropertiesKHR", (void *)GetDisplayModePropertiesKHR}, |
| {"vkCreateDisplayModeKHR", (void*)CreateDisplayModeKHR}, |
| {"vkGetDisplayPlaneCapabilitiesKHR", (void*)GetDisplayPlaneCapabilitiesKHR}, |
| {"vkCreateDisplayPlaneSurfaceKHR", (void*)CreateDisplayPlaneSurfaceKHR}, |
| {"vkCreateSharedSwapchainsKHR", (void*)CreateSharedSwapchainsKHR}, |
| #ifdef VK_USE_PLATFORM_XLIB_KHR |
| {"vkCreateXlibSurfaceKHR", (void*)CreateXlibSurfaceKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_XLIB_KHR |
| {"vkGetPhysicalDeviceXlibPresentationSupportKHR", (void*)GetPhysicalDeviceXlibPresentationSupportKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_XCB_KHR |
| {"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_XCB_KHR |
| {"vkGetPhysicalDeviceXcbPresentationSupportKHR", (void*)GetPhysicalDeviceXcbPresentationSupportKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_WAYLAND_KHR |
| {"vkCreateWaylandSurfaceKHR", (void*)CreateWaylandSurfaceKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_WAYLAND_KHR |
| {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (void*)GetPhysicalDeviceWaylandPresentationSupportKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_MIR_KHR |
| {"vkCreateMirSurfaceKHR", (void*)CreateMirSurfaceKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_MIR_KHR |
| {"vkGetPhysicalDeviceMirPresentationSupportKHR", (void*)GetPhysicalDeviceMirPresentationSupportKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| {"vkCreateAndroidSurfaceKHR", (void*)CreateAndroidSurfaceKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| {"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| {"vkGetPhysicalDeviceWin32PresentationSupportKHR", (void*)GetPhysicalDeviceWin32PresentationSupportKHR}, |
| #endif |
| {"vkGetPhysicalDeviceFeatures2KHR", (void*)GetPhysicalDeviceFeatures2KHR}, |
| {"vkGetPhysicalDeviceProperties2KHR", (void*)GetPhysicalDeviceProperties2KHR}, |
| {"vkGetPhysicalDeviceFormatProperties2KHR", (void*)GetPhysicalDeviceFormatProperties2KHR}, |
| {"vkGetPhysicalDeviceImageFormatProperties2KHR", (void*)GetPhysicalDeviceImageFormatProperties2KHR}, |
| {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (void *)GetPhysicalDeviceQueueFamilyProperties2KHR}, |
| {"vkGetPhysicalDeviceMemoryProperties2KHR", (void*)GetPhysicalDeviceMemoryProperties2KHR}, |
| {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (void*)GetPhysicalDeviceSparseImageFormatProperties2KHR}, |
| {"vkGetDeviceGroupPeerMemoryFeaturesKHR", (void*)GetDeviceGroupPeerMemoryFeaturesKHR}, |
| {"vkCmdSetDeviceMaskKHR", (void*)CmdSetDeviceMaskKHR}, |
| {"vkCmdDispatchBaseKHR", (void*)CmdDispatchBaseKHR}, |
| {"vkTrimCommandPoolKHR", (void*)TrimCommandPoolKHR}, |
| {"vkEnumeratePhysicalDeviceGroupsKHR", (void*)EnumeratePhysicalDeviceGroupsKHR}, |
| {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (void*)GetPhysicalDeviceExternalBufferPropertiesKHR}, |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| {"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| {"vkGetMemoryWin32HandlePropertiesKHR", (void*)GetMemoryWin32HandlePropertiesKHR}, |
| #endif |
| {"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR}, |
| {"vkGetMemoryFdPropertiesKHR", (void*)GetMemoryFdPropertiesKHR}, |
| {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHR}, |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| {"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| {"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR}, |
| #endif |
| {"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR}, |
| {"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR}, |
| {"vkCmdPushDescriptorSetKHR", (void *)CmdPushDescriptorSetKHR}, |
| {"vkCmdPushDescriptorSetWithTemplateKHR", (void*)CmdPushDescriptorSetWithTemplateKHR}, |
| {"vkCreateDescriptorUpdateTemplateKHR", (void*)CreateDescriptorUpdateTemplateKHR}, |
| {"vkDestroyDescriptorUpdateTemplateKHR", (void*)DestroyDescriptorUpdateTemplateKHR}, |
| {"vkUpdateDescriptorSetWithTemplateKHR", (void*)UpdateDescriptorSetWithTemplateKHR}, |
| {"vkGetSwapchainStatusKHR", (void*)GetSwapchainStatusKHR}, |
| {"vkGetPhysicalDeviceExternalFencePropertiesKHR", (void*)GetPhysicalDeviceExternalFencePropertiesKHR}, |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| {"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| {"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR}, |
| #endif |
| {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR}, |
| {"vkGetFenceFdKHR", (void*)GetFenceFdKHR}, |
| {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (void*)GetPhysicalDeviceSurfaceCapabilities2KHR}, |
| {"vkGetPhysicalDeviceSurfaceFormats2KHR", (void*)GetPhysicalDeviceSurfaceFormats2KHR}, |
| {"vkGetImageMemoryRequirements2KHR", (void*)GetImageMemoryRequirements2KHR}, |
| {"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR}, |
| {"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR}, |
| {"vkCreateSamplerYcbcrConversionKHR", (void*)CreateSamplerYcbcrConversionKHR}, |
| {"vkDestroySamplerYcbcrConversionKHR", (void*)DestroySamplerYcbcrConversionKHR}, |
| {"vkBindBufferMemory2KHR", (void*)BindBufferMemory2KHR}, |
| {"vkBindImageMemory2KHR", (void*)BindImageMemory2KHR}, |
| {"vkGetDescriptorSetLayoutSupportKHR", (void*)GetDescriptorSetLayoutSupportKHR}, |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkCreateMagmaSurfaceKHR", (void*)CreateMagmaSurfaceKHR}, |
| #endif |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkGetPhysicalDeviceMagmaPresentationSupportKHR", (void*)GetPhysicalDeviceMagmaPresentationSupportKHR}, |
| #endif |
| {"vkCreateDebugReportCallbackEXT", (void *)CreateDebugReportCallbackEXT}, |
| {"vkDestroyDebugReportCallbackEXT", (void *)DestroyDebugReportCallbackEXT}, |
| {"vkDebugReportMessageEXT", (void *)DebugReportMessageEXT}, |
| {"vkDebugMarkerSetObjectTagEXT", (void*)DebugMarkerSetObjectTagEXT}, |
| {"vkDebugMarkerSetObjectNameEXT", (void *)DebugMarkerSetObjectNameEXT}, |
| {"vkCmdDebugMarkerBeginEXT", (void*)CmdDebugMarkerBeginEXT}, |
| {"vkCmdDebugMarkerEndEXT", (void*)CmdDebugMarkerEndEXT}, |
| {"vkCmdDebugMarkerInsertEXT", (void*)CmdDebugMarkerInsertEXT}, |
| {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD}, |
| {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD}, |
| {"vkGetShaderInfoAMD", (void*)GetShaderInfoAMD}, |
| {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", (void*)GetPhysicalDeviceExternalImageFormatPropertiesNV}, |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| {"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV}, |
| #endif |
| #ifdef VK_USE_PLATFORM_VI_NN |
| {"vkCreateViSurfaceNN", (void*)CreateViSurfaceNN}, |
| #endif |
| {"vkCmdProcessCommandsNVX", (void*)CmdProcessCommandsNVX}, |
| {"vkCmdReserveSpaceForCommandsNVX", (void*)CmdReserveSpaceForCommandsNVX}, |
| {"vkCreateIndirectCommandsLayoutNVX", (void*)CreateIndirectCommandsLayoutNVX}, |
| {"vkDestroyIndirectCommandsLayoutNVX", (void*)DestroyIndirectCommandsLayoutNVX}, |
| {"vkCreateObjectTableNVX", (void*)CreateObjectTableNVX}, |
| {"vkDestroyObjectTableNVX", (void*)DestroyObjectTableNVX}, |
| {"vkRegisterObjectsNVX", (void*)RegisterObjectsNVX}, |
| {"vkUnregisterObjectsNVX", (void*)UnregisterObjectsNVX}, |
| {"vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", (void*)GetPhysicalDeviceGeneratedCommandsPropertiesNVX}, |
| {"vkCmdSetViewportWScalingNV", (void*)CmdSetViewportWScalingNV}, |
| {"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT}, |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| {"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT}, |
| #endif |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| {"vkGetRandROutputDisplayEXT", (void*)GetRandROutputDisplayEXT}, |
| #endif |
| {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT}, |
| {"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT}, |
| {"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT}, |
| {"vkRegisterDisplayEventEXT", (void*)RegisterDisplayEventEXT}, |
| {"vkGetSwapchainCounterEXT", (void*)GetSwapchainCounterEXT}, |
| {"vkGetRefreshCycleDurationGOOGLE", (void*)GetRefreshCycleDurationGOOGLE}, |
| {"vkGetPastPresentationTimingGOOGLE", (void*)GetPastPresentationTimingGOOGLE}, |
| {"vkCmdSetDiscardRectangleEXT", (void*)CmdSetDiscardRectangleEXT}, |
| {"vkSetHdrMetadataEXT", (void*)SetHdrMetadataEXT}, |
| #ifdef VK_USE_PLATFORM_IOS_MVK |
| {"vkCreateIOSSurfaceMVK", (void*)CreateIOSSurfaceMVK}, |
| #endif |
| #ifdef VK_USE_PLATFORM_MACOS_MVK |
| {"vkCreateMacOSSurfaceMVK", (void*)CreateMacOSSurfaceMVK}, |
| #endif |
| {"vkSetDebugUtilsObjectNameEXT", (void *)SetDebugUtilsObjectNameEXT}, |
| {"vkSetDebugUtilsObjectTagEXT", (void *)SetDebugUtilsObjectTagEXT}, |
| {"vkQueueBeginDebugUtilsLabelEXT", (void *)QueueBeginDebugUtilsLabelEXT}, |
| {"vkQueueEndDebugUtilsLabelEXT", (void *)QueueEndDebugUtilsLabelEXT}, |
| {"vkQueueInsertDebugUtilsLabelEXT", (void *)QueueInsertDebugUtilsLabelEXT}, |
| {"vkCmdBeginDebugUtilsLabelEXT", (void *)CmdBeginDebugUtilsLabelEXT}, |
| {"vkCmdEndDebugUtilsLabelEXT", (void *)CmdEndDebugUtilsLabelEXT}, |
| {"vkCmdInsertDebugUtilsLabelEXT", (void *)CmdInsertDebugUtilsLabelEXT}, |
| {"vkCreateDebugUtilsMessengerEXT", (void *)CreateDebugUtilsMessengerEXT}, |
| {"vkDestroyDebugUtilsMessengerEXT", (void *)DestroyDebugUtilsMessengerEXT}, |
| {"vkSubmitDebugUtilsMessageEXT", (void *)SubmitDebugUtilsMessageEXT}, |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| {"vkGetAndroidHardwareBufferPropertiesANDROID", (void*)GetAndroidHardwareBufferPropertiesANDROID}, |
| #endif |
| #ifdef VK_USE_PLATFORM_ANDROID_KHR |
| {"vkGetMemoryAndroidHardwareBufferANDROID", (void*)GetMemoryAndroidHardwareBufferANDROID}, |
| #endif |
| {"vkCmdSetSampleLocationsEXT", (void*)CmdSetSampleLocationsEXT}, |
| {"vkGetPhysicalDeviceMultisamplePropertiesEXT", (void*)GetPhysicalDeviceMultisamplePropertiesEXT}, |
| {"vkCreateValidationCacheEXT", (void*)CreateValidationCacheEXT}, |
| {"vkDestroyValidationCacheEXT", (void*)DestroyValidationCacheEXT}, |
| {"vkMergeValidationCachesEXT", (void*)MergeValidationCachesEXT}, |
| {"vkGetValidationCacheDataEXT", (void*)GetValidationCacheDataEXT}, |
| {"vkGetMemoryHostPointerPropertiesEXT", (void*)GetMemoryHostPointerPropertiesEXT}, |
| {"vkCmdWriteBufferMarkerAMD", (void*)CmdWriteBufferMarkerAMD}, |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkCreateImagePipeSurfaceFUCHSIA", (void*)CreateImagePipeSurfaceFUCHSIA}, |
| #endif |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkCreateBufferCollectionFUCHSIA", (void*)CreateBufferCollectionFUCHSIA}, |
| #endif |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkSetBufferCollectionConstraintsFUCHSIA", (void*)SetBufferCollectionConstraintsFUCHSIA}, |
| #endif |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkDestroyBufferCollectionFUCHSIA", (void*)DestroyBufferCollectionFUCHSIA}, |
| #endif |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkGetBufferCollectionPropertiesFUCHSIA", (void*)GetBufferCollectionPropertiesFUCHSIA}, |
| #endif |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkGetMemoryZirconHandleFUCHSIA", (void*)GetMemoryZirconHandleFUCHSIA}, |
| #endif |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkGetMemoryZirconHandlePropertiesFUCHSIA", (void*)GetMemoryZirconHandlePropertiesFUCHSIA}, |
| #endif |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkImportSemaphoreZirconHandleFUCHSIA", (void*)ImportSemaphoreZirconHandleFUCHSIA}, |
| #endif |
| #ifdef VK_USE_PLATFORM_FUCHSIA |
| {"vkGetSemaphoreZirconHandleFUCHSIA", (void*)GetSemaphoreZirconHandleFUCHSIA}, |
| #endif |
| }; |
| |
| |
| } // namespace object_tracker |
