| // Copyright 2018 The Chromium Authors. All rights reserved. |
| // 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_ |
