| // Copyright 2018 The Chromium Authors | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| // | |
| // This file is auto-generated from | |
| // gpu/vulkan/generate_bindings.py | |
| // It's formatted by clang-format using chromium coding style: | |
| // clang-format -i -style=chromium filename | |
| // DO NOT EDIT! | |
| #ifndef GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_ | |
| #define GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_ | |
| #include <vulkan/vulkan.h> | |
| #include <memory> | |
| #include "base/compiler_specific.h" | |
| #include "base/component_export.h" | |
| #include "base/containers/flat_map.h" | |
| #include "base/native_library.h" | |
| #include "base/synchronization/lock.h" | |
| #include "build/build_config.h" | |
| #include "ui/gfx/extension_set.h" | |
| #if BUILDFLAG(IS_ANDROID) | |
| #include <vulkan/vulkan_android.h> | |
| #endif | |
| #if BUILDFLAG(IS_FUCHSIA) | |
| #include <zircon/types.h> | |
| // <vulkan/vulkan_fuchsia.h> must be included after <zircon/types.h> | |
| #include <vulkan/vulkan_fuchsia.h> | |
| #include "gpu/vulkan/fuchsia/vulkan_fuchsia_ext.h" | |
| #endif | |
| #if defined(USE_VULKAN_XCB) | |
| #include <xcb/xcb.h> | |
| // <vulkan/vulkan_xcb.h> must be included after <xcb/xcb.h> | |
| #include <vulkan/vulkan_xcb.h> | |
| #endif | |
| #if BUILDFLAG(IS_WIN) | |
| #include <vulkan/vulkan_win32.h> | |
| #endif | |
| namespace gpu { | |
| struct VulkanFunctionPointers; | |
| constexpr uint32_t kVulkanRequiredApiVersion = VK_API_VERSION_1_1; | |
| COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers* GetVulkanFunctionPointers(); | |
| struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers { | |
| VulkanFunctionPointers(); | |
| ~VulkanFunctionPointers(); | |
| bool BindUnassociatedFunctionPointersFromLoaderLib(base::NativeLibrary lib); | |
| bool BindUnassociatedFunctionPointersFromGetProcAddr( | |
| PFN_vkGetInstanceProcAddr proc); | |
| // These functions assume that vkGetInstanceProcAddr has been populated. | |
| bool BindInstanceFunctionPointers( | |
| VkInstance vk_instance, | |
| uint32_t api_version, | |
| const gfx::ExtensionSet& enabled_extensions); | |
| // These functions assume that vkGetDeviceProcAddr has been populated. | |
| bool BindDeviceFunctionPointers(VkDevice vk_device, | |
| uint32_t api_version, | |
| const gfx::ExtensionSet& enabled_extensions); | |
| // This is used to allow thread safe access to a given vulkan queue when | |
| // multiple gpu threads are accessing it. Note that this map will be only | |
| // accessed by multiple gpu threads concurrently to read the data, so it | |
| // should be thread safe to use this map by multiple threads. | |
| base::flat_map<VkQueue, std::unique_ptr<base::Lock>> per_queue_lock_map; | |
| template <typename T> | |
| class VulkanFunction; | |
| template <typename R, typename... Args> | |
| class VulkanFunction<R(VKAPI_PTR*)(Args...)> { | |
| public: | |
| using Fn = R(VKAPI_PTR*)(Args...); | |
| explicit operator bool() const { return !!fn_; } | |
| NO_SANITIZE("cfi-icall") | |
| R operator()(Args... args) const { return fn_(args...); } | |
| Fn get() const { return fn_; } | |
| private: | |
| friend VulkanFunctionPointers; | |
| Fn operator=(Fn fn) { | |
| fn_ = fn; | |
| return fn_; | |
| } | |
| Fn fn_ = nullptr; | |
| }; | |
| // Unassociated functions | |
| VulkanFunction<PFN_vkGetInstanceProcAddr> vkGetInstanceProcAddr; | |
| VulkanFunction<PFN_vkEnumerateInstanceVersion> vkEnumerateInstanceVersion; | |
| VulkanFunction<PFN_vkCreateInstance> vkCreateInstance; | |
| VulkanFunction<PFN_vkEnumerateInstanceExtensionProperties> | |
| vkEnumerateInstanceExtensionProperties; | |
| VulkanFunction<PFN_vkEnumerateInstanceLayerProperties> | |
| vkEnumerateInstanceLayerProperties; | |
| // Instance functions | |
| VulkanFunction<PFN_vkCreateDevice> vkCreateDevice; | |
| VulkanFunction<PFN_vkDestroyInstance> vkDestroyInstance; | |
| VulkanFunction<PFN_vkEnumerateDeviceExtensionProperties> | |
| vkEnumerateDeviceExtensionProperties; | |
| VulkanFunction<PFN_vkEnumerateDeviceLayerProperties> | |
| vkEnumerateDeviceLayerProperties; | |
| VulkanFunction<PFN_vkEnumeratePhysicalDevices> vkEnumeratePhysicalDevices; | |
| VulkanFunction<PFN_vkGetDeviceProcAddr> vkGetDeviceProcAddr; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceFeatures2> vkGetPhysicalDeviceFeatures2; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceFormatProperties> | |
| vkGetPhysicalDeviceFormatProperties; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceFormatProperties2> | |
| vkGetPhysicalDeviceFormatProperties2; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceImageFormatProperties2> | |
| vkGetPhysicalDeviceImageFormatProperties2; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceMemoryProperties> | |
| vkGetPhysicalDeviceMemoryProperties; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceMemoryProperties2> | |
| vkGetPhysicalDeviceMemoryProperties2; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceProperties> | |
| vkGetPhysicalDeviceProperties; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceProperties2> | |
| vkGetPhysicalDeviceProperties2; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceQueueFamilyProperties> | |
| vkGetPhysicalDeviceQueueFamilyProperties; | |
| #if DCHECK_IS_ON() | |
| VulkanFunction<PFN_vkCreateDebugReportCallbackEXT> | |
| vkCreateDebugReportCallbackEXT; | |
| VulkanFunction<PFN_vkDestroyDebugReportCallbackEXT> | |
| vkDestroyDebugReportCallbackEXT; | |
| #endif // DCHECK_IS_ON() | |
| VulkanFunction<PFN_vkDestroySurfaceKHR> vkDestroySurfaceKHR; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR> | |
| vkGetPhysicalDeviceSurfaceCapabilitiesKHR; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR> | |
| vkGetPhysicalDeviceSurfaceFormatsKHR; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceSurfaceSupportKHR> | |
| vkGetPhysicalDeviceSurfaceSupportKHR; | |
| VulkanFunction<PFN_vkCreateHeadlessSurfaceEXT> vkCreateHeadlessSurfaceEXT; | |
| #if defined(USE_VULKAN_XCB) | |
| VulkanFunction<PFN_vkCreateXcbSurfaceKHR> vkCreateXcbSurfaceKHR; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR> | |
| vkGetPhysicalDeviceXcbPresentationSupportKHR; | |
| #endif // defined(USE_VULKAN_XCB) | |
| #if BUILDFLAG(IS_WIN) | |
| VulkanFunction<PFN_vkCreateWin32SurfaceKHR> vkCreateWin32SurfaceKHR; | |
| VulkanFunction<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR> | |
| vkGetPhysicalDeviceWin32PresentationSupportKHR; | |
| #endif // BUILDFLAG(IS_WIN) | |
| #if BUILDFLAG(IS_ANDROID) | |
| VulkanFunction<PFN_vkCreateAndroidSurfaceKHR> vkCreateAndroidSurfaceKHR; | |
| #endif // BUILDFLAG(IS_ANDROID) | |
| #if BUILDFLAG(IS_FUCHSIA) | |
| VulkanFunction<PFN_vkCreateImagePipeSurfaceFUCHSIA> | |
| vkCreateImagePipeSurfaceFUCHSIA; | |
| #endif // BUILDFLAG(IS_FUCHSIA) | |
| // Device functions | |
| VulkanFunction<PFN_vkAllocateCommandBuffers> vkAllocateCommandBuffers; | |
| VulkanFunction<PFN_vkAllocateDescriptorSets> vkAllocateDescriptorSets; | |
| VulkanFunction<PFN_vkAllocateMemory> vkAllocateMemory; | |
| VulkanFunction<PFN_vkBeginCommandBuffer> vkBeginCommandBuffer; | |
| VulkanFunction<PFN_vkBindBufferMemory> vkBindBufferMemory; | |
| VulkanFunction<PFN_vkBindBufferMemory2> vkBindBufferMemory2; | |
| VulkanFunction<PFN_vkBindImageMemory> vkBindImageMemory; | |
| VulkanFunction<PFN_vkBindImageMemory2> vkBindImageMemory2; | |
| VulkanFunction<PFN_vkCmdBeginRenderPass> vkCmdBeginRenderPass; | |
| VulkanFunction<PFN_vkCmdCopyBuffer> vkCmdCopyBuffer; | |
| VulkanFunction<PFN_vkCmdCopyBufferToImage> vkCmdCopyBufferToImage; | |
| VulkanFunction<PFN_vkCmdCopyImageToBuffer> vkCmdCopyImageToBuffer; | |
| VulkanFunction<PFN_vkCmdEndRenderPass> vkCmdEndRenderPass; | |
| VulkanFunction<PFN_vkCmdExecuteCommands> vkCmdExecuteCommands; | |
| VulkanFunction<PFN_vkCmdNextSubpass> vkCmdNextSubpass; | |
| VulkanFunction<PFN_vkCmdPipelineBarrier> vkCmdPipelineBarrier; | |
| VulkanFunction<PFN_vkCreateBuffer> vkCreateBuffer; | |
| VulkanFunction<PFN_vkCreateCommandPool> vkCreateCommandPool; | |
| VulkanFunction<PFN_vkCreateDescriptorPool> vkCreateDescriptorPool; | |
| VulkanFunction<PFN_vkCreateDescriptorSetLayout> vkCreateDescriptorSetLayout; | |
| VulkanFunction<PFN_vkCreateFence> vkCreateFence; | |
| VulkanFunction<PFN_vkCreateFramebuffer> vkCreateFramebuffer; | |
| VulkanFunction<PFN_vkCreateGraphicsPipelines> vkCreateGraphicsPipelines; | |
| VulkanFunction<PFN_vkCreateImage> vkCreateImage; | |
| VulkanFunction<PFN_vkCreateImageView> vkCreateImageView; | |
| VulkanFunction<PFN_vkCreateRenderPass> vkCreateRenderPass; | |
| VulkanFunction<PFN_vkCreateSampler> vkCreateSampler; | |
| VulkanFunction<PFN_vkCreateSemaphore> vkCreateSemaphore; | |
| VulkanFunction<PFN_vkCreateShaderModule> vkCreateShaderModule; | |
| VulkanFunction<PFN_vkDestroyBuffer> vkDestroyBuffer; | |
| VulkanFunction<PFN_vkDestroyCommandPool> vkDestroyCommandPool; | |
| VulkanFunction<PFN_vkDestroyDescriptorPool> vkDestroyDescriptorPool; | |
| VulkanFunction<PFN_vkDestroyDescriptorSetLayout> vkDestroyDescriptorSetLayout; | |
| VulkanFunction<PFN_vkDestroyDevice> vkDestroyDevice; | |
| VulkanFunction<PFN_vkDestroyFence> vkDestroyFence; | |
| VulkanFunction<PFN_vkDestroyFramebuffer> vkDestroyFramebuffer; | |
| VulkanFunction<PFN_vkDestroyImage> vkDestroyImage; | |
| VulkanFunction<PFN_vkDestroyImageView> vkDestroyImageView; | |
| VulkanFunction<PFN_vkDestroyRenderPass> vkDestroyRenderPass; | |
| VulkanFunction<PFN_vkDestroySampler> vkDestroySampler; | |
| VulkanFunction<PFN_vkDestroySemaphore> vkDestroySemaphore; | |
| VulkanFunction<PFN_vkDestroyShaderModule> vkDestroyShaderModule; | |
| VulkanFunction<PFN_vkDeviceWaitIdle> vkDeviceWaitIdle; | |
| VulkanFunction<PFN_vkFlushMappedMemoryRanges> vkFlushMappedMemoryRanges; | |
| VulkanFunction<PFN_vkEndCommandBuffer> vkEndCommandBuffer; | |
| VulkanFunction<PFN_vkFreeCommandBuffers> vkFreeCommandBuffers; | |
| VulkanFunction<PFN_vkFreeDescriptorSets> vkFreeDescriptorSets; | |
| VulkanFunction<PFN_vkFreeMemory> vkFreeMemory; | |
| VulkanFunction<PFN_vkInvalidateMappedMemoryRanges> | |
| vkInvalidateMappedMemoryRanges; | |
| VulkanFunction<PFN_vkGetBufferMemoryRequirements> | |
| vkGetBufferMemoryRequirements; | |
| VulkanFunction<PFN_vkGetBufferMemoryRequirements2> | |
| vkGetBufferMemoryRequirements2; | |
| VulkanFunction<PFN_vkGetDeviceQueue> vkGetDeviceQueue; | |
| VulkanFunction<PFN_vkGetDeviceQueue2> vkGetDeviceQueue2; | |
| VulkanFunction<PFN_vkGetFenceStatus> vkGetFenceStatus; | |
| VulkanFunction<PFN_vkGetImageMemoryRequirements> vkGetImageMemoryRequirements; | |
| VulkanFunction<PFN_vkGetImageMemoryRequirements2> | |
| vkGetImageMemoryRequirements2; | |
| VulkanFunction<PFN_vkGetImageSubresourceLayout> vkGetImageSubresourceLayout; | |
| VulkanFunction<PFN_vkMapMemory> vkMapMemory; | |
| VulkanFunction<PFN_vkQueueSubmit> vkQueueSubmit; | |
| VulkanFunction<PFN_vkQueueWaitIdle> vkQueueWaitIdle; | |
| VulkanFunction<PFN_vkResetCommandBuffer> vkResetCommandBuffer; | |
| VulkanFunction<PFN_vkResetFences> vkResetFences; | |
| VulkanFunction<PFN_vkUnmapMemory> vkUnmapMemory; | |
| VulkanFunction<PFN_vkUpdateDescriptorSets> vkUpdateDescriptorSets; | |
| VulkanFunction<PFN_vkWaitForFences> vkWaitForFences; | |
| #if BUILDFLAG(IS_ANDROID) | |
| VulkanFunction<PFN_vkGetAndroidHardwareBufferPropertiesANDROID> | |
| vkGetAndroidHardwareBufferPropertiesANDROID; | |
| #endif // BUILDFLAG(IS_ANDROID) | |
| #if BUILDFLAG(IS_POSIX) | |
| VulkanFunction<PFN_vkGetSemaphoreFdKHR> vkGetSemaphoreFdKHR; | |
| VulkanFunction<PFN_vkImportSemaphoreFdKHR> vkImportSemaphoreFdKHR; | |
| #endif // BUILDFLAG(IS_POSIX) | |
| #if BUILDFLAG(IS_WIN) | |
| VulkanFunction<PFN_vkGetSemaphoreWin32HandleKHR> vkGetSemaphoreWin32HandleKHR; | |
| VulkanFunction<PFN_vkImportSemaphoreWin32HandleKHR> | |
| vkImportSemaphoreWin32HandleKHR; | |
| #endif // BUILDFLAG(IS_WIN) | |
| #if BUILDFLAG(IS_POSIX) | |
| VulkanFunction<PFN_vkGetMemoryFdKHR> vkGetMemoryFdKHR; | |
| VulkanFunction<PFN_vkGetMemoryFdPropertiesKHR> vkGetMemoryFdPropertiesKHR; | |
| #endif // BUILDFLAG(IS_POSIX) | |
| #if BUILDFLAG(IS_WIN) | |
| VulkanFunction<PFN_vkGetMemoryWin32HandleKHR> vkGetMemoryWin32HandleKHR; | |
| VulkanFunction<PFN_vkGetMemoryWin32HandlePropertiesKHR> | |
| vkGetMemoryWin32HandlePropertiesKHR; | |
| #endif // BUILDFLAG(IS_WIN) | |
| #if BUILDFLAG(IS_FUCHSIA) | |
| VulkanFunction<PFN_vkImportSemaphoreZirconHandleFUCHSIA> | |
| vkImportSemaphoreZirconHandleFUCHSIA; | |
| VulkanFunction<PFN_vkGetSemaphoreZirconHandleFUCHSIA> | |
| vkGetSemaphoreZirconHandleFUCHSIA; | |
| #endif // BUILDFLAG(IS_FUCHSIA) | |
| #if BUILDFLAG(IS_FUCHSIA) | |
| VulkanFunction<PFN_vkGetMemoryZirconHandleFUCHSIA> | |
| vkGetMemoryZirconHandleFUCHSIA; | |
| #endif // BUILDFLAG(IS_FUCHSIA) | |
| #if BUILDFLAG(IS_FUCHSIA) | |
| VulkanFunction<PFN_vkCreateBufferCollectionFUCHSIA> | |
| vkCreateBufferCollectionFUCHSIA; | |
| VulkanFunction<PFN_vkSetBufferCollectionImageConstraintsFUCHSIA> | |
| vkSetBufferCollectionImageConstraintsFUCHSIA; | |
| VulkanFunction<PFN_vkGetBufferCollectionPropertiesFUCHSIA> | |
| vkGetBufferCollectionPropertiesFUCHSIA; | |
| VulkanFunction<PFN_vkDestroyBufferCollectionFUCHSIA> | |
| vkDestroyBufferCollectionFUCHSIA; | |
| #endif // BUILDFLAG(IS_FUCHSIA) | |
| VulkanFunction<PFN_vkAcquireNextImageKHR> vkAcquireNextImageKHR; | |
| VulkanFunction<PFN_vkCreateSwapchainKHR> vkCreateSwapchainKHR; | |
| VulkanFunction<PFN_vkDestroySwapchainKHR> vkDestroySwapchainKHR; | |
| VulkanFunction<PFN_vkGetSwapchainImagesKHR> vkGetSwapchainImagesKHR; | |
| VulkanFunction<PFN_vkQueuePresentKHR> vkQueuePresentKHR; | |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) | |
| VulkanFunction<PFN_vkGetImageDrmFormatModifierPropertiesEXT> | |
| vkGetImageDrmFormatModifierPropertiesEXT; | |
| #endif // BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) | |
| private: | |
| bool BindUnassociatedFunctionPointersCommon(); | |
| // The `Bind*` functions will acquires lock, so should not be called with | |
| // with this lock held. Code that writes to members directly should take this | |
| // lock as well. | |
| base::Lock write_lock_; | |
| base::NativeLibrary loader_library_ = nullptr; | |
| }; | |
| } // namespace gpu | |
| // Unassociated functions | |
| ALWAYS_INLINE PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, | |
| const char* pName) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetInstanceProcAddr(instance, | |
| pName); | |
| } | |
| ALWAYS_INLINE VkResult vkEnumerateInstanceVersion(uint32_t* pApiVersion) { | |
| return gpu::GetVulkanFunctionPointers()->vkEnumerateInstanceVersion( | |
| pApiVersion); | |
| } | |
| ALWAYS_INLINE VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkInstance* pInstance) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateInstance( | |
| pCreateInfo, pAllocator, pInstance); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkEnumerateInstanceExtensionProperties(const char* pLayerName, | |
| uint32_t* pPropertyCount, | |
| VkExtensionProperties* pProperties) { | |
| return gpu::GetVulkanFunctionPointers() | |
| ->vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, | |
| pProperties); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, | |
| VkLayerProperties* pProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkEnumerateInstanceLayerProperties( | |
| pPropertyCount, pProperties); | |
| } | |
| // Instance functions | |
| ALWAYS_INLINE VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, | |
| const VkDeviceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDevice* pDevice) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateDevice( | |
| physicalDevice, pCreateInfo, pAllocator, pDevice); | |
| } | |
| ALWAYS_INLINE void vkDestroyInstance(VkInstance instance, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyInstance(instance, | |
| pAllocator); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, | |
| const char* pLayerName, | |
| uint32_t* pPropertyCount, | |
| VkExtensionProperties* pProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkEnumerateDeviceExtensionProperties( | |
| physicalDevice, pLayerName, pPropertyCount, pProperties); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, | |
| uint32_t* pPropertyCount, | |
| VkLayerProperties* pProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkEnumerateDeviceLayerProperties( | |
| physicalDevice, pPropertyCount, pProperties); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkEnumeratePhysicalDevices(VkInstance instance, | |
| uint32_t* pPhysicalDeviceCount, | |
| VkPhysicalDevice* pPhysicalDevices) { | |
| return gpu::GetVulkanFunctionPointers()->vkEnumeratePhysicalDevices( | |
| instance, pPhysicalDeviceCount, pPhysicalDevices); | |
| } | |
| ALWAYS_INLINE PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, | |
| const char* pName) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetDeviceProcAddr(device, pName); | |
| } | |
| ALWAYS_INLINE void vkGetPhysicalDeviceFeatures2( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceFeatures2* pFeatures) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFeatures2( | |
| physicalDevice, pFeatures); | |
| } | |
| ALWAYS_INLINE void vkGetPhysicalDeviceFormatProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkFormatProperties* pFormatProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFormatProperties( | |
| physicalDevice, format, pFormatProperties); | |
| } | |
| ALWAYS_INLINE void vkGetPhysicalDeviceFormatProperties2( | |
| VkPhysicalDevice physicalDevice, | |
| VkFormat format, | |
| VkFormatProperties2* pFormatProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFormatProperties2( | |
| physicalDevice, format, pFormatProperties); | |
| } | |
| ALWAYS_INLINE VkResult vkGetPhysicalDeviceImageFormatProperties2( | |
| VkPhysicalDevice physicalDevice, | |
| const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, | |
| VkImageFormatProperties2* pImageFormatProperties) { | |
| return gpu::GetVulkanFunctionPointers() | |
| ->vkGetPhysicalDeviceImageFormatProperties2( | |
| physicalDevice, pImageFormatInfo, pImageFormatProperties); | |
| } | |
| ALWAYS_INLINE void vkGetPhysicalDeviceMemoryProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceMemoryProperties* pMemoryProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceMemoryProperties( | |
| physicalDevice, pMemoryProperties); | |
| } | |
| ALWAYS_INLINE void vkGetPhysicalDeviceMemoryProperties2( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceMemoryProperties2( | |
| physicalDevice, pMemoryProperties); | |
| } | |
| ALWAYS_INLINE void vkGetPhysicalDeviceProperties( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceProperties* pProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceProperties( | |
| physicalDevice, pProperties); | |
| } | |
| ALWAYS_INLINE void vkGetPhysicalDeviceProperties2( | |
| VkPhysicalDevice physicalDevice, | |
| VkPhysicalDeviceProperties2* pProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceProperties2( | |
| physicalDevice, pProperties); | |
| } | |
| ALWAYS_INLINE void vkGetPhysicalDeviceQueueFamilyProperties( | |
| VkPhysicalDevice physicalDevice, | |
| uint32_t* pQueueFamilyPropertyCount, | |
| VkQueueFamilyProperties* pQueueFamilyProperties) { | |
| return gpu::GetVulkanFunctionPointers() | |
| ->vkGetPhysicalDeviceQueueFamilyProperties( | |
| physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); | |
| } | |
| #if DCHECK_IS_ON() | |
| ALWAYS_INLINE VkResult vkCreateDebugReportCallbackEXT( | |
| VkInstance instance, | |
| const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDebugReportCallbackEXT* pCallback) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateDebugReportCallbackEXT( | |
| instance, pCreateInfo, pAllocator, pCallback); | |
| } | |
| ALWAYS_INLINE void vkDestroyDebugReportCallbackEXT( | |
| VkInstance instance, | |
| VkDebugReportCallbackEXT callback, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyDebugReportCallbackEXT( | |
| instance, callback, pAllocator); | |
| } | |
| #endif // DCHECK_IS_ON() | |
| ALWAYS_INLINE void vkDestroySurfaceKHR( | |
| VkInstance instance, | |
| VkSurfaceKHR surface, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroySurfaceKHR( | |
| instance, surface, pAllocator); | |
| } | |
| ALWAYS_INLINE VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( | |
| VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { | |
| return gpu::GetVulkanFunctionPointers() | |
| ->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, | |
| pSurfaceCapabilities); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, | |
| VkSurfaceKHR surface, | |
| uint32_t* pSurfaceFormatCount, | |
| VkSurfaceFormatKHR* pSurfaceFormats) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceSurfaceFormatsKHR( | |
| physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| VkSurfaceKHR surface, | |
| VkBool32* pSupported) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceSurfaceSupportKHR( | |
| physicalDevice, queueFamilyIndex, surface, pSupported); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateHeadlessSurfaceEXT(VkInstance instance, | |
| const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateHeadlessSurfaceEXT( | |
| instance, pCreateInfo, pAllocator, pSurface); | |
| } | |
| #if defined(USE_VULKAN_XCB) | |
| ALWAYS_INLINE VkResult | |
| vkCreateXcbSurfaceKHR(VkInstance instance, | |
| const VkXcbSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateXcbSurfaceKHR( | |
| instance, pCreateInfo, pAllocator, pSurface); | |
| } | |
| ALWAYS_INLINE VkBool32 | |
| vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex, | |
| xcb_connection_t* connection, | |
| xcb_visualid_t visual_id) { | |
| return gpu::GetVulkanFunctionPointers() | |
| ->vkGetPhysicalDeviceXcbPresentationSupportKHR( | |
| physicalDevice, queueFamilyIndex, connection, visual_id); | |
| } | |
| #endif // defined(USE_VULKAN_XCB) | |
| #if BUILDFLAG(IS_WIN) | |
| ALWAYS_INLINE VkResult | |
| vkCreateWin32SurfaceKHR(VkInstance instance, | |
| const VkWin32SurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateWin32SurfaceKHR( | |
| instance, pCreateInfo, pAllocator, pSurface); | |
| } | |
| ALWAYS_INLINE VkBool32 | |
| vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, | |
| uint32_t queueFamilyIndex) { | |
| return gpu::GetVulkanFunctionPointers() | |
| ->vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, | |
| queueFamilyIndex); | |
| } | |
| #endif // BUILDFLAG(IS_WIN) | |
| #if BUILDFLAG(IS_ANDROID) | |
| ALWAYS_INLINE VkResult | |
| vkCreateAndroidSurfaceKHR(VkInstance instance, | |
| const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateAndroidSurfaceKHR( | |
| instance, pCreateInfo, pAllocator, pSurface); | |
| } | |
| #endif // BUILDFLAG(IS_ANDROID) | |
| #if BUILDFLAG(IS_FUCHSIA) | |
| ALWAYS_INLINE VkResult vkCreateImagePipeSurfaceFUCHSIA( | |
| VkInstance instance, | |
| const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSurfaceKHR* pSurface) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateImagePipeSurfaceFUCHSIA( | |
| instance, pCreateInfo, pAllocator, pSurface); | |
| } | |
| #endif // BUILDFLAG(IS_FUCHSIA) | |
| // Device functions | |
| ALWAYS_INLINE VkResult | |
| vkAllocateCommandBuffers(VkDevice device, | |
| const VkCommandBufferAllocateInfo* pAllocateInfo, | |
| VkCommandBuffer* pCommandBuffers) { | |
| return gpu::GetVulkanFunctionPointers()->vkAllocateCommandBuffers( | |
| device, pAllocateInfo, pCommandBuffers); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkAllocateDescriptorSets(VkDevice device, | |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, | |
| VkDescriptorSet* pDescriptorSets) { | |
| return gpu::GetVulkanFunctionPointers()->vkAllocateDescriptorSets( | |
| device, pAllocateInfo, pDescriptorSets); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkAllocateMemory(VkDevice device, | |
| const VkMemoryAllocateInfo* pAllocateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDeviceMemory* pMemory) { | |
| return gpu::GetVulkanFunctionPointers()->vkAllocateMemory( | |
| device, pAllocateInfo, pAllocator, pMemory); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkBeginCommandBuffer(VkCommandBuffer commandBuffer, | |
| const VkCommandBufferBeginInfo* pBeginInfo) { | |
| return gpu::GetVulkanFunctionPointers()->vkBeginCommandBuffer(commandBuffer, | |
| pBeginInfo); | |
| } | |
| ALWAYS_INLINE VkResult vkBindBufferMemory(VkDevice device, | |
| VkBuffer buffer, | |
| VkDeviceMemory memory, | |
| VkDeviceSize memoryOffset) { | |
| return gpu::GetVulkanFunctionPointers()->vkBindBufferMemory( | |
| device, buffer, memory, memoryOffset); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkBindBufferMemory2(VkDevice device, | |
| uint32_t bindInfoCount, | |
| const VkBindBufferMemoryInfo* pBindInfos) { | |
| return gpu::GetVulkanFunctionPointers()->vkBindBufferMemory2( | |
| device, bindInfoCount, pBindInfos); | |
| } | |
| ALWAYS_INLINE VkResult vkBindImageMemory(VkDevice device, | |
| VkImage image, | |
| VkDeviceMemory memory, | |
| VkDeviceSize memoryOffset) { | |
| return gpu::GetVulkanFunctionPointers()->vkBindImageMemory( | |
| device, image, memory, memoryOffset); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkBindImageMemory2(VkDevice device, | |
| uint32_t bindInfoCount, | |
| const VkBindImageMemoryInfo* pBindInfos) { | |
| return gpu::GetVulkanFunctionPointers()->vkBindImageMemory2( | |
| device, bindInfoCount, pBindInfos); | |
| } | |
| ALWAYS_INLINE void vkCmdBeginRenderPass( | |
| VkCommandBuffer commandBuffer, | |
| const VkRenderPassBeginInfo* pRenderPassBegin, | |
| VkSubpassContents contents) { | |
| return gpu::GetVulkanFunctionPointers()->vkCmdBeginRenderPass( | |
| commandBuffer, pRenderPassBegin, contents); | |
| } | |
| ALWAYS_INLINE void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, | |
| VkBuffer srcBuffer, | |
| VkBuffer dstBuffer, | |
| uint32_t regionCount, | |
| const VkBufferCopy* pRegions) { | |
| return gpu::GetVulkanFunctionPointers()->vkCmdCopyBuffer( | |
| commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); | |
| } | |
| ALWAYS_INLINE void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, | |
| VkBuffer srcBuffer, | |
| VkImage dstImage, | |
| VkImageLayout dstImageLayout, | |
| uint32_t regionCount, | |
| const VkBufferImageCopy* pRegions) { | |
| return gpu::GetVulkanFunctionPointers()->vkCmdCopyBufferToImage( | |
| commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, | |
| pRegions); | |
| } | |
| ALWAYS_INLINE void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, | |
| VkImage srcImage, | |
| VkImageLayout srcImageLayout, | |
| VkBuffer dstBuffer, | |
| uint32_t regionCount, | |
| const VkBufferImageCopy* pRegions) { | |
| return gpu::GetVulkanFunctionPointers()->vkCmdCopyImageToBuffer( | |
| commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, | |
| pRegions); | |
| } | |
| ALWAYS_INLINE void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) { | |
| return gpu::GetVulkanFunctionPointers()->vkCmdEndRenderPass(commandBuffer); | |
| } | |
| ALWAYS_INLINE void vkCmdExecuteCommands( | |
| VkCommandBuffer commandBuffer, | |
| uint32_t commandBufferCount, | |
| const VkCommandBuffer* pCommandBuffers) { | |
| return gpu::GetVulkanFunctionPointers()->vkCmdExecuteCommands( | |
| commandBuffer, commandBufferCount, pCommandBuffers); | |
| } | |
| ALWAYS_INLINE void vkCmdNextSubpass(VkCommandBuffer commandBuffer, | |
| VkSubpassContents contents) { | |
| return gpu::GetVulkanFunctionPointers()->vkCmdNextSubpass(commandBuffer, | |
| contents); | |
| } | |
| ALWAYS_INLINE void vkCmdPipelineBarrier( | |
| 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) { | |
| return gpu::GetVulkanFunctionPointers()->vkCmdPipelineBarrier( | |
| commandBuffer, srcStageMask, dstStageMask, dependencyFlags, | |
| memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, | |
| pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); | |
| } | |
| ALWAYS_INLINE VkResult vkCreateBuffer(VkDevice device, | |
| const VkBufferCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkBuffer* pBuffer) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateBuffer(device, pCreateInfo, | |
| pAllocator, pBuffer); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateCommandPool(VkDevice device, | |
| const VkCommandPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkCommandPool* pCommandPool) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateCommandPool( | |
| device, pCreateInfo, pAllocator, pCommandPool); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateDescriptorPool(VkDevice device, | |
| const VkDescriptorPoolCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorPool* pDescriptorPool) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateDescriptorPool( | |
| device, pCreateInfo, pAllocator, pDescriptorPool); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateDescriptorSetLayout(VkDevice device, | |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkDescriptorSetLayout* pSetLayout) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateDescriptorSetLayout( | |
| device, pCreateInfo, pAllocator, pSetLayout); | |
| } | |
| ALWAYS_INLINE VkResult vkCreateFence(VkDevice device, | |
| const VkFenceCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFence* pFence) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateFence(device, pCreateInfo, | |
| pAllocator, pFence); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateFramebuffer(VkDevice device, | |
| const VkFramebufferCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkFramebuffer* pFramebuffer) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateFramebuffer( | |
| device, pCreateInfo, pAllocator, pFramebuffer); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateGraphicsPipelines(VkDevice device, | |
| VkPipelineCache pipelineCache, | |
| uint32_t createInfoCount, | |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkPipeline* pPipelines) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateGraphicsPipelines( | |
| device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, | |
| pPipelines); | |
| } | |
| ALWAYS_INLINE VkResult vkCreateImage(VkDevice device, | |
| const VkImageCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkImage* pImage) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateImage(device, pCreateInfo, | |
| pAllocator, pImage); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateImageView(VkDevice device, | |
| const VkImageViewCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkImageView* pView) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateImageView( | |
| device, pCreateInfo, pAllocator, pView); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateRenderPass(VkDevice device, | |
| const VkRenderPassCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkRenderPass* pRenderPass) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateRenderPass( | |
| device, pCreateInfo, pAllocator, pRenderPass); | |
| } | |
| ALWAYS_INLINE VkResult vkCreateSampler(VkDevice device, | |
| const VkSamplerCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSampler* pSampler) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateSampler( | |
| device, pCreateInfo, pAllocator, pSampler); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateSemaphore(VkDevice device, | |
| const VkSemaphoreCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSemaphore* pSemaphore) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateSemaphore( | |
| device, pCreateInfo, pAllocator, pSemaphore); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateShaderModule(VkDevice device, | |
| const VkShaderModuleCreateInfo* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkShaderModule* pShaderModule) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateShaderModule( | |
| device, pCreateInfo, pAllocator, pShaderModule); | |
| } | |
| ALWAYS_INLINE void vkDestroyBuffer(VkDevice device, | |
| VkBuffer buffer, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyBuffer(device, buffer, | |
| pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroyCommandPool( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyCommandPool( | |
| device, commandPool, pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroyDescriptorPool( | |
| VkDevice device, | |
| VkDescriptorPool descriptorPool, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyDescriptorPool( | |
| device, descriptorPool, pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroyDescriptorSetLayout( | |
| VkDevice device, | |
| VkDescriptorSetLayout descriptorSetLayout, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyDescriptorSetLayout( | |
| device, descriptorSetLayout, pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroyDevice(VkDevice device, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyDevice(device, pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroyFence(VkDevice device, | |
| VkFence fence, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyFence(device, fence, | |
| pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroyFramebuffer( | |
| VkDevice device, | |
| VkFramebuffer framebuffer, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyFramebuffer( | |
| device, framebuffer, pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroyImage(VkDevice device, | |
| VkImage image, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyImage(device, image, | |
| pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroyImageView(VkDevice device, | |
| VkImageView imageView, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyImageView(device, imageView, | |
| pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroyRenderPass( | |
| VkDevice device, | |
| VkRenderPass renderPass, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyRenderPass( | |
| device, renderPass, pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroySampler(VkDevice device, | |
| VkSampler sampler, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroySampler(device, sampler, | |
| pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroySemaphore(VkDevice device, | |
| VkSemaphore semaphore, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroySemaphore(device, semaphore, | |
| pAllocator); | |
| } | |
| ALWAYS_INLINE void vkDestroyShaderModule( | |
| VkDevice device, | |
| VkShaderModule shaderModule, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyShaderModule( | |
| device, shaderModule, pAllocator); | |
| } | |
| ALWAYS_INLINE VkResult vkDeviceWaitIdle(VkDevice device) { | |
| return gpu::GetVulkanFunctionPointers()->vkDeviceWaitIdle(device); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkFlushMappedMemoryRanges(VkDevice device, | |
| uint32_t memoryRangeCount, | |
| const VkMappedMemoryRange* pMemoryRanges) { | |
| return gpu::GetVulkanFunctionPointers()->vkFlushMappedMemoryRanges( | |
| device, memoryRangeCount, pMemoryRanges); | |
| } | |
| ALWAYS_INLINE VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) { | |
| return gpu::GetVulkanFunctionPointers()->vkEndCommandBuffer(commandBuffer); | |
| } | |
| ALWAYS_INLINE void vkFreeCommandBuffers( | |
| VkDevice device, | |
| VkCommandPool commandPool, | |
| uint32_t commandBufferCount, | |
| const VkCommandBuffer* pCommandBuffers) { | |
| return gpu::GetVulkanFunctionPointers()->vkFreeCommandBuffers( | |
| device, commandPool, commandBufferCount, pCommandBuffers); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkFreeDescriptorSets(VkDevice device, | |
| VkDescriptorPool descriptorPool, | |
| uint32_t descriptorSetCount, | |
| const VkDescriptorSet* pDescriptorSets) { | |
| return gpu::GetVulkanFunctionPointers()->vkFreeDescriptorSets( | |
| device, descriptorPool, descriptorSetCount, pDescriptorSets); | |
| } | |
| ALWAYS_INLINE void vkFreeMemory(VkDevice device, | |
| VkDeviceMemory memory, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkFreeMemory(device, memory, | |
| pAllocator); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkInvalidateMappedMemoryRanges(VkDevice device, | |
| uint32_t memoryRangeCount, | |
| const VkMappedMemoryRange* pMemoryRanges) { | |
| return gpu::GetVulkanFunctionPointers()->vkInvalidateMappedMemoryRanges( | |
| device, memoryRangeCount, pMemoryRanges); | |
| } | |
| ALWAYS_INLINE void vkGetBufferMemoryRequirements( | |
| VkDevice device, | |
| VkBuffer buffer, | |
| VkMemoryRequirements* pMemoryRequirements) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetBufferMemoryRequirements( | |
| device, buffer, pMemoryRequirements); | |
| } | |
| ALWAYS_INLINE void vkGetBufferMemoryRequirements2( | |
| VkDevice device, | |
| const VkBufferMemoryRequirementsInfo2* pInfo, | |
| VkMemoryRequirements2* pMemoryRequirements) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetBufferMemoryRequirements2( | |
| device, pInfo, pMemoryRequirements); | |
| } | |
| ALWAYS_INLINE void vkGetDeviceQueue(VkDevice device, | |
| uint32_t queueFamilyIndex, | |
| uint32_t queueIndex, | |
| VkQueue* pQueue) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetDeviceQueue( | |
| device, queueFamilyIndex, queueIndex, pQueue); | |
| } | |
| ALWAYS_INLINE void vkGetDeviceQueue2(VkDevice device, | |
| const VkDeviceQueueInfo2* pQueueInfo, | |
| VkQueue* pQueue) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetDeviceQueue2(device, pQueueInfo, | |
| pQueue); | |
| } | |
| ALWAYS_INLINE VkResult vkGetFenceStatus(VkDevice device, VkFence fence) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetFenceStatus(device, fence); | |
| } | |
| ALWAYS_INLINE void vkGetImageMemoryRequirements( | |
| VkDevice device, | |
| VkImage image, | |
| VkMemoryRequirements* pMemoryRequirements) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetImageMemoryRequirements( | |
| device, image, pMemoryRequirements); | |
| } | |
| ALWAYS_INLINE void vkGetImageMemoryRequirements2( | |
| VkDevice device, | |
| const VkImageMemoryRequirementsInfo2* pInfo, | |
| VkMemoryRequirements2* pMemoryRequirements) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetImageMemoryRequirements2( | |
| device, pInfo, pMemoryRequirements); | |
| } | |
| ALWAYS_INLINE void vkGetImageSubresourceLayout( | |
| VkDevice device, | |
| VkImage image, | |
| const VkImageSubresource* pSubresource, | |
| VkSubresourceLayout* pLayout) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetImageSubresourceLayout( | |
| device, image, pSubresource, pLayout); | |
| } | |
| ALWAYS_INLINE VkResult vkMapMemory(VkDevice device, | |
| VkDeviceMemory memory, | |
| VkDeviceSize offset, | |
| VkDeviceSize size, | |
| VkMemoryMapFlags flags, | |
| void** ppData) { | |
| return gpu::GetVulkanFunctionPointers()->vkMapMemory(device, memory, offset, | |
| size, flags, ppData); | |
| } | |
| ALWAYS_INLINE VkResult vkQueueSubmit(VkQueue queue, | |
| uint32_t submitCount, | |
| const VkSubmitInfo* pSubmits, | |
| VkFence fence) { | |
| base::AutoLockMaybe auto_lock( | |
| gpu::GetVulkanFunctionPointers()->per_queue_lock_map[queue].get()); | |
| return gpu::GetVulkanFunctionPointers()->vkQueueSubmit(queue, submitCount, | |
| pSubmits, fence); | |
| } | |
| ALWAYS_INLINE VkResult vkQueueWaitIdle(VkQueue queue) { | |
| base::AutoLockMaybe auto_lock( | |
| gpu::GetVulkanFunctionPointers()->per_queue_lock_map[queue].get()); | |
| return gpu::GetVulkanFunctionPointers()->vkQueueWaitIdle(queue); | |
| } | |
| ALWAYS_INLINE VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, | |
| VkCommandBufferResetFlags flags) { | |
| return gpu::GetVulkanFunctionPointers()->vkResetCommandBuffer(commandBuffer, | |
| flags); | |
| } | |
| ALWAYS_INLINE VkResult vkResetFences(VkDevice device, | |
| uint32_t fenceCount, | |
| const VkFence* pFences) { | |
| return gpu::GetVulkanFunctionPointers()->vkResetFences(device, fenceCount, | |
| pFences); | |
| } | |
| ALWAYS_INLINE void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) { | |
| return gpu::GetVulkanFunctionPointers()->vkUnmapMemory(device, memory); | |
| } | |
| ALWAYS_INLINE void vkUpdateDescriptorSets( | |
| VkDevice device, | |
| uint32_t descriptorWriteCount, | |
| const VkWriteDescriptorSet* pDescriptorWrites, | |
| uint32_t descriptorCopyCount, | |
| const VkCopyDescriptorSet* pDescriptorCopies) { | |
| return gpu::GetVulkanFunctionPointers()->vkUpdateDescriptorSets( | |
| device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, | |
| pDescriptorCopies); | |
| } | |
| ALWAYS_INLINE VkResult vkWaitForFences(VkDevice device, | |
| uint32_t fenceCount, | |
| const VkFence* pFences, | |
| VkBool32 waitAll, | |
| uint64_t timeout) { | |
| return gpu::GetVulkanFunctionPointers()->vkWaitForFences( | |
| device, fenceCount, pFences, waitAll, timeout); | |
| } | |
| #if BUILDFLAG(IS_ANDROID) | |
| ALWAYS_INLINE VkResult vkGetAndroidHardwareBufferPropertiesANDROID( | |
| VkDevice device, | |
| const struct AHardwareBuffer* buffer, | |
| VkAndroidHardwareBufferPropertiesANDROID* pProperties) { | |
| return gpu::GetVulkanFunctionPointers() | |
| ->vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer, | |
| pProperties); | |
| } | |
| #endif // BUILDFLAG(IS_ANDROID) | |
| #if BUILDFLAG(IS_POSIX) | |
| ALWAYS_INLINE VkResult | |
| vkGetSemaphoreFdKHR(VkDevice device, | |
| const VkSemaphoreGetFdInfoKHR* pGetFdInfo, | |
| int* pFd) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreFdKHR(device, | |
| pGetFdInfo, pFd); | |
| } | |
| ALWAYS_INLINE VkResult vkImportSemaphoreFdKHR( | |
| VkDevice device, | |
| const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { | |
| return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreFdKHR( | |
| device, pImportSemaphoreFdInfo); | |
| } | |
| #endif // BUILDFLAG(IS_POSIX) | |
| #if BUILDFLAG(IS_WIN) | |
| ALWAYS_INLINE VkResult vkGetSemaphoreWin32HandleKHR( | |
| VkDevice device, | |
| const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, | |
| HANDLE* pHandle) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreWin32HandleKHR( | |
| device, pGetWin32HandleInfo, pHandle); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkImportSemaphoreWin32HandleKHR(VkDevice device, | |
| const VkImportSemaphoreWin32HandleInfoKHR* | |
| pImportSemaphoreWin32HandleInfo) { | |
| return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreWin32HandleKHR( | |
| device, pImportSemaphoreWin32HandleInfo); | |
| } | |
| #endif // BUILDFLAG(IS_WIN) | |
| #if BUILDFLAG(IS_POSIX) | |
| ALWAYS_INLINE VkResult vkGetMemoryFdKHR(VkDevice device, | |
| const VkMemoryGetFdInfoKHR* pGetFdInfo, | |
| int* pFd) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetMemoryFdKHR(device, pGetFdInfo, | |
| pFd); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkGetMemoryFdPropertiesKHR(VkDevice device, | |
| VkExternalMemoryHandleTypeFlagBits handleType, | |
| int fd, | |
| VkMemoryFdPropertiesKHR* pMemoryFdProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetMemoryFdPropertiesKHR( | |
| device, handleType, fd, pMemoryFdProperties); | |
| } | |
| #endif // BUILDFLAG(IS_POSIX) | |
| #if BUILDFLAG(IS_WIN) | |
| ALWAYS_INLINE VkResult vkGetMemoryWin32HandleKHR( | |
| VkDevice device, | |
| const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, | |
| HANDLE* pHandle) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetMemoryWin32HandleKHR( | |
| device, pGetWin32HandleInfo, pHandle); | |
| } | |
| ALWAYS_INLINE VkResult vkGetMemoryWin32HandlePropertiesKHR( | |
| VkDevice device, | |
| VkExternalMemoryHandleTypeFlagBits handleType, | |
| HANDLE handle, | |
| VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetMemoryWin32HandlePropertiesKHR( | |
| device, handleType, handle, pMemoryWin32HandleProperties); | |
| } | |
| #endif // BUILDFLAG(IS_WIN) | |
| #if BUILDFLAG(IS_FUCHSIA) | |
| ALWAYS_INLINE VkResult vkImportSemaphoreZirconHandleFUCHSIA( | |
| VkDevice device, | |
| const VkImportSemaphoreZirconHandleInfoFUCHSIA* | |
| pImportSemaphoreZirconHandleInfo) { | |
| return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreZirconHandleFUCHSIA( | |
| device, pImportSemaphoreZirconHandleInfo); | |
| } | |
| ALWAYS_INLINE VkResult vkGetSemaphoreZirconHandleFUCHSIA( | |
| VkDevice device, | |
| const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, | |
| zx_handle_t* pZirconHandle) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreZirconHandleFUCHSIA( | |
| device, pGetZirconHandleInfo, pZirconHandle); | |
| } | |
| #endif // BUILDFLAG(IS_FUCHSIA) | |
| #if BUILDFLAG(IS_FUCHSIA) | |
| ALWAYS_INLINE VkResult vkGetMemoryZirconHandleFUCHSIA( | |
| VkDevice device, | |
| const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, | |
| zx_handle_t* pZirconHandle) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetMemoryZirconHandleFUCHSIA( | |
| device, pGetZirconHandleInfo, pZirconHandle); | |
| } | |
| #endif // BUILDFLAG(IS_FUCHSIA) | |
| #if BUILDFLAG(IS_FUCHSIA) | |
| ALWAYS_INLINE VkResult vkCreateBufferCollectionFUCHSIA( | |
| VkDevice device, | |
| const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkBufferCollectionFUCHSIA* pCollection) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateBufferCollectionFUCHSIA( | |
| device, pCreateInfo, pAllocator, pCollection); | |
| } | |
| ALWAYS_INLINE VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( | |
| VkDevice device, | |
| VkBufferCollectionFUCHSIA collection, | |
| const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) { | |
| return gpu::GetVulkanFunctionPointers() | |
| ->vkSetBufferCollectionImageConstraintsFUCHSIA(device, collection, | |
| pImageConstraintsInfo); | |
| } | |
| ALWAYS_INLINE VkResult vkGetBufferCollectionPropertiesFUCHSIA( | |
| VkDevice device, | |
| VkBufferCollectionFUCHSIA collection, | |
| VkBufferCollectionPropertiesFUCHSIA* pProperties) { | |
| return gpu::GetVulkanFunctionPointers() | |
| ->vkGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties); | |
| } | |
| ALWAYS_INLINE void vkDestroyBufferCollectionFUCHSIA( | |
| VkDevice device, | |
| VkBufferCollectionFUCHSIA collection, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroyBufferCollectionFUCHSIA( | |
| device, collection, pAllocator); | |
| } | |
| #endif // BUILDFLAG(IS_FUCHSIA) | |
| ALWAYS_INLINE VkResult vkAcquireNextImageKHR(VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| uint64_t timeout, | |
| VkSemaphore semaphore, | |
| VkFence fence, | |
| uint32_t* pImageIndex) { | |
| return gpu::GetVulkanFunctionPointers()->vkAcquireNextImageKHR( | |
| device, swapchain, timeout, semaphore, fence, pImageIndex); | |
| } | |
| ALWAYS_INLINE VkResult | |
| vkCreateSwapchainKHR(VkDevice device, | |
| const VkSwapchainCreateInfoKHR* pCreateInfo, | |
| const VkAllocationCallbacks* pAllocator, | |
| VkSwapchainKHR* pSwapchain) { | |
| return gpu::GetVulkanFunctionPointers()->vkCreateSwapchainKHR( | |
| device, pCreateInfo, pAllocator, pSwapchain); | |
| } | |
| ALWAYS_INLINE void vkDestroySwapchainKHR( | |
| VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| const VkAllocationCallbacks* pAllocator) { | |
| return gpu::GetVulkanFunctionPointers()->vkDestroySwapchainKHR( | |
| device, swapchain, pAllocator); | |
| } | |
| ALWAYS_INLINE VkResult vkGetSwapchainImagesKHR(VkDevice device, | |
| VkSwapchainKHR swapchain, | |
| uint32_t* pSwapchainImageCount, | |
| VkImage* pSwapchainImages) { | |
| return gpu::GetVulkanFunctionPointers()->vkGetSwapchainImagesKHR( | |
| device, swapchain, pSwapchainImageCount, pSwapchainImages); | |
| } | |
| ALWAYS_INLINE VkResult vkQueuePresentKHR(VkQueue queue, | |
| const VkPresentInfoKHR* pPresentInfo) { | |
| base::AutoLockMaybe auto_lock( | |
| gpu::GetVulkanFunctionPointers()->per_queue_lock_map[queue].get()); | |
| return gpu::GetVulkanFunctionPointers()->vkQueuePresentKHR(queue, | |
| pPresentInfo); | |
| } | |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) | |
| ALWAYS_INLINE VkResult vkGetImageDrmFormatModifierPropertiesEXT( | |
| VkDevice device, | |
| VkImage image, | |
| VkImageDrmFormatModifierPropertiesEXT* pProperties) { | |
| return gpu::GetVulkanFunctionPointers() | |
| ->vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); | |
| } | |
| #endif // BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) | |
| #endif // GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_ |