Skip to content

GitLab

T
tangled
Commit 8cff2cd0 authored by Peng Huang's avatar Peng Huang Committed by Commit Bot
Browse files
Options

vulkan: enable the possibility of using vulkan c++ binding 

The vulkan.hpp is included in the upstream Khronos vulkan headers
package. It is a vulkan c++ binding generated from vulkan registry.
It is implemented with c++ template in a single header file.

This change updates gpu::VulkanFunctionPointers to make it compatible
with vulkan.hpp, and adds vulkan_cxx.h which setups several necessary
macros before including <vulkan/vulkan.hpp>. So any code wants to use
vulkan c++ binding just needs to include vulkan_cxx.h.

This change also adds a test for the vulkan c++ binding.

Change-Id: I74c7003008082686984b559c729bdecac1b08efd
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2198140
Commit-Queue: Peng Huang <penghuang@chromium.org>
Reviewed-by: default avatarVasiliy Telezhnikov <vasilyt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#770361}
parent eaf102da
Hide whitespace changes
Inline Side-by-side
Showing with 664 additions and 548 deletions
gpu/vulkan/BUILD.gn
View file @ 8cff2cd0
......@@ -85,6 +85,7 @@ if (enable_vulkan) {
"vulkan_command_pool.h",
"vulkan_crash_keys.cc",
"vulkan_crash_keys.h",
"vulkan_cxx.h",
"vulkan_device_queue.cc",
"vulkan_device_queue.h",
"vulkan_fence_helper.cc",
......@@ -203,6 +204,7 @@ if (enable_vulkan) {
"tests/basic_vulkan_test.h",
"tests/vulkan_test.cc",
"tests/vulkan_tests_main.cc",
"vulkan_cxx_unittest.cc",
"vulkan_fence_helper_unittest.cc",
"vulkan_image_unittest.cc",
]
......
gpu/vulkan/generate_bindings.py
View file @ 8cff2cd0
......@@ -26,7 +26,7 @@ VULKAN_UNASSOCIATED_FUNCTIONS = [
{
'functions': [
# vkGetInstanceProcAddr belongs here but is handled specially.
# vkEnumerateInstanceVersion belongs here but is handled specially.
'vkEnumerateInstanceVersion',
'vkCreateInstance',
'vkEnumerateInstanceExtensionProperties',
'vkEnumerateInstanceLayerProperties',
......@@ -326,7 +326,7 @@ def WriteFunctions(file, functions, template, check_extension=False):
WriteFunctionsInternal(file, functions, gen_content, check_extension)
def WriteFunctionDeclarations(file, functions):
template = Template(' VulkanFunction<PFN_${name}> ${name}Fn;\n')
template = Template(' VulkanFunction<PFN_${name}> ${name};\n')
WriteFunctions(file, functions, template)
def WriteMacros(file, functions):
......@@ -335,7 +335,7 @@ def WriteMacros(file, functions):
# Some fuchsia functions are not in the vulkan registry, so use macro for
# them.
template = Template(
'#define $name gpu::GetVulkanFunctionPointers()->${name}Fn\n')
'#define $name gpu::GetVulkanFunctionPointers()->${name}\n')
return template.substitute({'name': func, 'extension_suffix' : suffix})
none_str = lambda s: s if s else ''
cmd = registry.cmddict[func].elem
......@@ -348,7 +348,7 @@ def WriteMacros(file, functions):
pdecl += text + tail
n = len(params)
callstat = 'return gpu::GetVulkanFunctionPointers()->%sFn(' % func
callstat = 'return gpu::GetVulkanFunctionPointers()->%s(' % func
paramdecl = '('
if n > 0:
paramnames = (''.join(t for t in p.itertext())
......@@ -437,12 +437,12 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
public:
using Fn = R(VKAPI_PTR*)(Args...);
explicit operator bool() {
explicit operator bool() const {
return !!fn_;
}
NO_SANITIZE("cfi-icall")
R operator()(Args... args) {
R operator()(Args... args) const {
return fn_(args...);
}
......@@ -460,8 +460,7 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
};
// Unassociated functions
VulkanFunction<PFN_vkEnumerateInstanceVersion> vkEnumerateInstanceVersionFn;
VulkanFunction<PFN_vkGetInstanceProcAddr> vkGetInstanceProcAddrFn;
VulkanFunction<PFN_vkGetInstanceProcAddr> vkGetInstanceProcAddr;
""")
......@@ -489,8 +488,7 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
// Unassociated functions
""")
WriteMacros(file, [{'functions': [ 'vkGetInstanceProcAddr' ,
'vkEnumerateInstanceVersion']}])
WriteMacros(file, [{'functions': [ 'vkGetInstanceProcAddr']}])
WriteMacros(file, VULKAN_UNASSOCIATED_FUNCTIONS)
file.write("""\
......@@ -513,9 +511,9 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
def WriteFunctionPointerInitialization(file, proc_addr_function, parent,
functions):
template = Template(""" ${name}Fn = reinterpret_cast<PFN_${name}>(
template = Template(""" ${name} = reinterpret_cast<PFN_${name}>(
${get_proc_addr}(${parent}, "${name}${extension_suffix}"));
if (!${name}Fn) {
if (!${name}) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "${name}${extension_suffix}";
return false;
......@@ -568,17 +566,11 @@ bool VulkanFunctionPointers::BindUnassociatedFunctionPointers() {
// vkGetInstanceProcAddr must be handled specially since it gets its function
// pointer through base::GetFunctionPOinterFromNativeLibrary(). Other Vulkan
// functions don't do this.
vkGetInstanceProcAddrFn = reinterpret_cast<PFN_vkGetInstanceProcAddr>(
vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(
base::GetFunctionPointerFromNativeLibrary(vulkan_loader_library,
"vkGetInstanceProcAddr"));
if (!vkGetInstanceProcAddrFn)
if (!vkGetInstanceProcAddr)
return false;
vkEnumerateInstanceVersionFn =
reinterpret_cast<PFN_vkEnumerateInstanceVersion>(
vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceVersion"));
// vkEnumerateInstanceVersion didn't exist in Vulkan 1.0, so we should
// proceed even if we fail to get vkEnumerateInstanceVersion pointer.
""")
WriteUnassociatedFunctionPointerInitialization(
......
gpu/vulkan/vma_wrapper.cc
View file @ 8cff2cd0
......@@ -18,25 +18,25 @@ VkResult CreateAllocator(VkPhysicalDevice physical_device,
VmaAllocator* pAllocator) {
auto* function_pointers = gpu::GetVulkanFunctionPointers();
VmaVulkanFunctions functions = {
function_pointers->vkGetPhysicalDevicePropertiesFn.get(),
function_pointers->vkGetPhysicalDeviceMemoryPropertiesFn.get(),
function_pointers->vkAllocateMemoryFn.get(),
function_pointers->vkFreeMemoryFn.get(),
function_pointers->vkMapMemoryFn.get(),
function_pointers->vkUnmapMemoryFn.get(),
function_pointers->vkFlushMappedMemoryRangesFn.get(),
function_pointers->vkInvalidateMappedMemoryRangesFn.get(),
function_pointers->vkBindBufferMemoryFn.get(),
function_pointers->vkBindImageMemoryFn.get(),
function_pointers->vkGetBufferMemoryRequirementsFn.get(),
function_pointers->vkGetImageMemoryRequirementsFn.get(),
function_pointers->vkCreateBufferFn.get(),
function_pointers->vkDestroyBufferFn.get(),
function_pointers->vkCreateImageFn.get(),
function_pointers->vkDestroyImageFn.get(),
function_pointers->vkCmdCopyBufferFn.get(),
function_pointers->vkGetBufferMemoryRequirements2Fn.get(),
function_pointers->vkGetImageMemoryRequirements2Fn.get(),
function_pointers->vkGetPhysicalDeviceProperties.get(),
function_pointers->vkGetPhysicalDeviceMemoryProperties.get(),
function_pointers->vkAllocateMemory.get(),
function_pointers->vkFreeMemory.get(),
function_pointers->vkMapMemory.get(),
function_pointers->vkUnmapMemory.get(),
function_pointers->vkFlushMappedMemoryRanges.get(),
function_pointers->vkInvalidateMappedMemoryRanges.get(),
function_pointers->vkBindBufferMemory.get(),
function_pointers->vkBindImageMemory.get(),
function_pointers->vkGetBufferMemoryRequirements.get(),
function_pointers->vkGetImageMemoryRequirements.get(),
function_pointers->vkCreateBuffer.get(),
function_pointers->vkDestroyBuffer.get(),
function_pointers->vkCreateImage.get(),
function_pointers->vkDestroyImage.get(),
function_pointers->vkCmdCopyBuffer.get(),
function_pointers->vkGetBufferMemoryRequirements2.get(),
function_pointers->vkGetImageMemoryRequirements2.get(),
};
VmaAllocatorCreateInfo allocator_info = {
......
gpu/vulkan/vulkan_cxx.h 0 → 100644
View file @ 8cff2cd0
// Copyright 2020 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.
#ifndef GPU_VULKAN_VULKAN_CXX_H_
#define GPU_VULKAN_VULKAN_CXX_H_
#include <ostream>
#include "base/compiler_specific.h"
// Disable vulkan prototypes.
#if !defined(VK_NO_PROTOTYPES)
#define VK_NO_PROTOTYPES 1
#endif
// Disable dynamic loader tool.
#define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 0
// Disable c++ exceptions.
#define VULKAN_HPP_NO_EXCEPTIONS 1
// Disable dynamic dispatch loader.
#define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
// Set gpu::VulkanFunctionPointers as the default dispatcher.
#define VULKAN_HPP_DEFAULT_DISPATCHER (*gpu::GetVulkanFunctionPointers())
#define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE gpu::VulkanFunctionPointers
#include "gpu/vulkan/vulkan_function_pointers.h"
#include <vulkan/vulkan.hpp>
// operator for LOG() << result
ALWAYS_INLINE std::ostream& operator<<(std::ostream& out, vk::Result result) {
out << static_cast<VkResult>(result);
return out;
}
#endif // GPU_VULKAN_VULKAN_CXX_H_
\ No newline at end of file
gpu/vulkan/vulkan_cxx_unittest.cc 0 → 100644
View file @ 8cff2cd0
// Copyright 2020 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.
#include "testing/gtest/include/gtest/gtest.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/native_library.h"
#include "base/path_service.h"
#include "build/build_config.h"
#include "gpu/vulkan/vulkan_cxx.h"
#include "gpu/vulkan/vulkan_function_pointers.h"
namespace gpu {
class VulkanCXXTest : public testing::Test {
public:
VulkanCXXTest() = default;
~VulkanCXXTest() override = default;
void SetUp() override {
use_swiftshader_ =
base::CommandLine::ForCurrentProcess()->HasSwitch("use-swiftshader");
base::FilePath path;
#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_CHROMEOS) || \
defined(OS_FUCHSIA)
if (use_swiftshader_) {
#if defined(OS_LINUX)
EXPECT_TRUE(base::PathService::Get(base::DIR_MODULE, &path));
path = path.Append("libvk_swiftshader.so");
#else
return;
#endif
} else {
path = base::FilePath("libvulkan.so.1");
}
#elif defined(OS_WIN)
if (use_swiftshader_) {
EXPECT_TRUE(base::PathService::Get(base::DIR_MODULE, &path));
path = path.Append(L"vk_swiftshader.dll");
} else {
path = base::FilePath(L"vulkan-1.dll");
}
#else
#error "Not supported platform"
#endif
auto* vulkan_function_pointers = GetVulkanFunctionPointers();
base::NativeLibraryLoadError native_library_load_error;
vulkan_function_pointers->vulkan_loader_library =
base::LoadNativeLibrary(path, &native_library_load_error);
EXPECT_TRUE(vulkan_function_pointers->vulkan_loader_library);
}
void TearDown() override {
auto* vulkan_function_pointers = GetVulkanFunctionPointers();
base::UnloadNativeLibrary(vulkan_function_pointers->vulkan_loader_library);
}
private:
bool use_swiftshader_ = false;
};
TEST_F(VulkanCXXTest, CreateInstanceUnique) {
auto* vulkan_function_pointers = GetVulkanFunctionPointers();
EXPECT_TRUE(vulkan_function_pointers->BindUnassociatedFunctionPointers());
constexpr uint32_t kRequiredApiVersion = VK_MAKE_VERSION(1, 1, 0);
vk::Result result;
uint32_t api_version;
std::tie(result, api_version) = vk::enumerateInstanceVersion();
EXPECT_EQ(result, vk::Result::eSuccess);
EXPECT_GE(api_version, kRequiredApiVersion);
vk::ApplicationInfo app_info("VulkanCXXTest", 0, nullptr, 0,
kRequiredApiVersion);
vk::InstanceCreateInfo instance_create_info({}, &app_info);
auto result_value = vk::createInstanceUnique(instance_create_info);
EXPECT_EQ(result_value.result, vk::Result::eSuccess);
vk::UniqueInstance instance = std::move(result_value.value);
EXPECT_TRUE(instance);
EXPECT_TRUE(vulkan_function_pointers->BindInstanceFunctionPointers(
instance.get(), kRequiredApiVersion, gfx::ExtensionSet()));
instance.reset();
}
} // namespace gpu
gpu/vulkan/vulkan_function_pointers.cc
View file @ 8cff2cd0
......@@ -27,39 +27,41 @@ bool VulkanFunctionPointers::BindUnassociatedFunctionPointers() {
// vkGetInstanceProcAddr must be handled specially since it gets its function
// pointer through base::GetFunctionPOinterFromNativeLibrary(). Other Vulkan
// functions don't do this.
vkGetInstanceProcAddrFn = reinterpret_cast<PFN_vkGetInstanceProcAddr>(
vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(
base::GetFunctionPointerFromNativeLibrary(vulkan_loader_library,
"vkGetInstanceProcAddr"));
if (!vkGetInstanceProcAddrFn)
if (!vkGetInstanceProcAddr)
return false;
vkEnumerateInstanceVersion = reinterpret_cast<PFN_vkEnumerateInstanceVersion>(
vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceVersion"));
if (!vkEnumerateInstanceVersion) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkEnumerateInstanceVersion";
return false;
}
vkEnumerateInstanceVersionFn =
reinterpret_cast<PFN_vkEnumerateInstanceVersion>(
vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceVersion"));
// vkEnumerateInstanceVersion didn't exist in Vulkan 1.0, so we should
// proceed even if we fail to get vkEnumerateInstanceVersion pointer.
vkCreateInstanceFn = reinterpret_cast<PFN_vkCreateInstance>(
vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(
vkGetInstanceProcAddr(nullptr, "vkCreateInstance"));
if (!vkCreateInstanceFn) {
if (!vkCreateInstance) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateInstance";
return false;
}
vkEnumerateInstanceExtensionPropertiesFn =
vkEnumerateInstanceExtensionProperties =
reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(
vkGetInstanceProcAddr(nullptr,
"vkEnumerateInstanceExtensionProperties"));
if (!vkEnumerateInstanceExtensionPropertiesFn) {
if (!vkEnumerateInstanceExtensionProperties) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkEnumerateInstanceExtensionProperties";
return false;
}
vkEnumerateInstanceLayerPropertiesFn =
vkEnumerateInstanceLayerProperties =
reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceLayerProperties"));
if (!vkEnumerateInstanceLayerPropertiesFn) {
if (!vkEnumerateInstanceLayerProperties) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkEnumerateInstanceLayerProperties";
return false;
......@@ -72,102 +74,101 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
VkInstance vk_instance,
uint32_t api_version,
const gfx::ExtensionSet& enabled_extensions) {
vkCreateDeviceFn = reinterpret_cast<PFN_vkCreateDevice>(
vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(
vkGetInstanceProcAddr(vk_instance, "vkCreateDevice"));
if (!vkCreateDeviceFn) {
if (!vkCreateDevice) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateDevice";
return false;
}
vkDestroyInstanceFn = reinterpret_cast<PFN_vkDestroyInstance>(
vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(
vkGetInstanceProcAddr(vk_instance, "vkDestroyInstance"));
if (!vkDestroyInstanceFn) {
if (!vkDestroyInstance) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyInstance";
return false;
}
vkEnumerateDeviceExtensionPropertiesFn =
vkEnumerateDeviceExtensionProperties =
reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(
vkGetInstanceProcAddr(vk_instance,
"vkEnumerateDeviceExtensionProperties"));
if (!vkEnumerateDeviceExtensionPropertiesFn) {
if (!vkEnumerateDeviceExtensionProperties) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkEnumerateDeviceExtensionProperties";
return false;
}
vkEnumerateDeviceLayerPropertiesFn =
vkEnumerateDeviceLayerProperties =
reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(
vkGetInstanceProcAddr(vk_instance,
"vkEnumerateDeviceLayerProperties"));
if (!vkEnumerateDeviceLayerPropertiesFn) {
if (!vkEnumerateDeviceLayerProperties) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkEnumerateDeviceLayerProperties";
return false;
}
vkEnumeratePhysicalDevicesFn =
reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(
vkGetInstanceProcAddr(vk_instance, "vkEnumeratePhysicalDevices"));
if (!vkEnumeratePhysicalDevicesFn) {
vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(
vkGetInstanceProcAddr(vk_instance, "vkEnumeratePhysicalDevices"));
if (!vkEnumeratePhysicalDevices) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkEnumeratePhysicalDevices";
return false;
}
vkGetDeviceProcAddrFn = reinterpret_cast<PFN_vkGetDeviceProcAddr>(
vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(
vkGetInstanceProcAddr(vk_instance, "vkGetDeviceProcAddr"));
if (!vkGetDeviceProcAddrFn) {
if (!vkGetDeviceProcAddr) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetDeviceProcAddr";
return false;
}
vkGetPhysicalDeviceFeaturesFn =
vkGetPhysicalDeviceFeatures =
reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(
vkGetInstanceProcAddr(vk_instance, "vkGetPhysicalDeviceFeatures"));
if (!vkGetPhysicalDeviceFeaturesFn) {
if (!vkGetPhysicalDeviceFeatures) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceFeatures";
return false;
}
vkGetPhysicalDeviceFormatPropertiesFn =
vkGetPhysicalDeviceFormatProperties =
reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(
vkGetInstanceProcAddr(vk_instance,
"vkGetPhysicalDeviceFormatProperties"));
if (!vkGetPhysicalDeviceFormatPropertiesFn) {
if (!vkGetPhysicalDeviceFormatProperties) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceFormatProperties";
return false;
}
vkGetPhysicalDeviceMemoryPropertiesFn =
vkGetPhysicalDeviceMemoryProperties =
reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(
vkGetInstanceProcAddr(vk_instance,
"vkGetPhysicalDeviceMemoryProperties"));
if (!vkGetPhysicalDeviceMemoryPropertiesFn) {
if (!vkGetPhysicalDeviceMemoryProperties) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceMemoryProperties";
return false;
}
vkGetPhysicalDevicePropertiesFn =
vkGetPhysicalDeviceProperties =
reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(
vkGetInstanceProcAddr(vk_instance, "vkGetPhysicalDeviceProperties"));
if (!vkGetPhysicalDevicePropertiesFn) {
if (!vkGetPhysicalDeviceProperties) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceProperties";
return false;
}
vkGetPhysicalDeviceQueueFamilyPropertiesFn =
vkGetPhysicalDeviceQueueFamilyProperties =
reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(
vkGetInstanceProcAddr(vk_instance,
"vkGetPhysicalDeviceQueueFamilyProperties"));
if (!vkGetPhysicalDeviceQueueFamilyPropertiesFn) {
if (!vkGetPhysicalDeviceQueueFamilyProperties) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceQueueFamilyProperties";
return false;
......@@ -176,21 +177,21 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
#if DCHECK_IS_ON()
if (gfx::HasExtension(enabled_extensions,
VK_EXT_DEBUG_REPORT_EXTENSION_NAME)) {
vkCreateDebugReportCallbackEXTFn =
vkCreateDebugReportCallbackEXT =
reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(
vkGetInstanceProcAddr(vk_instance,
"vkCreateDebugReportCallbackEXT"));
if (!vkCreateDebugReportCallbackEXTFn) {
if (!vkCreateDebugReportCallbackEXT) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateDebugReportCallbackEXT";
return false;
}
vkDestroyDebugReportCallbackEXTFn =
vkDestroyDebugReportCallbackEXT =
reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
vkGetInstanceProcAddr(vk_instance,
"vkDestroyDebugReportCallbackEXT"));
if (!vkDestroyDebugReportCallbackEXTFn) {
if (!vkDestroyDebugReportCallbackEXT) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyDebugReportCallbackEXT";
return false;
......@@ -199,39 +200,39 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
#endif // DCHECK_IS_ON()
if (gfx::HasExtension(enabled_extensions, VK_KHR_SURFACE_EXTENSION_NAME)) {
vkDestroySurfaceKHRFn = reinterpret_cast<PFN_vkDestroySurfaceKHR>(
vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(
vkGetInstanceProcAddr(vk_instance, "vkDestroySurfaceKHR"));
if (!vkDestroySurfaceKHRFn) {
if (!vkDestroySurfaceKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroySurfaceKHR";
return false;
}
vkGetPhysicalDeviceSurfaceCapabilitiesKHRFn =
vkGetPhysicalDeviceSurfaceCapabilitiesKHR =
reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(
vkGetInstanceProcAddr(vk_instance,
"vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
if (!vkGetPhysicalDeviceSurfaceCapabilitiesKHRFn) {
if (!vkGetPhysicalDeviceSurfaceCapabilitiesKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceSurfaceCapabilitiesKHR";
return false;
}
vkGetPhysicalDeviceSurfaceFormatsKHRFn =
vkGetPhysicalDeviceSurfaceFormatsKHR =
reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(
vkGetInstanceProcAddr(vk_instance,
"vkGetPhysicalDeviceSurfaceFormatsKHR"));
if (!vkGetPhysicalDeviceSurfaceFormatsKHRFn) {
if (!vkGetPhysicalDeviceSurfaceFormatsKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceSurfaceFormatsKHR";
return false;
}
vkGetPhysicalDeviceSurfaceSupportKHRFn =
vkGetPhysicalDeviceSurfaceSupportKHR =
reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(
vkGetInstanceProcAddr(vk_instance,
"vkGetPhysicalDeviceSurfaceSupportKHR"));
if (!vkGetPhysicalDeviceSurfaceSupportKHRFn) {
if (!vkGetPhysicalDeviceSurfaceSupportKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceSurfaceSupportKHR";
return false;
......@@ -241,19 +242,19 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
#if defined(USE_VULKAN_XLIB)
if (gfx::HasExtension(enabled_extensions,
VK_KHR_XLIB_SURFACE_EXTENSION_NAME)) {
vkCreateXlibSurfaceKHRFn = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(
vkCreateXlibSurfaceKHR = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(
vkGetInstanceProcAddr(vk_instance, "vkCreateXlibSurfaceKHR"));
if (!vkCreateXlibSurfaceKHRFn) {
if (!vkCreateXlibSurfaceKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateXlibSurfaceKHR";
return false;
}
vkGetPhysicalDeviceXlibPresentationSupportKHRFn =
vkGetPhysicalDeviceXlibPresentationSupportKHR =
reinterpret_cast<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>(
vkGetInstanceProcAddr(
vk_instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
if (!vkGetPhysicalDeviceXlibPresentationSupportKHRFn) {
if (!vkGetPhysicalDeviceXlibPresentationSupportKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceXlibPresentationSupportKHR";
return false;
......@@ -264,19 +265,19 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
#if defined(OS_WIN)
if (gfx::HasExtension(enabled_extensions,
VK_KHR_WIN32_SURFACE_EXTENSION_NAME)) {
vkCreateWin32SurfaceKHRFn = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(
vkCreateWin32SurfaceKHR = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(
vkGetInstanceProcAddr(vk_instance, "vkCreateWin32SurfaceKHR"));
if (!vkCreateWin32SurfaceKHRFn) {
if (!vkCreateWin32SurfaceKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateWin32SurfaceKHR";
return false;
}
vkGetPhysicalDeviceWin32PresentationSupportKHRFn =
vkGetPhysicalDeviceWin32PresentationSupportKHR =
reinterpret_cast<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>(
vkGetInstanceProcAddr(
vk_instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
if (!vkGetPhysicalDeviceWin32PresentationSupportKHRFn) {
if (!vkGetPhysicalDeviceWin32PresentationSupportKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceWin32PresentationSupportKHR";
return false;
......@@ -287,10 +288,9 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
#if defined(OS_ANDROID)
if (gfx::HasExtension(enabled_extensions,
VK_KHR_ANDROID_SURFACE_EXTENSION_NAME)) {
vkCreateAndroidSurfaceKHRFn =
reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(
vkGetInstanceProcAddr(vk_instance, "vkCreateAndroidSurfaceKHR"));
if (!vkCreateAndroidSurfaceKHRFn) {
vkCreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(
vkGetInstanceProcAddr(vk_instance, "vkCreateAndroidSurfaceKHR"));
if (!vkCreateAndroidSurfaceKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateAndroidSurfaceKHR";
return false;
......@@ -301,11 +301,11 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
#if defined(OS_FUCHSIA)
if (gfx::HasExtension(enabled_extensions,
VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME)) {
vkCreateImagePipeSurfaceFUCHSIAFn =
vkCreateImagePipeSurfaceFUCHSIA =
reinterpret_cast<PFN_vkCreateImagePipeSurfaceFUCHSIA>(
vkGetInstanceProcAddr(vk_instance,
"vkCreateImagePipeSurfaceFUCHSIA"));
if (!vkCreateImagePipeSurfaceFUCHSIAFn) {
if (!vkCreateImagePipeSurfaceFUCHSIA) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateImagePipeSurfaceFUCHSIA";
return false;
......@@ -314,11 +314,11 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
#endif // defined(OS_FUCHSIA)
if (api_version >= VK_API_VERSION_1_1) {
vkGetPhysicalDeviceImageFormatProperties2Fn =
vkGetPhysicalDeviceImageFormatProperties2 =
reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties2>(
vkGetInstanceProcAddr(vk_instance,
"vkGetPhysicalDeviceImageFormatProperties2"));
if (!vkGetPhysicalDeviceImageFormatProperties2Fn) {
if (!vkGetPhysicalDeviceImageFormatProperties2) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceImageFormatProperties2";
return false;
......@@ -326,10 +326,10 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
}
if (api_version >= VK_API_VERSION_1_1) {
vkGetPhysicalDeviceFeatures2Fn =
vkGetPhysicalDeviceFeatures2 =
reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures2>(
vkGetInstanceProcAddr(vk_instance, "vkGetPhysicalDeviceFeatures2"));
if (!vkGetPhysicalDeviceFeatures2Fn) {
if (!vkGetPhysicalDeviceFeatures2) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceFeatures2";
return false;
......@@ -338,11 +338,11 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
} else if (gfx::HasExtension(
enabled_extensions,
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
vkGetPhysicalDeviceFeatures2Fn =
vkGetPhysicalDeviceFeatures2 =
reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures2>(
vkGetInstanceProcAddr(vk_instance,
"vkGetPhysicalDeviceFeatures2KHR"));
if (!vkGetPhysicalDeviceFeatures2Fn) {
if (!vkGetPhysicalDeviceFeatures2) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetPhysicalDeviceFeatures2KHR";
return false;
......@@ -357,489 +357,489 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(
uint32_t api_version,
const gfx::ExtensionSet& enabled_extensions) {
// Device functions
vkAllocateCommandBuffersFn = reinterpret_cast<PFN_vkAllocateCommandBuffers>(
vkAllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(
vkGetDeviceProcAddr(vk_device, "vkAllocateCommandBuffers"));
if (!vkAllocateCommandBuffersFn) {
if (!vkAllocateCommandBuffers) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkAllocateCommandBuffers";
return false;
}
vkAllocateDescriptorSetsFn = reinterpret_cast<PFN_vkAllocateDescriptorSets>(
vkAllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(
vkGetDeviceProcAddr(vk_device, "vkAllocateDescriptorSets"));
if (!vkAllocateDescriptorSetsFn) {
if (!vkAllocateDescriptorSets) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkAllocateDescriptorSets";
return false;
}
vkAllocateMemoryFn = reinterpret_cast<PFN_vkAllocateMemory>(
vkAllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(
vkGetDeviceProcAddr(vk_device, "vkAllocateMemory"));
if (!vkAllocateMemoryFn) {
if (!vkAllocateMemory) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkAllocateMemory";
return false;
}
vkBeginCommandBufferFn = reinterpret_cast<PFN_vkBeginCommandBuffer>(
vkBeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(
vkGetDeviceProcAddr(vk_device, "vkBeginCommandBuffer"));
if (!vkBeginCommandBufferFn) {
if (!vkBeginCommandBuffer) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkBeginCommandBuffer";
return false;
}
vkBindBufferMemoryFn = reinterpret_cast<PFN_vkBindBufferMemory>(
vkBindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(
vkGetDeviceProcAddr(vk_device, "vkBindBufferMemory"));
if (!vkBindBufferMemoryFn) {
if (!vkBindBufferMemory) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkBindBufferMemory";
return false;
}
vkBindImageMemoryFn = reinterpret_cast<PFN_vkBindImageMemory>(
vkBindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(
vkGetDeviceProcAddr(vk_device, "vkBindImageMemory"));
if (!vkBindImageMemoryFn) {
if (!vkBindImageMemory) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkBindImageMemory";
return false;
}
vkCmdBeginRenderPassFn = reinterpret_cast<PFN_vkCmdBeginRenderPass>(
vkCmdBeginRenderPass = reinterpret_cast<PFN_vkCmdBeginRenderPass>(
vkGetDeviceProcAddr(vk_device, "vkCmdBeginRenderPass"));
if (!vkCmdBeginRenderPassFn) {
if (!vkCmdBeginRenderPass) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCmdBeginRenderPass";
return false;
}
vkCmdCopyBufferFn = reinterpret_cast<PFN_vkCmdCopyBuffer>(
vkCmdCopyBuffer = reinterpret_cast<PFN_vkCmdCopyBuffer>(
vkGetDeviceProcAddr(vk_device, "vkCmdCopyBuffer"));
if (!vkCmdCopyBufferFn) {
if (!vkCmdCopyBuffer) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCmdCopyBuffer";
return false;
}
vkCmdCopyBufferToImageFn = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(
vkCmdCopyBufferToImage = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(
vkGetDeviceProcAddr(vk_device, "vkCmdCopyBufferToImage"));
if (!vkCmdCopyBufferToImageFn) {
if (!vkCmdCopyBufferToImage) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCmdCopyBufferToImage";
return false;
}
vkCmdEndRenderPassFn = reinterpret_cast<PFN_vkCmdEndRenderPass>(
vkCmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(
vkGetDeviceProcAddr(vk_device, "vkCmdEndRenderPass"));
if (!vkCmdEndRenderPassFn) {
if (!vkCmdEndRenderPass) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCmdEndRenderPass";
return false;
}
vkCmdExecuteCommandsFn = reinterpret_cast<PFN_vkCmdExecuteCommands>(
vkCmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(
vkGetDeviceProcAddr(vk_device, "vkCmdExecuteCommands"));
if (!vkCmdExecuteCommandsFn) {
if (!vkCmdExecuteCommands) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCmdExecuteCommands";
return false;
}
vkCmdNextSubpassFn = reinterpret_cast<PFN_vkCmdNextSubpass>(
vkCmdNextSubpass = reinterpret_cast<PFN_vkCmdNextSubpass>(
vkGetDeviceProcAddr(vk_device, "vkCmdNextSubpass"));
if (!vkCmdNextSubpassFn) {
if (!vkCmdNextSubpass) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCmdNextSubpass";
return false;
}
vkCmdPipelineBarrierFn = reinterpret_cast<PFN_vkCmdPipelineBarrier>(
vkCmdPipelineBarrier = reinterpret_cast<PFN_vkCmdPipelineBarrier>(
vkGetDeviceProcAddr(vk_device, "vkCmdPipelineBarrier"));
if (!vkCmdPipelineBarrierFn) {
if (!vkCmdPipelineBarrier) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCmdPipelineBarrier";
return false;
}
vkCreateBufferFn = reinterpret_cast<PFN_vkCreateBuffer>(
vkCreateBuffer = reinterpret_cast<PFN_vkCreateBuffer>(
vkGetDeviceProcAddr(vk_device, "vkCreateBuffer"));
if (!vkCreateBufferFn) {
if (!vkCreateBuffer) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateBuffer";
return false;
}
vkCreateCommandPoolFn = reinterpret_cast<PFN_vkCreateCommandPool>(
vkCreateCommandPool = reinterpret_cast<PFN_vkCreateCommandPool>(
vkGetDeviceProcAddr(vk_device, "vkCreateCommandPool"));
if (!vkCreateCommandPoolFn) {
if (!vkCreateCommandPool) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateCommandPool";
return false;
}
vkCreateDescriptorPoolFn = reinterpret_cast<PFN_vkCreateDescriptorPool>(
vkCreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(
vkGetDeviceProcAddr(vk_device, "vkCreateDescriptorPool"));
if (!vkCreateDescriptorPoolFn) {
if (!vkCreateDescriptorPool) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateDescriptorPool";
return false;
}
vkCreateDescriptorSetLayoutFn =
vkCreateDescriptorSetLayout =
reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(
vkGetDeviceProcAddr(vk_device, "vkCreateDescriptorSetLayout"));
if (!vkCreateDescriptorSetLayoutFn) {
if (!vkCreateDescriptorSetLayout) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateDescriptorSetLayout";
return false;
}
vkCreateFenceFn = reinterpret_cast<PFN_vkCreateFence>(
vkCreateFence = reinterpret_cast<PFN_vkCreateFence>(
vkGetDeviceProcAddr(vk_device, "vkCreateFence"));
if (!vkCreateFenceFn) {
if (!vkCreateFence) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateFence";
return false;
}
vkCreateFramebufferFn = reinterpret_cast<PFN_vkCreateFramebuffer>(
vkCreateFramebuffer = reinterpret_cast<PFN_vkCreateFramebuffer>(
vkGetDeviceProcAddr(vk_device, "vkCreateFramebuffer"));
if (!vkCreateFramebufferFn) {
if (!vkCreateFramebuffer) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateFramebuffer";
return false;
}
vkCreateImageFn = reinterpret_cast<PFN_vkCreateImage>(
vkCreateImage = reinterpret_cast<PFN_vkCreateImage>(
vkGetDeviceProcAddr(vk_device, "vkCreateImage"));
if (!vkCreateImageFn) {
if (!vkCreateImage) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateImage";
return false;
}
vkCreateImageViewFn = reinterpret_cast<PFN_vkCreateImageView>(
vkCreateImageView = reinterpret_cast<PFN_vkCreateImageView>(
vkGetDeviceProcAddr(vk_device, "vkCreateImageView"));
if (!vkCreateImageViewFn) {
if (!vkCreateImageView) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateImageView";
return false;
}
vkCreateRenderPassFn = reinterpret_cast<PFN_vkCreateRenderPass>(
vkCreateRenderPass = reinterpret_cast<PFN_vkCreateRenderPass>(
vkGetDeviceProcAddr(vk_device, "vkCreateRenderPass"));
if (!vkCreateRenderPassFn) {
if (!vkCreateRenderPass) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateRenderPass";
return false;
}
vkCreateSamplerFn = reinterpret_cast<PFN_vkCreateSampler>(
vkCreateSampler = reinterpret_cast<PFN_vkCreateSampler>(
vkGetDeviceProcAddr(vk_device, "vkCreateSampler"));
if (!vkCreateSamplerFn) {
if (!vkCreateSampler) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateSampler";
return false;
}
vkCreateSemaphoreFn = reinterpret_cast<PFN_vkCreateSemaphore>(
vkCreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(
vkGetDeviceProcAddr(vk_device, "vkCreateSemaphore"));
if (!vkCreateSemaphoreFn) {
if (!vkCreateSemaphore) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateSemaphore";
return false;
}
vkCreateShaderModuleFn = reinterpret_cast<PFN_vkCreateShaderModule>(
vkCreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(
vkGetDeviceProcAddr(vk_device, "vkCreateShaderModule"));
if (!vkCreateShaderModuleFn) {
if (!vkCreateShaderModule) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateShaderModule";
return false;
}
vkDestroyBufferFn = reinterpret_cast<PFN_vkDestroyBuffer>(
vkDestroyBuffer = reinterpret_cast<PFN_vkDestroyBuffer>(
vkGetDeviceProcAddr(vk_device, "vkDestroyBuffer"));
if (!vkDestroyBufferFn) {
if (!vkDestroyBuffer) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyBuffer";
return false;
}
vkDestroyCommandPoolFn = reinterpret_cast<PFN_vkDestroyCommandPool>(
vkDestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(
vkGetDeviceProcAddr(vk_device, "vkDestroyCommandPool"));
if (!vkDestroyCommandPoolFn) {
if (!vkDestroyCommandPool) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyCommandPool";
return false;
}
vkDestroyDescriptorPoolFn = reinterpret_cast<PFN_vkDestroyDescriptorPool>(
vkDestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(
vkGetDeviceProcAddr(vk_device, "vkDestroyDescriptorPool"));
if (!vkDestroyDescriptorPoolFn) {
if (!vkDestroyDescriptorPool) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyDescriptorPool";
return false;
}
vkDestroyDescriptorSetLayoutFn =
vkDestroyDescriptorSetLayout =
reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(
vkGetDeviceProcAddr(vk_device, "vkDestroyDescriptorSetLayout"));
if (!vkDestroyDescriptorSetLayoutFn) {
if (!vkDestroyDescriptorSetLayout) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyDescriptorSetLayout";
return false;
}
vkDestroyDeviceFn = reinterpret_cast<PFN_vkDestroyDevice>(
vkDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(
vkGetDeviceProcAddr(vk_device, "vkDestroyDevice"));
if (!vkDestroyDeviceFn) {
if (!vkDestroyDevice) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyDevice";
return false;
}
vkDestroyFenceFn = reinterpret_cast<PFN_vkDestroyFence>(
vkDestroyFence = reinterpret_cast<PFN_vkDestroyFence>(
vkGetDeviceProcAddr(vk_device, "vkDestroyFence"));
if (!vkDestroyFenceFn) {
if (!vkDestroyFence) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyFence";
return false;
}
vkDestroyFramebufferFn = reinterpret_cast<PFN_vkDestroyFramebuffer>(
vkDestroyFramebuffer = reinterpret_cast<PFN_vkDestroyFramebuffer>(
vkGetDeviceProcAddr(vk_device, "vkDestroyFramebuffer"));
if (!vkDestroyFramebufferFn) {
if (!vkDestroyFramebuffer) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyFramebuffer";
return false;
}
vkDestroyImageFn = reinterpret_cast<PFN_vkDestroyImage>(
vkDestroyImage = reinterpret_cast<PFN_vkDestroyImage>(
vkGetDeviceProcAddr(vk_device, "vkDestroyImage"));
if (!vkDestroyImageFn) {
if (!vkDestroyImage) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyImage";
return false;
}
vkDestroyImageViewFn = reinterpret_cast<PFN_vkDestroyImageView>(
vkDestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(
vkGetDeviceProcAddr(vk_device, "vkDestroyImageView"));
if (!vkDestroyImageViewFn) {
if (!vkDestroyImageView) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyImageView";
return false;
}
vkDestroyRenderPassFn = reinterpret_cast<PFN_vkDestroyRenderPass>(
vkDestroyRenderPass = reinterpret_cast<PFN_vkDestroyRenderPass>(
vkGetDeviceProcAddr(vk_device, "vkDestroyRenderPass"));
if (!vkDestroyRenderPassFn) {
if (!vkDestroyRenderPass) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyRenderPass";
return false;
}
vkDestroySamplerFn = reinterpret_cast<PFN_vkDestroySampler>(
vkDestroySampler = reinterpret_cast<PFN_vkDestroySampler>(
vkGetDeviceProcAddr(vk_device, "vkDestroySampler"));
if (!vkDestroySamplerFn) {
if (!vkDestroySampler) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroySampler";
return false;
}
vkDestroySemaphoreFn = reinterpret_cast<PFN_vkDestroySemaphore>(
vkDestroySemaphore = reinterpret_cast<PFN_vkDestroySemaphore>(
vkGetDeviceProcAddr(vk_device, "vkDestroySemaphore"));
if (!vkDestroySemaphoreFn) {
if (!vkDestroySemaphore) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroySemaphore";
return false;
}
vkDestroyShaderModuleFn = reinterpret_cast<PFN_vkDestroyShaderModule>(
vkDestroyShaderModule = reinterpret_cast<PFN_vkDestroyShaderModule>(
vkGetDeviceProcAddr(vk_device, "vkDestroyShaderModule"));
if (!vkDestroyShaderModuleFn) {
if (!vkDestroyShaderModule) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyShaderModule";
return false;
}
vkDeviceWaitIdleFn = reinterpret_cast<PFN_vkDeviceWaitIdle>(
vkDeviceWaitIdle = reinterpret_cast<PFN_vkDeviceWaitIdle>(
vkGetDeviceProcAddr(vk_device, "vkDeviceWaitIdle"));
if (!vkDeviceWaitIdleFn) {
if (!vkDeviceWaitIdle) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDeviceWaitIdle";
return false;
}
vkFlushMappedMemoryRangesFn = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(
vkFlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(
vkGetDeviceProcAddr(vk_device, "vkFlushMappedMemoryRanges"));
if (!vkFlushMappedMemoryRangesFn) {
if (!vkFlushMappedMemoryRanges) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkFlushMappedMemoryRanges";
return false;
}
vkEndCommandBufferFn = reinterpret_cast<PFN_vkEndCommandBuffer>(
vkEndCommandBuffer = reinterpret_cast<PFN_vkEndCommandBuffer>(
vkGetDeviceProcAddr(vk_device, "vkEndCommandBuffer"));
if (!vkEndCommandBufferFn) {
if (!vkEndCommandBuffer) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkEndCommandBuffer";
return false;
}
vkFreeCommandBuffersFn = reinterpret_cast<PFN_vkFreeCommandBuffers>(
vkFreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(
vkGetDeviceProcAddr(vk_device, "vkFreeCommandBuffers"));
if (!vkFreeCommandBuffersFn) {
if (!vkFreeCommandBuffers) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkFreeCommandBuffers";
return false;
}
vkFreeDescriptorSetsFn = reinterpret_cast<PFN_vkFreeDescriptorSets>(
vkFreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(
vkGetDeviceProcAddr(vk_device, "vkFreeDescriptorSets"));
if (!vkFreeDescriptorSetsFn) {
if (!vkFreeDescriptorSets) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkFreeDescriptorSets";
return false;
}
vkFreeMemoryFn = reinterpret_cast<PFN_vkFreeMemory>(
vkFreeMemory = reinterpret_cast<PFN_vkFreeMemory>(
vkGetDeviceProcAddr(vk_device, "vkFreeMemory"));
if (!vkFreeMemoryFn) {
if (!vkFreeMemory) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkFreeMemory";
return false;
}
vkInvalidateMappedMemoryRangesFn =
vkInvalidateMappedMemoryRanges =
reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(
vkGetDeviceProcAddr(vk_device, "vkInvalidateMappedMemoryRanges"));
if (!vkInvalidateMappedMemoryRangesFn) {
if (!vkInvalidateMappedMemoryRanges) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkInvalidateMappedMemoryRanges";
return false;
}
vkGetBufferMemoryRequirementsFn =
vkGetBufferMemoryRequirements =
reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(
vkGetDeviceProcAddr(vk_device, "vkGetBufferMemoryRequirements"));
if (!vkGetBufferMemoryRequirementsFn) {
if (!vkGetBufferMemoryRequirements) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetBufferMemoryRequirements";
return false;
}
vkGetDeviceQueueFn = reinterpret_cast<PFN_vkGetDeviceQueue>(
vkGetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(
vkGetDeviceProcAddr(vk_device, "vkGetDeviceQueue"));
if (!vkGetDeviceQueueFn) {
if (!vkGetDeviceQueue) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetDeviceQueue";
return false;
}
vkGetFenceStatusFn = reinterpret_cast<PFN_vkGetFenceStatus>(
vkGetFenceStatus = reinterpret_cast<PFN_vkGetFenceStatus>(
vkGetDeviceProcAddr(vk_device, "vkGetFenceStatus"));
if (!vkGetFenceStatusFn) {
if (!vkGetFenceStatus) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetFenceStatus";
return false;
}
vkGetImageMemoryRequirementsFn =
vkGetImageMemoryRequirements =
reinterpret_cast<PFN_vkGetImageMemoryRequirements>(
vkGetDeviceProcAddr(vk_device, "vkGetImageMemoryRequirements"));
if (!vkGetImageMemoryRequirementsFn) {
if (!vkGetImageMemoryRequirements) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetImageMemoryRequirements";
return false;
}
vkMapMemoryFn = reinterpret_cast<PFN_vkMapMemory>(
vkMapMemory = reinterpret_cast<PFN_vkMapMemory>(
vkGetDeviceProcAddr(vk_device, "vkMapMemory"));
if (!vkMapMemoryFn) {
if (!vkMapMemory) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkMapMemory";
return false;
}
vkQueueSubmitFn = reinterpret_cast<PFN_vkQueueSubmit>(
vkQueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(
vkGetDeviceProcAddr(vk_device, "vkQueueSubmit"));
if (!vkQueueSubmitFn) {
if (!vkQueueSubmit) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkQueueSubmit";
return false;
}
vkQueueWaitIdleFn = reinterpret_cast<PFN_vkQueueWaitIdle>(
vkQueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(
vkGetDeviceProcAddr(vk_device, "vkQueueWaitIdle"));
if (!vkQueueWaitIdleFn) {
if (!vkQueueWaitIdle) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkQueueWaitIdle";
return false;
}
vkResetCommandBufferFn = reinterpret_cast<PFN_vkResetCommandBuffer>(
vkResetCommandBuffer = reinterpret_cast<PFN_vkResetCommandBuffer>(
vkGetDeviceProcAddr(vk_device, "vkResetCommandBuffer"));
if (!vkResetCommandBufferFn) {
if (!vkResetCommandBuffer) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkResetCommandBuffer";
return false;
}
vkResetFencesFn = reinterpret_cast<PFN_vkResetFences>(
vkResetFences = reinterpret_cast<PFN_vkResetFences>(
vkGetDeviceProcAddr(vk_device, "vkResetFences"));
if (!vkResetFencesFn) {
if (!vkResetFences) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkResetFences";
return false;
}
vkUnmapMemoryFn = reinterpret_cast<PFN_vkUnmapMemory>(
vkUnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(
vkGetDeviceProcAddr(vk_device, "vkUnmapMemory"));
if (!vkUnmapMemoryFn) {
if (!vkUnmapMemory) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkUnmapMemory";
return false;
}
vkUpdateDescriptorSetsFn = reinterpret_cast<PFN_vkUpdateDescriptorSets>(
vkUpdateDescriptorSets = reinterpret_cast<PFN_vkUpdateDescriptorSets>(
vkGetDeviceProcAddr(vk_device, "vkUpdateDescriptorSets"));
if (!vkUpdateDescriptorSetsFn) {
if (!vkUpdateDescriptorSets) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkUpdateDescriptorSets";
return false;
}
vkWaitForFencesFn = reinterpret_cast<PFN_vkWaitForFences>(
vkWaitForFences = reinterpret_cast<PFN_vkWaitForFences>(
vkGetDeviceProcAddr(vk_device, "vkWaitForFences"));
if (!vkWaitForFencesFn) {
if (!vkWaitForFences) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkWaitForFences";
return false;
}
if (api_version >= VK_API_VERSION_1_1) {
vkGetDeviceQueue2Fn = reinterpret_cast<PFN_vkGetDeviceQueue2>(
vkGetDeviceQueue2 = reinterpret_cast<PFN_vkGetDeviceQueue2>(
vkGetDeviceProcAddr(vk_device, "vkGetDeviceQueue2"));
if (!vkGetDeviceQueue2Fn) {
if (!vkGetDeviceQueue2) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetDeviceQueue2";
return false;
}
vkGetBufferMemoryRequirements2Fn =
vkGetBufferMemoryRequirements2 =
reinterpret_cast<PFN_vkGetBufferMemoryRequirements2>(
vkGetDeviceProcAddr(vk_device, "vkGetBufferMemoryRequirements2"));
if (!vkGetBufferMemoryRequirements2Fn) {
if (!vkGetBufferMemoryRequirements2) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetBufferMemoryRequirements2";
return false;
}
vkGetImageMemoryRequirements2Fn =
vkGetImageMemoryRequirements2 =
reinterpret_cast<PFN_vkGetImageMemoryRequirements2>(
vkGetDeviceProcAddr(vk_device, "vkGetImageMemoryRequirements2"));
if (!vkGetImageMemoryRequirements2Fn) {
if (!vkGetImageMemoryRequirements2) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetImageMemoryRequirements2";
return false;
......@@ -850,11 +850,11 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(
if (gfx::HasExtension(
enabled_extensions,
VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME)) {
vkGetAndroidHardwareBufferPropertiesANDROIDFn =
vkGetAndroidHardwareBufferPropertiesANDROID =
reinterpret_cast<PFN_vkGetAndroidHardwareBufferPropertiesANDROID>(
vkGetDeviceProcAddr(vk_device,
"vkGetAndroidHardwareBufferPropertiesANDROID"));
if (!vkGetAndroidHardwareBufferPropertiesANDROIDFn) {
if (!vkGetAndroidHardwareBufferPropertiesANDROID) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetAndroidHardwareBufferPropertiesANDROID";
return false;
......@@ -865,17 +865,17 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(
#if defined(OS_LINUX) || defined(OS_ANDROID)
if (gfx::HasExtension(enabled_extensions,
VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME)) {
vkGetSemaphoreFdKHRFn = reinterpret_cast<PFN_vkGetSemaphoreFdKHR>(
vkGetSemaphoreFdKHR = reinterpret_cast<PFN_vkGetSemaphoreFdKHR>(
vkGetDeviceProcAddr(vk_device, "vkGetSemaphoreFdKHR"));
if (!vkGetSemaphoreFdKHRFn) {
if (!vkGetSemaphoreFdKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetSemaphoreFdKHR";
return false;
}
vkImportSemaphoreFdKHRFn = reinterpret_cast<PFN_vkImportSemaphoreFdKHR>(
vkImportSemaphoreFdKHR = reinterpret_cast<PFN_vkImportSemaphoreFdKHR>(
vkGetDeviceProcAddr(vk_device, "vkImportSemaphoreFdKHR"));
if (!vkImportSemaphoreFdKHRFn) {
if (!vkImportSemaphoreFdKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkImportSemaphoreFdKHR";
return false;
......@@ -886,19 +886,19 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(
#if defined(OS_WIN)
if (gfx::HasExtension(enabled_extensions,
VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME)) {
vkGetSemaphoreWin32HandleKHRFn =
vkGetSemaphoreWin32HandleKHR =
reinterpret_cast<PFN_vkGetSemaphoreWin32HandleKHR>(
vkGetDeviceProcAddr(vk_device, "vkGetSemaphoreWin32HandleKHR"));
if (!vkGetSemaphoreWin32HandleKHRFn) {
if (!vkGetSemaphoreWin32HandleKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetSemaphoreWin32HandleKHR";
return false;
}
vkImportSemaphoreWin32HandleKHRFn =
vkImportSemaphoreWin32HandleKHR =
reinterpret_cast<PFN_vkImportSemaphoreWin32HandleKHR>(
vkGetDeviceProcAddr(vk_device, "vkImportSemaphoreWin32HandleKHR"));
if (!vkImportSemaphoreWin32HandleKHRFn) {
if (!vkImportSemaphoreWin32HandleKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkImportSemaphoreWin32HandleKHR";
return false;
......@@ -909,18 +909,18 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(
#if defined(OS_LINUX) || defined(OS_ANDROID)
if (gfx::HasExtension(enabled_extensions,
VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME)) {
vkGetMemoryFdKHRFn = reinterpret_cast<PFN_vkGetMemoryFdKHR>(
vkGetMemoryFdKHR = reinterpret_cast<PFN_vkGetMemoryFdKHR>(
vkGetDeviceProcAddr(vk_device, "vkGetMemoryFdKHR"));
if (!vkGetMemoryFdKHRFn) {
if (!vkGetMemoryFdKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetMemoryFdKHR";
return false;
}
vkGetMemoryFdPropertiesKHRFn =
vkGetMemoryFdPropertiesKHR =
reinterpret_cast<PFN_vkGetMemoryFdPropertiesKHR>(
vkGetDeviceProcAddr(vk_device, "vkGetMemoryFdPropertiesKHR"));
if (!vkGetMemoryFdPropertiesKHRFn) {
if (!vkGetMemoryFdPropertiesKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetMemoryFdPropertiesKHR";
return false;
......@@ -931,20 +931,19 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(
#if defined(OS_WIN)
if (gfx::HasExtension(enabled_extensions,
VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME)) {
vkGetMemoryWin32HandleKHRFn =
reinterpret_cast<PFN_vkGetMemoryWin32HandleKHR>(
vkGetDeviceProcAddr(vk_device, "vkGetMemoryWin32HandleKHR"));
if (!vkGetMemoryWin32HandleKHRFn) {
vkGetMemoryWin32HandleKHR = reinterpret_cast<PFN_vkGetMemoryWin32HandleKHR>(
vkGetDeviceProcAddr(vk_device, "vkGetMemoryWin32HandleKHR"));
if (!vkGetMemoryWin32HandleKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetMemoryWin32HandleKHR";
return false;
}
vkGetMemoryWin32HandlePropertiesKHRFn =
vkGetMemoryWin32HandlePropertiesKHR =
reinterpret_cast<PFN_vkGetMemoryWin32HandlePropertiesKHR>(
vkGetDeviceProcAddr(vk_device,
"vkGetMemoryWin32HandlePropertiesKHR"));
if (!vkGetMemoryWin32HandlePropertiesKHRFn) {
if (!vkGetMemoryWin32HandlePropertiesKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetMemoryWin32HandlePropertiesKHR";
return false;
......@@ -955,21 +954,21 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(
#if defined(OS_FUCHSIA)
if (gfx::HasExtension(enabled_extensions,
VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME)) {
vkImportSemaphoreZirconHandleFUCHSIAFn =
vkImportSemaphoreZirconHandleFUCHSIA =
reinterpret_cast<PFN_vkImportSemaphoreZirconHandleFUCHSIA>(
vkGetDeviceProcAddr(vk_device,
"vkImportSemaphoreZirconHandleFUCHSIA"));
if (!vkImportSemaphoreZirconHandleFUCHSIAFn) {
if (!vkImportSemaphoreZirconHandleFUCHSIA) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkImportSemaphoreZirconHandleFUCHSIA";
return false;
}
vkGetSemaphoreZirconHandleFUCHSIAFn =
vkGetSemaphoreZirconHandleFUCHSIA =
reinterpret_cast<PFN_vkGetSemaphoreZirconHandleFUCHSIA>(
vkGetDeviceProcAddr(vk_device,
"vkGetSemaphoreZirconHandleFUCHSIA"));
if (!vkGetSemaphoreZirconHandleFUCHSIAFn) {
if (!vkGetSemaphoreZirconHandleFUCHSIA) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetSemaphoreZirconHandleFUCHSIA";
return false;
......@@ -980,10 +979,10 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(
#if defined(OS_FUCHSIA)
if (gfx::HasExtension(enabled_extensions,
VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME)) {
vkGetMemoryZirconHandleFUCHSIAFn =
vkGetMemoryZirconHandleFUCHSIA =
reinterpret_cast<PFN_vkGetMemoryZirconHandleFUCHSIA>(
vkGetDeviceProcAddr(vk_device, "vkGetMemoryZirconHandleFUCHSIA"));
if (!vkGetMemoryZirconHandleFUCHSIAFn) {
if (!vkGetMemoryZirconHandleFUCHSIA) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetMemoryZirconHandleFUCHSIA";
return false;
......@@ -994,39 +993,39 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(
#if defined(OS_FUCHSIA)
if (gfx::HasExtension(enabled_extensions,
VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME)) {
vkCreateBufferCollectionFUCHSIAFn =
vkCreateBufferCollectionFUCHSIA =
reinterpret_cast<PFN_vkCreateBufferCollectionFUCHSIA>(
vkGetDeviceProcAddr(vk_device, "vkCreateBufferCollectionFUCHSIA"));
if (!vkCreateBufferCollectionFUCHSIAFn) {
if (!vkCreateBufferCollectionFUCHSIA) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateBufferCollectionFUCHSIA";
return false;
}
vkSetBufferCollectionConstraintsFUCHSIAFn =
vkSetBufferCollectionConstraintsFUCHSIA =
reinterpret_cast<PFN_vkSetBufferCollectionConstraintsFUCHSIA>(
vkGetDeviceProcAddr(vk_device,
"vkSetBufferCollectionConstraintsFUCHSIA"));
if (!vkSetBufferCollectionConstraintsFUCHSIAFn) {
if (!vkSetBufferCollectionConstraintsFUCHSIA) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkSetBufferCollectionConstraintsFUCHSIA";
return false;
}
vkGetBufferCollectionPropertiesFUCHSIAFn =
vkGetBufferCollectionPropertiesFUCHSIA =
reinterpret_cast<PFN_vkGetBufferCollectionPropertiesFUCHSIA>(
vkGetDeviceProcAddr(vk_device,
"vkGetBufferCollectionPropertiesFUCHSIA"));
if (!vkGetBufferCollectionPropertiesFUCHSIAFn) {
if (!vkGetBufferCollectionPropertiesFUCHSIA) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetBufferCollectionPropertiesFUCHSIA";
return false;
}
vkDestroyBufferCollectionFUCHSIAFn =
vkDestroyBufferCollectionFUCHSIA =
reinterpret_cast<PFN_vkDestroyBufferCollectionFUCHSIA>(
vkGetDeviceProcAddr(vk_device, "vkDestroyBufferCollectionFUCHSIA"));
if (!vkDestroyBufferCollectionFUCHSIAFn) {
if (!vkDestroyBufferCollectionFUCHSIA) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroyBufferCollectionFUCHSIA";
return false;
......@@ -1035,41 +1034,41 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(
#endif // defined(OS_FUCHSIA)
if (gfx::HasExtension(enabled_extensions, VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
vkAcquireNextImageKHRFn = reinterpret_cast<PFN_vkAcquireNextImageKHR>(
vkAcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(
vkGetDeviceProcAddr(vk_device, "vkAcquireNextImageKHR"));
if (!vkAcquireNextImageKHRFn) {
if (!vkAcquireNextImageKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkAcquireNextImageKHR";
return false;
}
vkCreateSwapchainKHRFn = reinterpret_cast<PFN_vkCreateSwapchainKHR>(
vkCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(
vkGetDeviceProcAddr(vk_device, "vkCreateSwapchainKHR"));
if (!vkCreateSwapchainKHRFn) {
if (!vkCreateSwapchainKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkCreateSwapchainKHR";
return false;
}
vkDestroySwapchainKHRFn = reinterpret_cast<PFN_vkDestroySwapchainKHR>(
vkDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(
vkGetDeviceProcAddr(vk_device, "vkDestroySwapchainKHR"));
if (!vkDestroySwapchainKHRFn) {
if (!vkDestroySwapchainKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkDestroySwapchainKHR";
return false;
}
vkGetSwapchainImagesKHRFn = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(
vkGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(
vkGetDeviceProcAddr(vk_device, "vkGetSwapchainImagesKHR"));
if (!vkGetSwapchainImagesKHRFn) {
if (!vkGetSwapchainImagesKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkGetSwapchainImagesKHR";
return false;
}
vkQueuePresentKHRFn = reinterpret_cast<PFN_vkQueuePresentKHR>(
vkQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(
vkGetDeviceProcAddr(vk_device, "vkQueuePresentKHR"));
if (!vkQueuePresentKHRFn) {
if (!vkQueuePresentKHR) {
DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
<< "vkQueuePresentKHR";
return false;
......
gpu/vulkan/vulkan_function_pointers.h
View file @ 8cff2cd0
......@@ -72,10 +72,10 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
public:
using Fn = R(VKAPI_PTR*)(Args...);
explicit operator bool() { return !!fn_; }
explicit operator bool() const { return !!fn_; }
NO_SANITIZE("cfi-icall")
R operator()(Args... args) { return fn_(args...); }
R operator()(Args... args) const { return fn_(args...); }
Fn get() const { return fn_; }
......@@ -91,201 +91,197 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
};
// Unassociated functions
VulkanFunction<PFN_vkEnumerateInstanceVersion> vkEnumerateInstanceVersionFn;
VulkanFunction<PFN_vkGetInstanceProcAddr> vkGetInstanceProcAddrFn;
VulkanFunction<PFN_vkGetInstanceProcAddr> vkGetInstanceProcAddr;
VulkanFunction<PFN_vkCreateInstance> vkCreateInstanceFn;
VulkanFunction<PFN_vkEnumerateInstanceVersion> vkEnumerateInstanceVersion;
VulkanFunction<PFN_vkCreateInstance> vkCreateInstance;
VulkanFunction<PFN_vkEnumerateInstanceExtensionProperties>
vkEnumerateInstanceExtensionPropertiesFn;
vkEnumerateInstanceExtensionProperties;
VulkanFunction<PFN_vkEnumerateInstanceLayerProperties>
vkEnumerateInstanceLayerPropertiesFn;
vkEnumerateInstanceLayerProperties;
// Instance functions
VulkanFunction<PFN_vkCreateDevice> vkCreateDeviceFn;
VulkanFunction<PFN_vkDestroyInstance> vkDestroyInstanceFn;
VulkanFunction<PFN_vkCreateDevice> vkCreateDevice;
VulkanFunction<PFN_vkDestroyInstance> vkDestroyInstance;
VulkanFunction<PFN_vkEnumerateDeviceExtensionProperties>
vkEnumerateDeviceExtensionPropertiesFn;
vkEnumerateDeviceExtensionProperties;
VulkanFunction<PFN_vkEnumerateDeviceLayerProperties>
vkEnumerateDeviceLayerPropertiesFn;
VulkanFunction<PFN_vkEnumeratePhysicalDevices> vkEnumeratePhysicalDevicesFn;
VulkanFunction<PFN_vkGetDeviceProcAddr> vkGetDeviceProcAddrFn;
VulkanFunction<PFN_vkGetPhysicalDeviceFeatures> vkGetPhysicalDeviceFeaturesFn;
vkEnumerateDeviceLayerProperties;
VulkanFunction<PFN_vkEnumeratePhysicalDevices> vkEnumeratePhysicalDevices;
VulkanFunction<PFN_vkGetDeviceProcAddr> vkGetDeviceProcAddr;
VulkanFunction<PFN_vkGetPhysicalDeviceFeatures> vkGetPhysicalDeviceFeatures;
VulkanFunction<PFN_vkGetPhysicalDeviceFormatProperties>
vkGetPhysicalDeviceFormatPropertiesFn;
vkGetPhysicalDeviceFormatProperties;
VulkanFunction<PFN_vkGetPhysicalDeviceMemoryProperties>
vkGetPhysicalDeviceMemoryPropertiesFn;
vkGetPhysicalDeviceMemoryProperties;
VulkanFunction<PFN_vkGetPhysicalDeviceProperties>
vkGetPhysicalDevicePropertiesFn;
vkGetPhysicalDeviceProperties;
VulkanFunction<PFN_vkGetPhysicalDeviceQueueFamilyProperties>
vkGetPhysicalDeviceQueueFamilyPropertiesFn;
vkGetPhysicalDeviceQueueFamilyProperties;
#if DCHECK_IS_ON()
VulkanFunction<PFN_vkCreateDebugReportCallbackEXT>
vkCreateDebugReportCallbackEXTFn;
vkCreateDebugReportCallbackEXT;
VulkanFunction<PFN_vkDestroyDebugReportCallbackEXT>
vkDestroyDebugReportCallbackEXTFn;
vkDestroyDebugReportCallbackEXT;
#endif // DCHECK_IS_ON()
VulkanFunction<PFN_vkDestroySurfaceKHR> vkDestroySurfaceKHRFn;
VulkanFunction<PFN_vkDestroySurfaceKHR> vkDestroySurfaceKHR;
VulkanFunction<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>
vkGetPhysicalDeviceSurfaceCapabilitiesKHRFn;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
VulkanFunction<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>
vkGetPhysicalDeviceSurfaceFormatsKHRFn;
vkGetPhysicalDeviceSurfaceFormatsKHR;
VulkanFunction<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>
vkGetPhysicalDeviceSurfaceSupportKHRFn;
vkGetPhysicalDeviceSurfaceSupportKHR;
#if defined(USE_VULKAN_XLIB)
VulkanFunction<PFN_vkCreateXlibSurfaceKHR> vkCreateXlibSurfaceKHRFn;
VulkanFunction<PFN_vkCreateXlibSurfaceKHR> vkCreateXlibSurfaceKHR;
VulkanFunction<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>
vkGetPhysicalDeviceXlibPresentationSupportKHRFn;
vkGetPhysicalDeviceXlibPresentationSupportKHR;
#endif // defined(USE_VULKAN_XLIB)
#if defined(OS_WIN)
VulkanFunction<PFN_vkCreateWin32SurfaceKHR> vkCreateWin32SurfaceKHRFn;
VulkanFunction<PFN_vkCreateWin32SurfaceKHR> vkCreateWin32SurfaceKHR;
VulkanFunction<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>
vkGetPhysicalDeviceWin32PresentationSupportKHRFn;
vkGetPhysicalDeviceWin32PresentationSupportKHR;
#endif // defined(OS_WIN)
#if defined(OS_ANDROID)
VulkanFunction<PFN_vkCreateAndroidSurfaceKHR> vkCreateAndroidSurfaceKHRFn;
VulkanFunction<PFN_vkCreateAndroidSurfaceKHR> vkCreateAndroidSurfaceKHR;
#endif // defined(OS_ANDROID)
#if defined(OS_FUCHSIA)
VulkanFunction<PFN_vkCreateImagePipeSurfaceFUCHSIA>
vkCreateImagePipeSurfaceFUCHSIAFn;
vkCreateImagePipeSurfaceFUCHSIA;
#endif // defined(OS_FUCHSIA)
VulkanFunction<PFN_vkGetPhysicalDeviceImageFormatProperties2>
vkGetPhysicalDeviceImageFormatProperties2Fn;
vkGetPhysicalDeviceImageFormatProperties2;
VulkanFunction<PFN_vkGetPhysicalDeviceFeatures2>
vkGetPhysicalDeviceFeatures2Fn;
VulkanFunction<PFN_vkGetPhysicalDeviceFeatures2> vkGetPhysicalDeviceFeatures2;
// Device functions
VulkanFunction<PFN_vkAllocateCommandBuffers> vkAllocateCommandBuffersFn;
VulkanFunction<PFN_vkAllocateDescriptorSets> vkAllocateDescriptorSetsFn;
VulkanFunction<PFN_vkAllocateMemory> vkAllocateMemoryFn;
VulkanFunction<PFN_vkBeginCommandBuffer> vkBeginCommandBufferFn;
VulkanFunction<PFN_vkBindBufferMemory> vkBindBufferMemoryFn;
VulkanFunction<PFN_vkBindImageMemory> vkBindImageMemoryFn;
VulkanFunction<PFN_vkCmdBeginRenderPass> vkCmdBeginRenderPassFn;
VulkanFunction<PFN_vkCmdCopyBuffer> vkCmdCopyBufferFn;
VulkanFunction<PFN_vkCmdCopyBufferToImage> vkCmdCopyBufferToImageFn;
VulkanFunction<PFN_vkCmdEndRenderPass> vkCmdEndRenderPassFn;
VulkanFunction<PFN_vkCmdExecuteCommands> vkCmdExecuteCommandsFn;
VulkanFunction<PFN_vkCmdNextSubpass> vkCmdNextSubpassFn;
VulkanFunction<PFN_vkCmdPipelineBarrier> vkCmdPipelineBarrierFn;
VulkanFunction<PFN_vkCreateBuffer> vkCreateBufferFn;
VulkanFunction<PFN_vkCreateCommandPool> vkCreateCommandPoolFn;
VulkanFunction<PFN_vkCreateDescriptorPool> vkCreateDescriptorPoolFn;
VulkanFunction<PFN_vkCreateDescriptorSetLayout> vkCreateDescriptorSetLayoutFn;
VulkanFunction<PFN_vkCreateFence> vkCreateFenceFn;
VulkanFunction<PFN_vkCreateFramebuffer> vkCreateFramebufferFn;
VulkanFunction<PFN_vkCreateImage> vkCreateImageFn;
VulkanFunction<PFN_vkCreateImageView> vkCreateImageViewFn;
VulkanFunction<PFN_vkCreateRenderPass> vkCreateRenderPassFn;
VulkanFunction<PFN_vkCreateSampler> vkCreateSamplerFn;
VulkanFunction<PFN_vkCreateSemaphore> vkCreateSemaphoreFn;
VulkanFunction<PFN_vkCreateShaderModule> vkCreateShaderModuleFn;
VulkanFunction<PFN_vkDestroyBuffer> vkDestroyBufferFn;
VulkanFunction<PFN_vkDestroyCommandPool> vkDestroyCommandPoolFn;
VulkanFunction<PFN_vkDestroyDescriptorPool> vkDestroyDescriptorPoolFn;
VulkanFunction<PFN_vkDestroyDescriptorSetLayout>
vkDestroyDescriptorSetLayoutFn;
VulkanFunction<PFN_vkDestroyDevice> vkDestroyDeviceFn;
VulkanFunction<PFN_vkDestroyFence> vkDestroyFenceFn;
VulkanFunction<PFN_vkDestroyFramebuffer> vkDestroyFramebufferFn;
VulkanFunction<PFN_vkDestroyImage> vkDestroyImageFn;
VulkanFunction<PFN_vkDestroyImageView> vkDestroyImageViewFn;
VulkanFunction<PFN_vkDestroyRenderPass> vkDestroyRenderPassFn;
VulkanFunction<PFN_vkDestroySampler> vkDestroySamplerFn;
VulkanFunction<PFN_vkDestroySemaphore> vkDestroySemaphoreFn;
VulkanFunction<PFN_vkDestroyShaderModule> vkDestroyShaderModuleFn;
VulkanFunction<PFN_vkDeviceWaitIdle> vkDeviceWaitIdleFn;
VulkanFunction<PFN_vkFlushMappedMemoryRanges> vkFlushMappedMemoryRangesFn;
VulkanFunction<PFN_vkEndCommandBuffer> vkEndCommandBufferFn;
VulkanFunction<PFN_vkFreeCommandBuffers> vkFreeCommandBuffersFn;
VulkanFunction<PFN_vkFreeDescriptorSets> vkFreeDescriptorSetsFn;
VulkanFunction<PFN_vkFreeMemory> vkFreeMemoryFn;
VulkanFunction<PFN_vkAllocateCommandBuffers> vkAllocateCommandBuffers;
VulkanFunction<PFN_vkAllocateDescriptorSets> vkAllocateDescriptorSets;
VulkanFunction<PFN_vkAllocateMemory> vkAllocateMemory;
VulkanFunction<PFN_vkBeginCommandBuffer> vkBeginCommandBuffer;
VulkanFunction<PFN_vkBindBufferMemory> vkBindBufferMemory;
VulkanFunction<PFN_vkBindImageMemory> vkBindImageMemory;
VulkanFunction<PFN_vkCmdBeginRenderPass> vkCmdBeginRenderPass;
VulkanFunction<PFN_vkCmdCopyBuffer> vkCmdCopyBuffer;
VulkanFunction<PFN_vkCmdCopyBufferToImage> vkCmdCopyBufferToImage;
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_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>
vkInvalidateMappedMemoryRangesFn;
vkInvalidateMappedMemoryRanges;
VulkanFunction<PFN_vkGetBufferMemoryRequirements>
vkGetBufferMemoryRequirementsFn;
VulkanFunction<PFN_vkGetDeviceQueue> vkGetDeviceQueueFn;
VulkanFunction<PFN_vkGetFenceStatus> vkGetFenceStatusFn;
VulkanFunction<PFN_vkGetImageMemoryRequirements>
vkGetImageMemoryRequirementsFn;
VulkanFunction<PFN_vkMapMemory> vkMapMemoryFn;
VulkanFunction<PFN_vkQueueSubmit> vkQueueSubmitFn;
VulkanFunction<PFN_vkQueueWaitIdle> vkQueueWaitIdleFn;
VulkanFunction<PFN_vkResetCommandBuffer> vkResetCommandBufferFn;
VulkanFunction<PFN_vkResetFences> vkResetFencesFn;
VulkanFunction<PFN_vkUnmapMemory> vkUnmapMemoryFn;
VulkanFunction<PFN_vkUpdateDescriptorSets> vkUpdateDescriptorSetsFn;
VulkanFunction<PFN_vkWaitForFences> vkWaitForFencesFn;
VulkanFunction<PFN_vkGetDeviceQueue2> vkGetDeviceQueue2Fn;
vkGetBufferMemoryRequirements;
VulkanFunction<PFN_vkGetDeviceQueue> vkGetDeviceQueue;
VulkanFunction<PFN_vkGetFenceStatus> vkGetFenceStatus;
VulkanFunction<PFN_vkGetImageMemoryRequirements> vkGetImageMemoryRequirements;
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;
VulkanFunction<PFN_vkGetDeviceQueue2> vkGetDeviceQueue2;
VulkanFunction<PFN_vkGetBufferMemoryRequirements2>
vkGetBufferMemoryRequirements2Fn;
vkGetBufferMemoryRequirements2;
VulkanFunction<PFN_vkGetImageMemoryRequirements2>
vkGetImageMemoryRequirements2Fn;
vkGetImageMemoryRequirements2;
#if defined(OS_ANDROID)
VulkanFunction<PFN_vkGetAndroidHardwareBufferPropertiesANDROID>
vkGetAndroidHardwareBufferPropertiesANDROIDFn;
vkGetAndroidHardwareBufferPropertiesANDROID;
#endif // defined(OS_ANDROID)
#if defined(OS_LINUX) || defined(OS_ANDROID)
VulkanFunction<PFN_vkGetSemaphoreFdKHR> vkGetSemaphoreFdKHRFn;
VulkanFunction<PFN_vkImportSemaphoreFdKHR> vkImportSemaphoreFdKHRFn;
VulkanFunction<PFN_vkGetSemaphoreFdKHR> vkGetSemaphoreFdKHR;
VulkanFunction<PFN_vkImportSemaphoreFdKHR> vkImportSemaphoreFdKHR;
#endif // defined(OS_LINUX) || defined(OS_ANDROID)
#if defined(OS_WIN)
VulkanFunction<PFN_vkGetSemaphoreWin32HandleKHR>
vkGetSemaphoreWin32HandleKHRFn;
VulkanFunction<PFN_vkGetSemaphoreWin32HandleKHR> vkGetSemaphoreWin32HandleKHR;
VulkanFunction<PFN_vkImportSemaphoreWin32HandleKHR>
vkImportSemaphoreWin32HandleKHRFn;
vkImportSemaphoreWin32HandleKHR;
#endif // defined(OS_WIN)
#if defined(OS_LINUX) || defined(OS_ANDROID)
VulkanFunction<PFN_vkGetMemoryFdKHR> vkGetMemoryFdKHRFn;
VulkanFunction<PFN_vkGetMemoryFdPropertiesKHR> vkGetMemoryFdPropertiesKHRFn;
VulkanFunction<PFN_vkGetMemoryFdKHR> vkGetMemoryFdKHR;
VulkanFunction<PFN_vkGetMemoryFdPropertiesKHR> vkGetMemoryFdPropertiesKHR;
#endif // defined(OS_LINUX) || defined(OS_ANDROID)
#if defined(OS_WIN)
VulkanFunction<PFN_vkGetMemoryWin32HandleKHR> vkGetMemoryWin32HandleKHRFn;
VulkanFunction<PFN_vkGetMemoryWin32HandleKHR> vkGetMemoryWin32HandleKHR;
VulkanFunction<PFN_vkGetMemoryWin32HandlePropertiesKHR>
vkGetMemoryWin32HandlePropertiesKHRFn;
vkGetMemoryWin32HandlePropertiesKHR;
#endif // defined(OS_WIN)
#if defined(OS_FUCHSIA)
VulkanFunction<PFN_vkImportSemaphoreZirconHandleFUCHSIA>
vkImportSemaphoreZirconHandleFUCHSIAFn;
vkImportSemaphoreZirconHandleFUCHSIA;
VulkanFunction<PFN_vkGetSemaphoreZirconHandleFUCHSIA>
vkGetSemaphoreZirconHandleFUCHSIAFn;
vkGetSemaphoreZirconHandleFUCHSIA;
#endif // defined(OS_FUCHSIA)
#if defined(OS_FUCHSIA)
VulkanFunction<PFN_vkGetMemoryZirconHandleFUCHSIA>
vkGetMemoryZirconHandleFUCHSIAFn;
vkGetMemoryZirconHandleFUCHSIA;
#endif // defined(OS_FUCHSIA)
#if defined(OS_FUCHSIA)
VulkanFunction<PFN_vkCreateBufferCollectionFUCHSIA>
vkCreateBufferCollectionFUCHSIAFn;
vkCreateBufferCollectionFUCHSIA;
VulkanFunction<PFN_vkSetBufferCollectionConstraintsFUCHSIA>
vkSetBufferCollectionConstraintsFUCHSIAFn;
vkSetBufferCollectionConstraintsFUCHSIA;
VulkanFunction<PFN_vkGetBufferCollectionPropertiesFUCHSIA>
vkGetBufferCollectionPropertiesFUCHSIAFn;
vkGetBufferCollectionPropertiesFUCHSIA;
VulkanFunction<PFN_vkDestroyBufferCollectionFUCHSIA>
vkDestroyBufferCollectionFUCHSIAFn;
vkDestroyBufferCollectionFUCHSIA;
#endif // defined(OS_FUCHSIA)
VulkanFunction<PFN_vkAcquireNextImageKHR> vkAcquireNextImageKHRFn;
VulkanFunction<PFN_vkCreateSwapchainKHR> vkCreateSwapchainKHRFn;
VulkanFunction<PFN_vkDestroySwapchainKHR> vkDestroySwapchainKHRFn;
VulkanFunction<PFN_vkGetSwapchainImagesKHR> vkGetSwapchainImagesKHRFn;
VulkanFunction<PFN_vkQueuePresentKHR> vkQueuePresentKHRFn;
VulkanFunction<PFN_vkAcquireNextImageKHR> vkAcquireNextImageKHR;
VulkanFunction<PFN_vkCreateSwapchainKHR> vkCreateSwapchainKHR;
VulkanFunction<PFN_vkDestroySwapchainKHR> vkDestroySwapchainKHR;
VulkanFunction<PFN_vkGetSwapchainImagesKHR> vkGetSwapchainImagesKHR;
VulkanFunction<PFN_vkQueuePresentKHR> vkQueuePresentKHR;
};
} // namespace gpu
......@@ -293,18 +289,18 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
// Unassociated functions
ALWAYS_INLINE PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance,
const char* pName) {
return gpu::GetVulkanFunctionPointers()->vkGetInstanceProcAddrFn(instance,
pName);
return gpu::GetVulkanFunctionPointers()->vkGetInstanceProcAddr(instance,
pName);
}
ALWAYS_INLINE VkResult vkEnumerateInstanceVersion(uint32_t* pApiVersion) {
return gpu::GetVulkanFunctionPointers()->vkEnumerateInstanceVersionFn(
return gpu::GetVulkanFunctionPointers()->vkEnumerateInstanceVersion(
pApiVersion);
}
ALWAYS_INLINE VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance) {
return gpu::GetVulkanFunctionPointers()->vkCreateInstanceFn(
return gpu::GetVulkanFunctionPointers()->vkCreateInstance(
pCreateInfo, pAllocator, pInstance);
}
ALWAYS_INLINE VkResult
......@@ -312,13 +308,13 @@ vkEnumerateInstanceExtensionProperties(const char* pLayerName,
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties) {
return gpu::GetVulkanFunctionPointers()
->vkEnumerateInstanceExtensionPropertiesFn(pLayerName, pPropertyCount,
pProperties);
->vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount,
pProperties);
}
ALWAYS_INLINE VkResult
vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
VkLayerProperties* pProperties) {
return gpu::GetVulkanFunctionPointers()->vkEnumerateInstanceLayerPropertiesFn(
return gpu::GetVulkanFunctionPointers()->vkEnumerateInstanceLayerProperties(
pPropertyCount, pProperties);
}
......@@ -327,66 +323,63 @@ ALWAYS_INLINE VkResult vkCreateDevice(VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDevice* pDevice) {
return gpu::GetVulkanFunctionPointers()->vkCreateDeviceFn(
return gpu::GetVulkanFunctionPointers()->vkCreateDevice(
physicalDevice, pCreateInfo, pAllocator, pDevice);
}
ALWAYS_INLINE void vkDestroyInstance(VkInstance instance,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyInstanceFn(instance,
pAllocator);
return gpu::GetVulkanFunctionPointers()->vkDestroyInstance(instance,
pAllocator);
}
ALWAYS_INLINE VkResult
vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
const char* pLayerName,
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties) {
return gpu::GetVulkanFunctionPointers()
->vkEnumerateDeviceExtensionPropertiesFn(physicalDevice, pLayerName,
pPropertyCount, pProperties);
return gpu::GetVulkanFunctionPointers()->vkEnumerateDeviceExtensionProperties(
physicalDevice, pLayerName, pPropertyCount, pProperties);
}
ALWAYS_INLINE VkResult
vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
uint32_t* pPropertyCount,
VkLayerProperties* pProperties) {
return gpu::GetVulkanFunctionPointers()->vkEnumerateDeviceLayerPropertiesFn(
return gpu::GetVulkanFunctionPointers()->vkEnumerateDeviceLayerProperties(
physicalDevice, pPropertyCount, pProperties);
}
ALWAYS_INLINE VkResult
vkEnumeratePhysicalDevices(VkInstance instance,
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices) {
return gpu::GetVulkanFunctionPointers()->vkEnumeratePhysicalDevicesFn(
return gpu::GetVulkanFunctionPointers()->vkEnumeratePhysicalDevices(
instance, pPhysicalDeviceCount, pPhysicalDevices);
}
ALWAYS_INLINE PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device,
const char* pName) {
return gpu::GetVulkanFunctionPointers()->vkGetDeviceProcAddrFn(device, pName);
return gpu::GetVulkanFunctionPointers()->vkGetDeviceProcAddr(device, pName);
}
ALWAYS_INLINE void vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures) {
return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFeaturesFn(
return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFeatures(
physicalDevice, pFeatures);
}
ALWAYS_INLINE void vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatProperties) {
return gpu::GetVulkanFunctionPointers()
->vkGetPhysicalDeviceFormatPropertiesFn(physicalDevice, format,
pFormatProperties);
return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFormatProperties(
physicalDevice, format, pFormatProperties);
}
ALWAYS_INLINE void vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
return gpu::GetVulkanFunctionPointers()
->vkGetPhysicalDeviceMemoryPropertiesFn(physicalDevice,
pMemoryProperties);
return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceMemoryProperties(
physicalDevice, pMemoryProperties);
}
ALWAYS_INLINE void vkGetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties) {
return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDevicePropertiesFn(
return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceProperties(
physicalDevice, pProperties);
}
ALWAYS_INLINE void vkGetPhysicalDeviceQueueFamilyProperties(
......@@ -394,7 +387,7 @@ ALWAYS_INLINE void vkGetPhysicalDeviceQueueFamilyProperties(
uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties* pQueueFamilyProperties) {
return gpu::GetVulkanFunctionPointers()
->vkGetPhysicalDeviceQueueFamilyPropertiesFn(
->vkGetPhysicalDeviceQueueFamilyProperties(
physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
......@@ -404,14 +397,14 @@ ALWAYS_INLINE VkResult vkCreateDebugReportCallbackEXT(
const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDebugReportCallbackEXT* pCallback) {
return gpu::GetVulkanFunctionPointers()->vkCreateDebugReportCallbackEXTFn(
return gpu::GetVulkanFunctionPointers()->vkCreateDebugReportCallbackEXT(
instance, pCreateInfo, pAllocator, pCallback);
}
ALWAYS_INLINE void vkDestroyDebugReportCallbackEXT(
VkInstance instance,
VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyDebugReportCallbackEXTFn(
return gpu::GetVulkanFunctionPointers()->vkDestroyDebugReportCallbackEXT(
instance, callback, pAllocator);
}
#endif // DCHECK_IS_ON()
......@@ -420,7 +413,7 @@ ALWAYS_INLINE void vkDestroySurfaceKHR(
VkInstance instance,
VkSurfaceKHR surface,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroySurfaceKHRFn(
return gpu::GetVulkanFunctionPointers()->vkDestroySurfaceKHR(
instance, surface, pAllocator);
}
ALWAYS_INLINE VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
......@@ -428,26 +421,24 @@ ALWAYS_INLINE VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
return gpu::GetVulkanFunctionPointers()
->vkGetPhysicalDeviceSurfaceCapabilitiesKHRFn(physicalDevice, surface,
pSurfaceCapabilities);
->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface,
pSurfaceCapabilities);
}
ALWAYS_INLINE VkResult
vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface,
uint32_t* pSurfaceFormatCount,
VkSurfaceFormatKHR* pSurfaceFormats) {
return gpu::GetVulkanFunctionPointers()
->vkGetPhysicalDeviceSurfaceFormatsKHRFn(
physicalDevice, surface, pSurfaceFormatCount, 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()
->vkGetPhysicalDeviceSurfaceSupportKHRFn(physicalDevice, queueFamilyIndex,
surface, pSupported);
return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceSurfaceSupportKHR(
physicalDevice, queueFamilyIndex, surface, pSupported);
}
#if defined(USE_VULKAN_XLIB)
......@@ -456,7 +447,7 @@ vkCreateXlibSurfaceKHR(VkInstance instance,
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
return gpu::GetVulkanFunctionPointers()->vkCreateXlibSurfaceKHRFn(
return gpu::GetVulkanFunctionPointers()->vkCreateXlibSurfaceKHR(
instance, pCreateInfo, pAllocator, pSurface);
}
ALWAYS_INLINE VkBool32
......@@ -465,7 +456,7 @@ vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
Display* dpy,
VisualID visualID) {
return gpu::GetVulkanFunctionPointers()
->vkGetPhysicalDeviceXlibPresentationSupportKHRFn(
->vkGetPhysicalDeviceXlibPresentationSupportKHR(
physicalDevice, queueFamilyIndex, dpy, visualID);
}
#endif // defined(USE_VULKAN_XLIB)
......@@ -476,15 +467,15 @@ vkCreateWin32SurfaceKHR(VkInstance instance,
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
return gpu::GetVulkanFunctionPointers()->vkCreateWin32SurfaceKHRFn(
return gpu::GetVulkanFunctionPointers()->vkCreateWin32SurfaceKHR(
instance, pCreateInfo, pAllocator, pSurface);
}
ALWAYS_INLINE VkBool32
vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex) {
return gpu::GetVulkanFunctionPointers()
->vkGetPhysicalDeviceWin32PresentationSupportKHRFn(physicalDevice,
queueFamilyIndex);
->vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice,
queueFamilyIndex);
}
#endif // defined(OS_WIN)
......@@ -494,7 +485,7 @@ vkCreateAndroidSurfaceKHR(VkInstance instance,
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
return gpu::GetVulkanFunctionPointers()->vkCreateAndroidSurfaceKHRFn(
return gpu::GetVulkanFunctionPointers()->vkCreateAndroidSurfaceKHR(
instance, pCreateInfo, pAllocator, pSurface);
}
#endif // defined(OS_ANDROID)
......@@ -505,7 +496,7 @@ ALWAYS_INLINE VkResult vkCreateImagePipeSurfaceFUCHSIA(
const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface) {
return gpu::GetVulkanFunctionPointers()->vkCreateImagePipeSurfaceFUCHSIAFn(
return gpu::GetVulkanFunctionPointers()->vkCreateImagePipeSurfaceFUCHSIA(
instance, pCreateInfo, pAllocator, pSurface);
}
#endif // defined(OS_FUCHSIA)
......@@ -515,14 +506,14 @@ ALWAYS_INLINE VkResult vkGetPhysicalDeviceImageFormatProperties2(
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
VkImageFormatProperties2* pImageFormatProperties) {
return gpu::GetVulkanFunctionPointers()
->vkGetPhysicalDeviceImageFormatProperties2Fn(
->vkGetPhysicalDeviceImageFormatProperties2(
physicalDevice, pImageFormatInfo, pImageFormatProperties);
}
ALWAYS_INLINE void vkGetPhysicalDeviceFeatures2(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures2* pFeatures) {
return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFeatures2Fn(
return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFeatures2(
physicalDevice, pFeatures);
}
......@@ -531,14 +522,14 @@ ALWAYS_INLINE VkResult
vkAllocateCommandBuffers(VkDevice device,
const VkCommandBufferAllocateInfo* pAllocateInfo,
VkCommandBuffer* pCommandBuffers) {
return gpu::GetVulkanFunctionPointers()->vkAllocateCommandBuffersFn(
return gpu::GetVulkanFunctionPointers()->vkAllocateCommandBuffers(
device, pAllocateInfo, pCommandBuffers);
}
ALWAYS_INLINE VkResult
vkAllocateDescriptorSets(VkDevice device,
const VkDescriptorSetAllocateInfo* pAllocateInfo,
VkDescriptorSet* pDescriptorSets) {
return gpu::GetVulkanFunctionPointers()->vkAllocateDescriptorSetsFn(
return gpu::GetVulkanFunctionPointers()->vkAllocateDescriptorSets(
device, pAllocateInfo, pDescriptorSets);
}
ALWAYS_INLINE VkResult
......@@ -546,34 +537,34 @@ vkAllocateMemory(VkDevice device,
const VkMemoryAllocateInfo* pAllocateInfo,
const VkAllocationCallbacks* pAllocator,
VkDeviceMemory* pMemory) {
return gpu::GetVulkanFunctionPointers()->vkAllocateMemoryFn(
return gpu::GetVulkanFunctionPointers()->vkAllocateMemory(
device, pAllocateInfo, pAllocator, pMemory);
}
ALWAYS_INLINE VkResult
vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo) {
return gpu::GetVulkanFunctionPointers()->vkBeginCommandBufferFn(commandBuffer,
pBeginInfo);
return gpu::GetVulkanFunctionPointers()->vkBeginCommandBuffer(commandBuffer,
pBeginInfo);
}
ALWAYS_INLINE VkResult vkBindBufferMemory(VkDevice device,
VkBuffer buffer,
VkDeviceMemory memory,
VkDeviceSize memoryOffset) {
return gpu::GetVulkanFunctionPointers()->vkBindBufferMemoryFn(
return gpu::GetVulkanFunctionPointers()->vkBindBufferMemory(
device, buffer, memory, memoryOffset);
}
ALWAYS_INLINE VkResult vkBindImageMemory(VkDevice device,
VkImage image,
VkDeviceMemory memory,
VkDeviceSize memoryOffset) {
return gpu::GetVulkanFunctionPointers()->vkBindImageMemoryFn(
return gpu::GetVulkanFunctionPointers()->vkBindImageMemory(
device, image, memory, memoryOffset);
}
ALWAYS_INLINE void vkCmdBeginRenderPass(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkSubpassContents contents) {
return gpu::GetVulkanFunctionPointers()->vkCmdBeginRenderPassFn(
return gpu::GetVulkanFunctionPointers()->vkCmdBeginRenderPass(
commandBuffer, pRenderPassBegin, contents);
}
ALWAYS_INLINE void vkCmdCopyBuffer(VkCommandBuffer commandBuffer,
......@@ -581,7 +572,7 @@ ALWAYS_INLINE void vkCmdCopyBuffer(VkCommandBuffer commandBuffer,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferCopy* pRegions) {
return gpu::GetVulkanFunctionPointers()->vkCmdCopyBufferFn(
return gpu::GetVulkanFunctionPointers()->vkCmdCopyBuffer(
commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
ALWAYS_INLINE void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
......@@ -590,24 +581,24 @@ ALWAYS_INLINE void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy* pRegions) {
return gpu::GetVulkanFunctionPointers()->vkCmdCopyBufferToImageFn(
return gpu::GetVulkanFunctionPointers()->vkCmdCopyBufferToImage(
commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
pRegions);
}
ALWAYS_INLINE void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
return gpu::GetVulkanFunctionPointers()->vkCmdEndRenderPassFn(commandBuffer);
return gpu::GetVulkanFunctionPointers()->vkCmdEndRenderPass(commandBuffer);
}
ALWAYS_INLINE void vkCmdExecuteCommands(
VkCommandBuffer commandBuffer,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers) {
return gpu::GetVulkanFunctionPointers()->vkCmdExecuteCommandsFn(
return gpu::GetVulkanFunctionPointers()->vkCmdExecuteCommands(
commandBuffer, commandBufferCount, pCommandBuffers);
}
ALWAYS_INLINE void vkCmdNextSubpass(VkCommandBuffer commandBuffer,
VkSubpassContents contents) {
return gpu::GetVulkanFunctionPointers()->vkCmdNextSubpassFn(commandBuffer,
contents);
return gpu::GetVulkanFunctionPointers()->vkCmdNextSubpass(commandBuffer,
contents);
}
ALWAYS_INLINE void vkCmdPipelineBarrier(
VkCommandBuffer commandBuffer,
......@@ -620,7 +611,7 @@ ALWAYS_INLINE void vkCmdPipelineBarrier(
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers) {
return gpu::GetVulkanFunctionPointers()->vkCmdPipelineBarrierFn(
return gpu::GetVulkanFunctionPointers()->vkCmdPipelineBarrier(
commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
......@@ -629,15 +620,15 @@ ALWAYS_INLINE VkResult vkCreateBuffer(VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer) {
return gpu::GetVulkanFunctionPointers()->vkCreateBufferFn(
device, pCreateInfo, pAllocator, 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()->vkCreateCommandPoolFn(
return gpu::GetVulkanFunctionPointers()->vkCreateCommandPool(
device, pCreateInfo, pAllocator, pCommandPool);
}
ALWAYS_INLINE VkResult
......@@ -645,7 +636,7 @@ vkCreateDescriptorPool(VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool) {
return gpu::GetVulkanFunctionPointers()->vkCreateDescriptorPoolFn(
return gpu::GetVulkanFunctionPointers()->vkCreateDescriptorPool(
device, pCreateInfo, pAllocator, pDescriptorPool);
}
ALWAYS_INLINE VkResult
......@@ -653,37 +644,37 @@ vkCreateDescriptorSetLayout(VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout) {
return gpu::GetVulkanFunctionPointers()->vkCreateDescriptorSetLayoutFn(
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()->vkCreateFenceFn(device, pCreateInfo,
pAllocator, 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()->vkCreateFramebufferFn(
return gpu::GetVulkanFunctionPointers()->vkCreateFramebuffer(
device, pCreateInfo, pAllocator, pFramebuffer);
}
ALWAYS_INLINE VkResult vkCreateImage(VkDevice device,
const VkImageCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImage* pImage) {
return gpu::GetVulkanFunctionPointers()->vkCreateImageFn(device, pCreateInfo,
pAllocator, 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()->vkCreateImageViewFn(
return gpu::GetVulkanFunctionPointers()->vkCreateImageView(
device, pCreateInfo, pAllocator, pView);
}
ALWAYS_INLINE VkResult
......@@ -691,14 +682,14 @@ vkCreateRenderPass(VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass) {
return gpu::GetVulkanFunctionPointers()->vkCreateRenderPassFn(
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()->vkCreateSamplerFn(
return gpu::GetVulkanFunctionPointers()->vkCreateSampler(
device, pCreateInfo, pAllocator, pSampler);
}
ALWAYS_INLINE VkResult
......@@ -706,7 +697,7 @@ vkCreateSemaphore(VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore) {
return gpu::GetVulkanFunctionPointers()->vkCreateSemaphoreFn(
return gpu::GetVulkanFunctionPointers()->vkCreateSemaphore(
device, pCreateInfo, pAllocator, pSemaphore);
}
ALWAYS_INLINE VkResult
......@@ -714,111 +705,110 @@ vkCreateShaderModule(VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule) {
return gpu::GetVulkanFunctionPointers()->vkCreateShaderModuleFn(
return gpu::GetVulkanFunctionPointers()->vkCreateShaderModule(
device, pCreateInfo, pAllocator, pShaderModule);
}
ALWAYS_INLINE void vkDestroyBuffer(VkDevice device,
VkBuffer buffer,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyBufferFn(device, buffer,
pAllocator);
return gpu::GetVulkanFunctionPointers()->vkDestroyBuffer(device, buffer,
pAllocator);
}
ALWAYS_INLINE void vkDestroyCommandPool(
VkDevice device,
VkCommandPool commandPool,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyCommandPoolFn(
return gpu::GetVulkanFunctionPointers()->vkDestroyCommandPool(
device, commandPool, pAllocator);
}
ALWAYS_INLINE void vkDestroyDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyDescriptorPoolFn(
return gpu::GetVulkanFunctionPointers()->vkDestroyDescriptorPool(
device, descriptorPool, pAllocator);
}
ALWAYS_INLINE void vkDestroyDescriptorSetLayout(
VkDevice device,
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyDescriptorSetLayoutFn(
return gpu::GetVulkanFunctionPointers()->vkDestroyDescriptorSetLayout(
device, descriptorSetLayout, pAllocator);
}
ALWAYS_INLINE void vkDestroyDevice(VkDevice device,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyDeviceFn(device,
pAllocator);
return gpu::GetVulkanFunctionPointers()->vkDestroyDevice(device, pAllocator);
}
ALWAYS_INLINE void vkDestroyFence(VkDevice device,
VkFence fence,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyFenceFn(device, fence,
pAllocator);
return gpu::GetVulkanFunctionPointers()->vkDestroyFence(device, fence,
pAllocator);
}
ALWAYS_INLINE void vkDestroyFramebuffer(
VkDevice device,
VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyFramebufferFn(
return gpu::GetVulkanFunctionPointers()->vkDestroyFramebuffer(
device, framebuffer, pAllocator);
}
ALWAYS_INLINE void vkDestroyImage(VkDevice device,
VkImage image,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyImageFn(device, image,
pAllocator);
return gpu::GetVulkanFunctionPointers()->vkDestroyImage(device, image,
pAllocator);
}
ALWAYS_INLINE void vkDestroyImageView(VkDevice device,
VkImageView imageView,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyImageViewFn(
device, imageView, pAllocator);
return gpu::GetVulkanFunctionPointers()->vkDestroyImageView(device, imageView,
pAllocator);
}
ALWAYS_INLINE void vkDestroyRenderPass(
VkDevice device,
VkRenderPass renderPass,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyRenderPassFn(
return gpu::GetVulkanFunctionPointers()->vkDestroyRenderPass(
device, renderPass, pAllocator);
}
ALWAYS_INLINE void vkDestroySampler(VkDevice device,
VkSampler sampler,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroySamplerFn(device, sampler,
pAllocator);
return gpu::GetVulkanFunctionPointers()->vkDestroySampler(device, sampler,
pAllocator);
}
ALWAYS_INLINE void vkDestroySemaphore(VkDevice device,
VkSemaphore semaphore,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroySemaphoreFn(
device, semaphore, pAllocator);
return gpu::GetVulkanFunctionPointers()->vkDestroySemaphore(device, semaphore,
pAllocator);
}
ALWAYS_INLINE void vkDestroyShaderModule(
VkDevice device,
VkShaderModule shaderModule,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroyShaderModuleFn(
return gpu::GetVulkanFunctionPointers()->vkDestroyShaderModule(
device, shaderModule, pAllocator);
}
ALWAYS_INLINE VkResult vkDeviceWaitIdle(VkDevice device) {
return gpu::GetVulkanFunctionPointers()->vkDeviceWaitIdleFn(device);
return gpu::GetVulkanFunctionPointers()->vkDeviceWaitIdle(device);
}
ALWAYS_INLINE VkResult
vkFlushMappedMemoryRanges(VkDevice device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges) {
return gpu::GetVulkanFunctionPointers()->vkFlushMappedMemoryRangesFn(
return gpu::GetVulkanFunctionPointers()->vkFlushMappedMemoryRanges(
device, memoryRangeCount, pMemoryRanges);
}
ALWAYS_INLINE VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
return gpu::GetVulkanFunctionPointers()->vkEndCommandBufferFn(commandBuffer);
return gpu::GetVulkanFunctionPointers()->vkEndCommandBuffer(commandBuffer);
}
ALWAYS_INLINE void vkFreeCommandBuffers(
VkDevice device,
VkCommandPool commandPool,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers) {
return gpu::GetVulkanFunctionPointers()->vkFreeCommandBuffersFn(
return gpu::GetVulkanFunctionPointers()->vkFreeCommandBuffers(
device, commandPool, commandBufferCount, pCommandBuffers);
}
ALWAYS_INLINE VkResult
......@@ -826,44 +816,44 @@ vkFreeDescriptorSets(VkDevice device,
VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets) {
return gpu::GetVulkanFunctionPointers()->vkFreeDescriptorSetsFn(
return gpu::GetVulkanFunctionPointers()->vkFreeDescriptorSets(
device, descriptorPool, descriptorSetCount, pDescriptorSets);
}
ALWAYS_INLINE void vkFreeMemory(VkDevice device,
VkDeviceMemory memory,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkFreeMemoryFn(device, memory,
pAllocator);
return gpu::GetVulkanFunctionPointers()->vkFreeMemory(device, memory,
pAllocator);
}
ALWAYS_INLINE VkResult
vkInvalidateMappedMemoryRanges(VkDevice device,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges) {
return gpu::GetVulkanFunctionPointers()->vkInvalidateMappedMemoryRangesFn(
return gpu::GetVulkanFunctionPointers()->vkInvalidateMappedMemoryRanges(
device, memoryRangeCount, pMemoryRanges);
}
ALWAYS_INLINE void vkGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements) {
return gpu::GetVulkanFunctionPointers()->vkGetBufferMemoryRequirementsFn(
return gpu::GetVulkanFunctionPointers()->vkGetBufferMemoryRequirements(
device, buffer, pMemoryRequirements);
}
ALWAYS_INLINE void vkGetDeviceQueue(VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
VkQueue* pQueue) {
return gpu::GetVulkanFunctionPointers()->vkGetDeviceQueueFn(
return gpu::GetVulkanFunctionPointers()->vkGetDeviceQueue(
device, queueFamilyIndex, queueIndex, pQueue);
}
ALWAYS_INLINE VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
return gpu::GetVulkanFunctionPointers()->vkGetFenceStatusFn(device, fence);
return gpu::GetVulkanFunctionPointers()->vkGetFenceStatus(device, fence);
}
ALWAYS_INLINE void vkGetImageMemoryRequirements(
VkDevice device,
VkImage image,
VkMemoryRequirements* pMemoryRequirements) {
return gpu::GetVulkanFunctionPointers()->vkGetImageMemoryRequirementsFn(
return gpu::GetVulkanFunctionPointers()->vkGetImageMemoryRequirements(
device, image, pMemoryRequirements);
}
ALWAYS_INLINE VkResult vkMapMemory(VkDevice device,
......@@ -872,32 +862,32 @@ ALWAYS_INLINE VkResult vkMapMemory(VkDevice device,
VkDeviceSize size,
VkMemoryMapFlags flags,
void** ppData) {
return gpu::GetVulkanFunctionPointers()->vkMapMemoryFn(device, memory, offset,
size, flags, 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) {
return gpu::GetVulkanFunctionPointers()->vkQueueSubmitFn(queue, submitCount,
pSubmits, fence);
return gpu::GetVulkanFunctionPointers()->vkQueueSubmit(queue, submitCount,
pSubmits, fence);
}
ALWAYS_INLINE VkResult vkQueueWaitIdle(VkQueue queue) {
return gpu::GetVulkanFunctionPointers()->vkQueueWaitIdleFn(queue);
return gpu::GetVulkanFunctionPointers()->vkQueueWaitIdle(queue);
}
ALWAYS_INLINE VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags) {
return gpu::GetVulkanFunctionPointers()->vkResetCommandBufferFn(commandBuffer,
flags);
return gpu::GetVulkanFunctionPointers()->vkResetCommandBuffer(commandBuffer,
flags);
}
ALWAYS_INLINE VkResult vkResetFences(VkDevice device,
uint32_t fenceCount,
const VkFence* pFences) {
return gpu::GetVulkanFunctionPointers()->vkResetFencesFn(device, fenceCount,
pFences);
return gpu::GetVulkanFunctionPointers()->vkResetFences(device, fenceCount,
pFences);
}
ALWAYS_INLINE void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
return gpu::GetVulkanFunctionPointers()->vkUnmapMemoryFn(device, memory);
return gpu::GetVulkanFunctionPointers()->vkUnmapMemory(device, memory);
}
ALWAYS_INLINE void vkUpdateDescriptorSets(
VkDevice device,
......@@ -905,7 +895,7 @@ ALWAYS_INLINE void vkUpdateDescriptorSets(
const VkWriteDescriptorSet* pDescriptorWrites,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies) {
return gpu::GetVulkanFunctionPointers()->vkUpdateDescriptorSetsFn(
return gpu::GetVulkanFunctionPointers()->vkUpdateDescriptorSets(
device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
pDescriptorCopies);
}
......@@ -914,28 +904,28 @@ ALWAYS_INLINE VkResult vkWaitForFences(VkDevice device,
const VkFence* pFences,
VkBool32 waitAll,
uint64_t timeout) {
return gpu::GetVulkanFunctionPointers()->vkWaitForFencesFn(
return gpu::GetVulkanFunctionPointers()->vkWaitForFences(
device, fenceCount, pFences, waitAll, timeout);
}
ALWAYS_INLINE void vkGetDeviceQueue2(VkDevice device,
const VkDeviceQueueInfo2* pQueueInfo,
VkQueue* pQueue) {
return gpu::GetVulkanFunctionPointers()->vkGetDeviceQueue2Fn(
device, pQueueInfo, pQueue);
return gpu::GetVulkanFunctionPointers()->vkGetDeviceQueue2(device, pQueueInfo,
pQueue);
}
ALWAYS_INLINE void vkGetBufferMemoryRequirements2(
VkDevice device,
const VkBufferMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
return gpu::GetVulkanFunctionPointers()->vkGetBufferMemoryRequirements2Fn(
return gpu::GetVulkanFunctionPointers()->vkGetBufferMemoryRequirements2(
device, pInfo, pMemoryRequirements);
}
ALWAYS_INLINE void vkGetImageMemoryRequirements2(
VkDevice device,
const VkImageMemoryRequirementsInfo2* pInfo,
VkMemoryRequirements2* pMemoryRequirements) {
return gpu::GetVulkanFunctionPointers()->vkGetImageMemoryRequirements2Fn(
return gpu::GetVulkanFunctionPointers()->vkGetImageMemoryRequirements2(
device, pInfo, pMemoryRequirements);
}
......@@ -945,8 +935,8 @@ ALWAYS_INLINE VkResult vkGetAndroidHardwareBufferPropertiesANDROID(
const struct AHardwareBuffer* buffer,
VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
return gpu::GetVulkanFunctionPointers()
->vkGetAndroidHardwareBufferPropertiesANDROIDFn(device, buffer,
pProperties);
->vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer,
pProperties);
}
#endif // defined(OS_ANDROID)
......@@ -955,13 +945,13 @@ ALWAYS_INLINE VkResult
vkGetSemaphoreFdKHR(VkDevice device,
const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
int* pFd) {
return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreFdKHRFn(
device, pGetFdInfo, pFd);
return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreFdKHR(device,
pGetFdInfo, pFd);
}
ALWAYS_INLINE VkResult vkImportSemaphoreFdKHR(
VkDevice device,
const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreFdKHRFn(
return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreFdKHR(
device, pImportSemaphoreFdInfo);
}
#endif // defined(OS_LINUX) || defined(OS_ANDROID)
......@@ -971,14 +961,14 @@ ALWAYS_INLINE VkResult vkGetSemaphoreWin32HandleKHR(
VkDevice device,
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle) {
return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreWin32HandleKHRFn(
return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreWin32HandleKHR(
device, pGetWin32HandleInfo, pHandle);
}
ALWAYS_INLINE VkResult
vkImportSemaphoreWin32HandleKHR(VkDevice device,
const VkImportSemaphoreWin32HandleInfoKHR*
pImportSemaphoreWin32HandleInfo) {
return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreWin32HandleKHRFn(
return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreWin32HandleKHR(
device, pImportSemaphoreWin32HandleInfo);
}
#endif // defined(OS_WIN)
......@@ -987,15 +977,15 @@ vkImportSemaphoreWin32HandleKHR(VkDevice device,
ALWAYS_INLINE VkResult vkGetMemoryFdKHR(VkDevice device,
const VkMemoryGetFdInfoKHR* pGetFdInfo,
int* pFd) {
return gpu::GetVulkanFunctionPointers()->vkGetMemoryFdKHRFn(device,
pGetFdInfo, pFd);
return gpu::GetVulkanFunctionPointers()->vkGetMemoryFdKHR(device, pGetFdInfo,
pFd);
}
ALWAYS_INLINE VkResult
vkGetMemoryFdPropertiesKHR(VkDevice device,
VkExternalMemoryHandleTypeFlagBits handleType,
int fd,
VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
return gpu::GetVulkanFunctionPointers()->vkGetMemoryFdPropertiesKHRFn(
return gpu::GetVulkanFunctionPointers()->vkGetMemoryFdPropertiesKHR(
device, handleType, fd, pMemoryFdProperties);
}
#endif // defined(OS_LINUX) || defined(OS_ANDROID)
......@@ -1005,7 +995,7 @@ ALWAYS_INLINE VkResult vkGetMemoryWin32HandleKHR(
VkDevice device,
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
HANDLE* pHandle) {
return gpu::GetVulkanFunctionPointers()->vkGetMemoryWin32HandleKHRFn(
return gpu::GetVulkanFunctionPointers()->vkGetMemoryWin32HandleKHR(
device, pGetWin32HandleInfo, pHandle);
}
ALWAYS_INLINE VkResult vkGetMemoryWin32HandlePropertiesKHR(
......@@ -1013,33 +1003,32 @@ ALWAYS_INLINE VkResult vkGetMemoryWin32HandlePropertiesKHR(
VkExternalMemoryHandleTypeFlagBits handleType,
HANDLE handle,
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
return gpu::GetVulkanFunctionPointers()
->vkGetMemoryWin32HandlePropertiesKHRFn(device, handleType, handle,
pMemoryWin32HandleProperties);
return gpu::GetVulkanFunctionPointers()->vkGetMemoryWin32HandlePropertiesKHR(
device, handleType, handle, pMemoryWin32HandleProperties);
}
#endif // defined(OS_WIN)
#if defined(OS_FUCHSIA)
#define vkImportSemaphoreZirconHandleFUCHSIA \
gpu::GetVulkanFunctionPointers()->vkImportSemaphoreZirconHandleFUCHSIAFn
gpu::GetVulkanFunctionPointers()->vkImportSemaphoreZirconHandleFUCHSIA
#define vkGetSemaphoreZirconHandleFUCHSIA \
gpu::GetVulkanFunctionPointers()->vkGetSemaphoreZirconHandleFUCHSIAFn
gpu::GetVulkanFunctionPointers()->vkGetSemaphoreZirconHandleFUCHSIA
#endif // defined(OS_FUCHSIA)
#if defined(OS_FUCHSIA)
#define vkGetMemoryZirconHandleFUCHSIA \
gpu::GetVulkanFunctionPointers()->vkGetMemoryZirconHandleFUCHSIAFn
gpu::GetVulkanFunctionPointers()->vkGetMemoryZirconHandleFUCHSIA
#endif // defined(OS_FUCHSIA)
#if defined(OS_FUCHSIA)
#define vkCreateBufferCollectionFUCHSIA \
gpu::GetVulkanFunctionPointers()->vkCreateBufferCollectionFUCHSIAFn
gpu::GetVulkanFunctionPointers()->vkCreateBufferCollectionFUCHSIA
#define vkSetBufferCollectionConstraintsFUCHSIA \
gpu::GetVulkanFunctionPointers()->vkSetBufferCollectionConstraintsFUCHSIAFn
gpu::GetVulkanFunctionPointers()->vkSetBufferCollectionConstraintsFUCHSIA
#define vkGetBufferCollectionPropertiesFUCHSIA \
gpu::GetVulkanFunctionPointers()->vkGetBufferCollectionPropertiesFUCHSIAFn
gpu::GetVulkanFunctionPointers()->vkGetBufferCollectionPropertiesFUCHSIA
#define vkDestroyBufferCollectionFUCHSIA \
gpu::GetVulkanFunctionPointers()->vkDestroyBufferCollectionFUCHSIAFn
gpu::GetVulkanFunctionPointers()->vkDestroyBufferCollectionFUCHSIA
#endif // defined(OS_FUCHSIA)
ALWAYS_INLINE VkResult vkAcquireNextImageKHR(VkDevice device,
......@@ -1048,7 +1037,7 @@ ALWAYS_INLINE VkResult vkAcquireNextImageKHR(VkDevice device,
VkSemaphore semaphore,
VkFence fence,
uint32_t* pImageIndex) {
return gpu::GetVulkanFunctionPointers()->vkAcquireNextImageKHRFn(
return gpu::GetVulkanFunctionPointers()->vkAcquireNextImageKHR(
device, swapchain, timeout, semaphore, fence, pImageIndex);
}
ALWAYS_INLINE VkResult
......@@ -1056,27 +1045,27 @@ vkCreateSwapchainKHR(VkDevice device,
const VkSwapchainCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchain) {
return gpu::GetVulkanFunctionPointers()->vkCreateSwapchainKHRFn(
return gpu::GetVulkanFunctionPointers()->vkCreateSwapchainKHR(
device, pCreateInfo, pAllocator, pSwapchain);
}
ALWAYS_INLINE void vkDestroySwapchainKHR(
VkDevice device,
VkSwapchainKHR swapchain,
const VkAllocationCallbacks* pAllocator) {
return gpu::GetVulkanFunctionPointers()->vkDestroySwapchainKHRFn(
return gpu::GetVulkanFunctionPointers()->vkDestroySwapchainKHR(
device, swapchain, pAllocator);
}
ALWAYS_INLINE VkResult vkGetSwapchainImagesKHR(VkDevice device,
VkSwapchainKHR swapchain,
uint32_t* pSwapchainImageCount,
VkImage* pSwapchainImages) {
return gpu::GetVulkanFunctionPointers()->vkGetSwapchainImagesKHRFn(
return gpu::GetVulkanFunctionPointers()->vkGetSwapchainImagesKHR(
device, swapchain, pSwapchainImageCount, pSwapchainImages);
}
ALWAYS_INLINE VkResult vkQueuePresentKHR(VkQueue queue,
const VkPresentInfoKHR* pPresentInfo) {
return gpu::GetVulkanFunctionPointers()->vkQueuePresentKHRFn(queue,
pPresentInfo);
return gpu::GetVulkanFunctionPointers()->vkQueuePresentKHR(queue,
pPresentInfo);
}
#endif // GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_
\ No newline at end of file
gpu/vulkan/vulkan_instance.cc
View file @ 8cff2cd0
......@@ -60,6 +60,8 @@ VulkanWarningCallback(VkDebugReportFlagsEXT flags,
}
#endif // DCHECK_IS_ON()
constexpr uint32_t kRequiredApiVersion = VK_MAKE_VERSION(1, 1, 0);
} // namespace
VulkanInstance::VulkanInstance() = default;
......@@ -79,19 +81,19 @@ bool VulkanInstance::Initialize(
if (!vulkan_function_pointers->BindUnassociatedFunctionPointers())
return false;
if (vulkan_function_pointers->vkEnumerateInstanceVersionFn)
vkEnumerateInstanceVersion(&vulkan_info_.api_version);
VkResult result = vkEnumerateInstanceVersion(&vulkan_info_.api_version);
if (result != VK_SUCCESS) {
DLOG(ERROR) << "vkEnumerateInstanceVersion() failed: " << result;
return false;
}
if (vulkan_info_.api_version < VK_MAKE_VERSION(1, 1, 0))
if (vulkan_info_.api_version < kRequiredApiVersion)
return false;
gpu::crash_keys::vulkan_api_version.Set(
VkVersionToString(vulkan_info_.api_version));
// Use Vulkan 1.1 if it's available.
vulkan_info_.used_api_version = VK_MAKE_VERSION(1, 1, 0);
VkResult result = VK_SUCCESS;
vulkan_info_.used_api_version = kRequiredApiVersion;
VkApplicationInfo app_info = {};
app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment