- You should now have `$GOPATH/bin/apic`. You might want to add `$GOPATH/bin` to your `$PATH`.
### Generating code
-To generate `libvulkan/dispatch_gen.*`,
+To generate `libvulkan/*_gen.*`,
- `$ cd libvulkan`
-- `$ apic template ../api/vulkan.api dispatch.tmpl`
-Similar for `nulldrv/null_driver_gen.*`.
\ No newline at end of file
+- `$ apic template ../api/vulkan.api code-generator.tmpl`
+Similar for `nulldrv/null_driver_gen.*`.
LOCAL_SANITIZE := integer
LOCAL_CFLAGS := -DLOG_TAG=\"vulkan\" \
+ -DVK_USE_PLATFORM_ANDROID_KHR \
-std=c99 -fvisibility=hidden -fstrict-aliasing \
-Weverything -Werror \
-Wno-padded \
system/core/libsync/include
LOCAL_SRC_FILES := \
+ api.cpp \
+ api_gen.cpp \
debug_report.cpp \
dispatch_gen.cpp \
layers_extensions.cpp \
--- /dev/null
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// The API layer of the loader defines Vulkan API and manages layers. The
+// entrypoints are generated and defined in api_dispatch.cpp. Most of them
+// simply find the dispatch table and jump.
+//
+// There are a few of them requiring manual code for things such as layer
+// discovery or chaining. They call into functions defined in this file.
+
+#include <stdlib.h>
+#include <string.h>
+#include <algorithm>
+#include <mutex>
+#include <new>
+#include <utility>
+#include <cutils/properties.h>
+#include <log/log.h>
+
+#include <vulkan/vk_layer_interface.h>
+#include "api.h"
+#include "driver.h"
+#include "loader.h"
+
+namespace vulkan {
+namespace api {
+
+namespace {
+
+// Provide overridden layer names when there are implicit layers. No effect
+// otherwise.
+class OverrideLayerNames {
+ public:
+ OverrideLayerNames(bool is_instance, const VkAllocationCallbacks& allocator)
+ : is_instance_(is_instance),
+ allocator_(allocator),
+ scope_(VK_SYSTEM_ALLOCATION_SCOPE_COMMAND),
+ names_(nullptr),
+ name_count_(0),
+ implicit_layers_() {
+ implicit_layers_.result = VK_SUCCESS;
+ }
+
+ ~OverrideLayerNames() {
+ allocator_.pfnFree(allocator_.pUserData, names_);
+ allocator_.pfnFree(allocator_.pUserData, implicit_layers_.elements);
+ allocator_.pfnFree(allocator_.pUserData, implicit_layers_.name_pool);
+ }
+
+ VkResult parse(const char* const* names, uint32_t count) {
+ add_implicit_layers();
+
+ const auto& arr = implicit_layers_;
+ if (arr.result != VK_SUCCESS)
+ return arr.result;
+
+ // no need to override when there is no implicit layer
+ if (!arr.count)
+ return VK_SUCCESS;
+
+ names_ = allocate_name_array(arr.count + count);
+ if (!names_)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ // add implicit layer names
+ for (uint32_t i = 0; i < arr.count; i++)
+ names_[i] = get_implicit_layer_name(i);
+
+ name_count_ = arr.count;
+
+ // add explicit layer names
+ for (uint32_t i = 0; i < count; i++) {
+ // ignore explicit layers that are also implicit
+ if (is_implicit_layer(names[i]))
+ continue;
+
+ names_[name_count_++] = names[i];
+ }
+
+ return VK_SUCCESS;
+ }
+
+ const char* const* names() const { return names_; }
+
+ uint32_t count() const { return name_count_; }
+
+ private:
+ struct ImplicitLayer {
+ int priority;
+ size_t name_offset;
+ };
+
+ struct ImplicitLayerArray {
+ ImplicitLayer* elements;
+ uint32_t max_count;
+ uint32_t count;
+
+ char* name_pool;
+ size_t max_pool_size;
+ size_t pool_size;
+
+ VkResult result;
+ };
+
+ void add_implicit_layers() {
+ if (!driver::Debuggable())
+ return;
+
+ parse_debug_vulkan_layers();
+ property_list(parse_debug_vulkan_layer, this);
+
+ // sort by priorities
+ auto& arr = implicit_layers_;
+ std::sort(arr.elements, arr.elements + arr.count,
+ [](const ImplicitLayer& a, const ImplicitLayer& b) {
+ return (a.priority < b.priority);
+ });
+ }
+
+ void parse_debug_vulkan_layers() {
+ // debug.vulkan.layers specifies colon-separated layer names
+ char prop[PROPERTY_VALUE_MAX];
+ if (!property_get("debug.vulkan.layers", prop, ""))
+ return;
+
+ // assign negative/high priorities to them
+ int prio = -PROPERTY_VALUE_MAX;
+
+ const char* p = prop;
+ const char* delim;
+ while ((delim = strchr(p, ':'))) {
+ if (delim > p)
+ add_implicit_layer(prio, p, static_cast<size_t>(delim - p));
+
+ prio++;
+ p = delim + 1;
+ }
+
+ if (p[0] != '\0')
+ add_implicit_layer(prio, p, strlen(p));
+ }
+
+ static void parse_debug_vulkan_layer(const char* key,
+ const char* val,
+ void* user_data) {
+ static const char prefix[] = "debug.vulkan.layer.";
+ const size_t prefix_len = sizeof(prefix) - 1;
+
+ if (strncmp(key, prefix, prefix_len) || val[0] == '\0')
+ return;
+ key += prefix_len;
+
+ // debug.vulkan.layer.<priority>
+ int priority = -1;
+ if (key[0] >= '0' && key[0] <= '9')
+ priority = atoi(key);
+
+ if (priority < 0) {
+ ALOGW("Ignored implicit layer %s with invalid priority %s", val,
+ key);
+ return;
+ }
+
+ OverrideLayerNames& override_layers =
+ *reinterpret_cast<OverrideLayerNames*>(user_data);
+ override_layers.add_implicit_layer(priority, val, strlen(val));
+ }
+
+ void add_implicit_layer(int priority, const char* name, size_t len) {
+ if (!grow_implicit_layer_array(1, 0))
+ return;
+
+ auto& arr = implicit_layers_;
+ auto& layer = arr.elements[arr.count++];
+
+ layer.priority = priority;
+ layer.name_offset = add_implicit_layer_name(name, len);
+
+ ALOGV("Added implicit layer %s",
+ get_implicit_layer_name(arr.count - 1));
+ }
+
+ size_t add_implicit_layer_name(const char* name, size_t len) {
+ if (!grow_implicit_layer_array(0, len + 1))
+ return 0;
+
+ // add the name to the pool
+ auto& arr = implicit_layers_;
+ size_t offset = arr.pool_size;
+ char* dst = arr.name_pool + offset;
+
+ std::copy(name, name + len, dst);
+ dst[len] = '\0';
+
+ arr.pool_size += len + 1;
+
+ return offset;
+ }
+
+ bool grow_implicit_layer_array(uint32_t layer_count, size_t name_size) {
+ const uint32_t initial_max_count = 16;
+ const size_t initial_max_pool_size = 512;
+
+ auto& arr = implicit_layers_;
+
+ // grow the element array if needed
+ while (arr.count + layer_count > arr.max_count) {
+ uint32_t new_max_count =
+ (arr.max_count) ? (arr.max_count << 1) : initial_max_count;
+ void* new_mem = nullptr;
+
+ if (new_max_count > arr.max_count) {
+ new_mem = allocator_.pfnReallocation(
+ allocator_.pUserData, arr.elements,
+ sizeof(ImplicitLayer) * new_max_count,
+ alignof(ImplicitLayer), scope_);
+ }
+
+ if (!new_mem) {
+ arr.result = VK_ERROR_OUT_OF_HOST_MEMORY;
+ arr.count = 0;
+ return false;
+ }
+
+ arr.elements = reinterpret_cast<ImplicitLayer*>(new_mem);
+ arr.max_count = new_max_count;
+ }
+
+ // grow the name pool if needed
+ while (arr.pool_size + name_size > arr.max_pool_size) {
+ size_t new_max_pool_size = (arr.max_pool_size)
+ ? (arr.max_pool_size << 1)
+ : initial_max_pool_size;
+ void* new_mem = nullptr;
+
+ if (new_max_pool_size > arr.max_pool_size) {
+ new_mem = allocator_.pfnReallocation(
+ allocator_.pUserData, arr.name_pool, new_max_pool_size,
+ alignof(char), scope_);
+ }
+
+ if (!new_mem) {
+ arr.result = VK_ERROR_OUT_OF_HOST_MEMORY;
+ arr.pool_size = 0;
+ return false;
+ }
+
+ arr.name_pool = reinterpret_cast<char*>(new_mem);
+ arr.max_pool_size = new_max_pool_size;
+ }
+
+ return true;
+ }
+
+ const char* get_implicit_layer_name(uint32_t index) const {
+ const auto& arr = implicit_layers_;
+
+ // this may return nullptr when arr.result is not VK_SUCCESS
+ return implicit_layers_.name_pool + arr.elements[index].name_offset;
+ }
+
+ bool is_implicit_layer(const char* name) const {
+ const auto& arr = implicit_layers_;
+
+ for (uint32_t i = 0; i < arr.count; i++) {
+ if (strcmp(name, get_implicit_layer_name(i)) == 0)
+ return true;
+ }
+
+ return false;
+ }
+
+ const char** allocate_name_array(uint32_t count) const {
+ return reinterpret_cast<const char**>(allocator_.pfnAllocation(
+ allocator_.pUserData, sizeof(const char*) * count,
+ alignof(const char*), scope_));
+ }
+
+ const bool is_instance_;
+ const VkAllocationCallbacks& allocator_;
+ const VkSystemAllocationScope scope_;
+
+ const char** names_;
+ uint32_t name_count_;
+
+ ImplicitLayerArray implicit_layers_;
+};
+
+// Provide overridden extension names when there are implicit extensions.
+// No effect otherwise.
+//
+// This is used only to enable VK_EXT_debug_report.
+class OverrideExtensionNames {
+ public:
+ OverrideExtensionNames(bool is_instance,
+ const VkAllocationCallbacks& allocator)
+ : is_instance_(is_instance),
+ allocator_(allocator),
+ scope_(VK_SYSTEM_ALLOCATION_SCOPE_COMMAND),
+ names_(nullptr),
+ name_count_(0),
+ install_debug_callback_(false) {}
+
+ ~OverrideExtensionNames() {
+ allocator_.pfnFree(allocator_.pUserData, names_);
+ }
+
+ VkResult parse(const char* const* names, uint32_t count) {
+ // this is only for debug.vulkan.enable_callback
+ if (!enable_debug_callback())
+ return VK_SUCCESS;
+
+ names_ = allocate_name_array(count + 1);
+ if (!names_)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ std::copy(names, names + count, names_);
+
+ name_count_ = count;
+ names_[name_count_++] = "VK_EXT_debug_report";
+
+ install_debug_callback_ = true;
+
+ return VK_SUCCESS;
+ }
+
+ const char* const* names() const { return names_; }
+
+ uint32_t count() const { return name_count_; }
+
+ bool install_debug_callback() const { return install_debug_callback_; }
+
+ private:
+ bool enable_debug_callback() const {
+ return (is_instance_ && driver::Debuggable() &&
+ property_get_bool("debug.vulkan.enable_callback", false));
+ }
+
+ const char** allocate_name_array(uint32_t count) const {
+ return reinterpret_cast<const char**>(allocator_.pfnAllocation(
+ allocator_.pUserData, sizeof(const char*) * count,
+ alignof(const char*), scope_));
+ }
+
+ const bool is_instance_;
+ const VkAllocationCallbacks& allocator_;
+ const VkSystemAllocationScope scope_;
+
+ const char** names_;
+ uint32_t name_count_;
+ bool install_debug_callback_;
+};
+
+// vkCreateInstance and vkCreateDevice helpers with support for layer
+// chaining.
+class LayerChain {
+ public:
+ static VkResult create_instance(const VkInstanceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+ VkInstance* instance_out);
+
+ static VkResult create_device(VkPhysicalDevice physical_dev,
+ const VkDeviceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+ VkDevice* dev_out);
+
+ static void destroy_instance(VkInstance instance,
+ const VkAllocationCallbacks* allocator);
+
+ static void destroy_device(VkDevice dev,
+ const VkAllocationCallbacks* allocator);
+
+ private:
+ struct ActiveLayer {
+ LayerRef ref;
+ union {
+ VkLayerInstanceLink instance_link;
+ VkLayerDeviceLink device_link;
+ };
+ };
+
+ LayerChain(bool is_instance, const VkAllocationCallbacks& allocator);
+ ~LayerChain();
+
+ VkResult activate_layers(const char* const* layer_names,
+ uint32_t layer_count,
+ const char* const* extension_names,
+ uint32_t extension_count);
+ ActiveLayer* allocate_layer_array(uint32_t count) const;
+ VkResult load_layer(ActiveLayer& layer, const char* name);
+ void setup_layer_links();
+
+ bool empty() const;
+ void modify_create_info(VkInstanceCreateInfo& info);
+ void modify_create_info(VkDeviceCreateInfo& info);
+
+ VkResult create(const VkInstanceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+ VkInstance* instance_out);
+
+ VkResult create(VkPhysicalDevice physical_dev,
+ const VkDeviceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+ VkDevice* dev_out);
+
+ template <typename DataType>
+ void steal_layers(DataType& data);
+
+ static void destroy_layers(ActiveLayer* layers,
+ uint32_t count,
+ const VkAllocationCallbacks& allocator);
+
+ static VKAPI_ATTR VkBool32
+ debug_report_callback(VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT obj_type,
+ uint64_t obj,
+ size_t location,
+ int32_t msg_code,
+ const char* layer_prefix,
+ const char* msg,
+ void* user_data);
+
+ const bool is_instance_;
+ const VkAllocationCallbacks& allocator_;
+
+ OverrideLayerNames override_layers_;
+ OverrideExtensionNames override_extensions_;
+
+ ActiveLayer* layers_;
+ uint32_t layer_count_;
+
+ PFN_vkGetInstanceProcAddr get_instance_proc_addr_;
+ PFN_vkGetDeviceProcAddr get_device_proc_addr_;
+
+ union {
+ VkLayerInstanceCreateInfo instance_chain_info_;
+ VkLayerDeviceCreateInfo device_chain_info_;
+ };
+};
+
+LayerChain::LayerChain(bool is_instance, const VkAllocationCallbacks& allocator)
+ : is_instance_(is_instance),
+ allocator_(allocator),
+ override_layers_(is_instance, allocator),
+ override_extensions_(is_instance, allocator),
+ layers_(nullptr),
+ layer_count_(0),
+ get_instance_proc_addr_(nullptr),
+ get_device_proc_addr_(nullptr) {}
+
+LayerChain::~LayerChain() {
+ destroy_layers(layers_, layer_count_, allocator_);
+}
+
+VkResult LayerChain::activate_layers(const char* const* layer_names,
+ uint32_t layer_count,
+ const char* const* extension_names,
+ uint32_t extension_count) {
+ VkResult result = override_layers_.parse(layer_names, layer_count);
+ if (result != VK_SUCCESS)
+ return result;
+
+ result = override_extensions_.parse(extension_names, extension_count);
+ if (result != VK_SUCCESS)
+ return result;
+
+ if (override_layers_.count()) {
+ layer_names = override_layers_.names();
+ layer_count = override_layers_.count();
+ }
+
+ if (!layer_count) {
+ // point head of chain to the driver
+ get_instance_proc_addr_ = driver::GetInstanceProcAddr;
+ if (!is_instance_)
+ get_device_proc_addr_ = driver::GetDeviceProcAddr;
+
+ return VK_SUCCESS;
+ }
+
+ layers_ = allocate_layer_array(layer_count);
+ if (!layers_)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ // load layers
+ for (uint32_t i = 0; i < layer_count; i++) {
+ result = load_layer(layers_[i], layer_names[i]);
+ if (result != VK_SUCCESS)
+ return result;
+
+ // count loaded layers for proper destructions on errors
+ layer_count_++;
+ }
+
+ setup_layer_links();
+
+ return VK_SUCCESS;
+}
+
+LayerChain::ActiveLayer* LayerChain::allocate_layer_array(
+ uint32_t count) const {
+ VkSystemAllocationScope scope = (is_instance_)
+ ? VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
+ : VK_SYSTEM_ALLOCATION_SCOPE_DEVICE;
+
+ return reinterpret_cast<ActiveLayer*>(allocator_.pfnAllocation(
+ allocator_.pUserData, sizeof(ActiveLayer) * count, alignof(ActiveLayer),
+ scope));
+}
+
+VkResult LayerChain::load_layer(ActiveLayer& layer, const char* name) {
+ if (is_instance_)
+ new (&layer) ActiveLayer{GetInstanceLayerRef(name), {}};
+ else
+ new (&layer) ActiveLayer{GetDeviceLayerRef(name), {}};
+
+ if (!layer.ref) {
+ ALOGE("Failed to load layer %s", name);
+ layer.ref.~LayerRef();
+ return VK_ERROR_LAYER_NOT_PRESENT;
+ }
+
+ ALOGI("Loaded %s layer %s", (is_instance_) ? "instance" : "device", name);
+
+ return VK_SUCCESS;
+}
+
+void LayerChain::setup_layer_links() {
+ if (is_instance_) {
+ for (uint32_t i = 0; i < layer_count_; i++) {
+ ActiveLayer& layer = layers_[i];
+
+ // point head of chain to the first layer
+ if (i == 0)
+ get_instance_proc_addr_ = layer.ref.GetGetInstanceProcAddr();
+
+ // point tail of chain to the driver
+ if (i == layer_count_ - 1) {
+ layer.instance_link.pNext = nullptr;
+ layer.instance_link.pfnNextGetInstanceProcAddr =
+ driver::GetInstanceProcAddr;
+ break;
+ }
+
+ const ActiveLayer& next = layers_[i + 1];
+
+ // const_cast as some naughty layers want to modify our links!
+ layer.instance_link.pNext =
+ const_cast<VkLayerInstanceLink*>(&next.instance_link);
+ layer.instance_link.pfnNextGetInstanceProcAddr =
+ next.ref.GetGetInstanceProcAddr();
+ }
+ } else {
+ for (uint32_t i = 0; i < layer_count_; i++) {
+ ActiveLayer& layer = layers_[i];
+
+ // point head of chain to the first layer
+ if (i == 0) {
+ get_instance_proc_addr_ = layer.ref.GetGetInstanceProcAddr();
+ get_device_proc_addr_ = layer.ref.GetGetDeviceProcAddr();
+ }
+
+ // point tail of chain to the driver
+ if (i == layer_count_ - 1) {
+ layer.device_link.pNext = nullptr;
+ layer.device_link.pfnNextGetInstanceProcAddr =
+ driver::GetInstanceProcAddr;
+ layer.device_link.pfnNextGetDeviceProcAddr =
+ driver::GetDeviceProcAddr;
+ break;
+ }
+
+ const ActiveLayer& next = layers_[i + 1];
+
+ // const_cast as some naughty layers want to modify our links!
+ layer.device_link.pNext =
+ const_cast<VkLayerDeviceLink*>(&next.device_link);
+ layer.device_link.pfnNextGetInstanceProcAddr =
+ next.ref.GetGetInstanceProcAddr();
+ layer.device_link.pfnNextGetDeviceProcAddr =
+ next.ref.GetGetDeviceProcAddr();
+ }
+ }
+}
+
+bool LayerChain::empty() const {
+ return (!layer_count_ && !override_layers_.count() &&
+ !override_extensions_.count());
+}
+
+void LayerChain::modify_create_info(VkInstanceCreateInfo& info) {
+ if (layer_count_) {
+ const ActiveLayer& layer = layers_[0];
+
+ instance_chain_info_.sType =
+ VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
+ instance_chain_info_.function = VK_LAYER_FUNCTION_LINK;
+ // TODO fix vk_layer_interface.h and get rid of const_cast?
+ instance_chain_info_.u.pLayerInfo =
+ const_cast<VkLayerInstanceLink*>(&layer.instance_link);
+
+ // insert layer info
+ instance_chain_info_.pNext = info.pNext;
+ info.pNext = &instance_chain_info_;
+ }
+
+ if (override_layers_.count()) {
+ info.enabledLayerCount = override_layers_.count();
+ info.ppEnabledLayerNames = override_layers_.names();
+ }
+
+ if (override_extensions_.count()) {
+ info.enabledExtensionCount = override_extensions_.count();
+ info.ppEnabledExtensionNames = override_extensions_.names();
+ }
+}
+
+void LayerChain::modify_create_info(VkDeviceCreateInfo& info) {
+ if (layer_count_) {
+ const ActiveLayer& layer = layers_[0];
+
+ device_chain_info_.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
+ device_chain_info_.function = VK_LAYER_FUNCTION_LINK;
+ // TODO fix vk_layer_interface.h and get rid of const_cast?
+ device_chain_info_.u.pLayerInfo =
+ const_cast<VkLayerDeviceLink*>(&layer.device_link);
+
+ // insert layer info
+ device_chain_info_.pNext = info.pNext;
+ info.pNext = &device_chain_info_;
+ }
+
+ if (override_layers_.count()) {
+ info.enabledLayerCount = override_layers_.count();
+ info.ppEnabledLayerNames = override_layers_.names();
+ }
+
+ if (override_extensions_.count()) {
+ info.enabledExtensionCount = override_extensions_.count();
+ info.ppEnabledExtensionNames = override_extensions_.names();
+ }
+}
+
+VkResult LayerChain::create(const VkInstanceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+ VkInstance* instance_out) {
+ // call down the chain
+ PFN_vkCreateInstance create_instance =
+ reinterpret_cast<PFN_vkCreateInstance>(
+ get_instance_proc_addr_(VK_NULL_HANDLE, "vkCreateInstance"));
+ VkInstance instance;
+ VkResult result = create_instance(create_info, allocator, &instance);
+ if (result != VK_SUCCESS)
+ return result;
+
+ // initialize InstanceData
+ InstanceData& data = GetData(instance);
+ memset(&data, 0, sizeof(data));
+
+ data.instance = instance;
+
+ if (!InitDispatchTable(instance, get_instance_proc_addr_)) {
+ if (data.dispatch.DestroyInstance)
+ data.dispatch.DestroyInstance(instance, allocator);
+
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ // install debug report callback
+ if (override_extensions_.install_debug_callback()) {
+ PFN_vkCreateDebugReportCallbackEXT create_debug_report_callback =
+ reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(
+ get_instance_proc_addr_(instance,
+ "vkCreateDebugReportCallbackEXT"));
+ data.destroy_debug_callback =
+ reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
+ get_instance_proc_addr_(instance,
+ "vkDestroyDebugReportCallbackEXT"));
+ if (!create_debug_report_callback || !data.destroy_debug_callback) {
+ ALOGE("Broken VK_EXT_debug_report support");
+ data.dispatch.DestroyInstance(instance, allocator);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ VkDebugReportCallbackCreateInfoEXT debug_callback_info = {};
+ debug_callback_info.sType =
+ VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
+ debug_callback_info.flags =
+ VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
+ debug_callback_info.pfnCallback = debug_report_callback;
+
+ VkDebugReportCallbackEXT debug_callback;
+ result = create_debug_report_callback(instance, &debug_callback_info,
+ nullptr, &debug_callback);
+ if (result != VK_SUCCESS) {
+ ALOGE("Failed to install debug report callback");
+ data.dispatch.DestroyInstance(instance, allocator);
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ data.debug_callback = debug_callback;
+
+ ALOGI("Installed debug report callback");
+ }
+
+ steal_layers(data);
+
+ *instance_out = instance;
+
+ return VK_SUCCESS;
+}
+
+VkResult LayerChain::create(VkPhysicalDevice physical_dev,
+ const VkDeviceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+ VkDevice* dev_out) {
+ // call down the chain
+ //
+ // TODO Instance call chain available at
+ // GetData(physical_dev).dispatch.CreateDevice is ignored. Is that
+ // right?
+ VkInstance instance = GetData(physical_dev).instance;
+ PFN_vkCreateDevice create_device = reinterpret_cast<PFN_vkCreateDevice>(
+ get_instance_proc_addr_(instance, "vkCreateDevice"));
+ VkDevice dev;
+ VkResult result = create_device(physical_dev, create_info, allocator, &dev);
+ if (result != VK_SUCCESS)
+ return result;
+
+ // initialize DeviceData
+ DeviceData& data = GetData(dev);
+ memset(&data, 0, sizeof(data));
+
+ if (!InitDispatchTable(dev, get_device_proc_addr_)) {
+ if (data.dispatch.DestroyDevice)
+ data.dispatch.DestroyDevice(dev, allocator);
+
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
+
+ steal_layers(data);
+
+ *dev_out = dev;
+
+ return VK_SUCCESS;
+}
+
+template <typename DataType>
+void LayerChain::steal_layers(DataType& data) {
+ data.layers = layers_;
+ data.layer_count = layer_count_;
+
+ layers_ = nullptr;
+ layer_count_ = 0;
+}
+
+void LayerChain::destroy_layers(ActiveLayer* layers,
+ uint32_t count,
+ const VkAllocationCallbacks& allocator) {
+ for (uint32_t i = 0; i < count; i++)
+ layers[i].ref.~LayerRef();
+
+ allocator.pfnFree(allocator.pUserData, layers);
+}
+
+VkBool32 LayerChain::debug_report_callback(VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT obj_type,
+ uint64_t obj,
+ size_t location,
+ int32_t msg_code,
+ const char* layer_prefix,
+ const char* msg,
+ void* user_data) {
+ int prio;
+
+ if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
+ prio = ANDROID_LOG_ERROR;
+ else if (flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT |
+ VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT))
+ prio = ANDROID_LOG_WARN;
+ else if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
+ prio = ANDROID_LOG_INFO;
+ else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT)
+ prio = ANDROID_LOG_DEBUG;
+ else
+ prio = ANDROID_LOG_UNKNOWN;
+
+ LOG_PRI(prio, LOG_TAG, "[%s] Code %d : %s", layer_prefix, msg_code, msg);
+
+ (void)obj_type;
+ (void)obj;
+ (void)location;
+ (void)user_data;
+
+ return false;
+}
+
+VkResult LayerChain::create_instance(const VkInstanceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+ VkInstance* instance_out) {
+ LayerChain chain(true,
+ (allocator) ? *allocator : driver::GetDefaultAllocator());
+
+ VkResult result = chain.activate_layers(
+ create_info->ppEnabledLayerNames, create_info->enabledLayerCount,
+ create_info->ppEnabledExtensionNames,
+ create_info->enabledExtensionCount);
+ if (result != VK_SUCCESS)
+ return result;
+
+ // use a local create info when the chain is not empty
+ VkInstanceCreateInfo local_create_info;
+ if (!chain.empty()) {
+ local_create_info = *create_info;
+ chain.modify_create_info(local_create_info);
+ create_info = &local_create_info;
+ }
+
+ return chain.create(create_info, allocator, instance_out);
+}
+
+VkResult LayerChain::create_device(VkPhysicalDevice physical_dev,
+ const VkDeviceCreateInfo* create_info,
+ const VkAllocationCallbacks* allocator,
+ VkDevice* dev_out) {
+ LayerChain chain(false, (allocator)
+ ? *allocator
+ : driver::GetData(physical_dev).allocator);
+
+ VkResult result = chain.activate_layers(
+ create_info->ppEnabledLayerNames, create_info->enabledLayerCount,
+ create_info->ppEnabledExtensionNames,
+ create_info->enabledExtensionCount);
+ if (result != VK_SUCCESS)
+ return result;
+
+ // use a local create info when the chain is not empty
+ VkDeviceCreateInfo local_create_info;
+ if (!chain.empty()) {
+ local_create_info = *create_info;
+ chain.modify_create_info(local_create_info);
+ create_info = &local_create_info;
+ }
+
+ return chain.create(physical_dev, create_info, allocator, dev_out);
+}
+
+void LayerChain::destroy_instance(VkInstance instance,
+ const VkAllocationCallbacks* allocator) {
+ InstanceData& data = GetData(instance);
+
+ if (data.debug_callback != VK_NULL_HANDLE)
+ data.destroy_debug_callback(instance, data.debug_callback, allocator);
+
+ ActiveLayer* layers = reinterpret_cast<ActiveLayer*>(data.layers);
+ uint32_t layer_count = data.layer_count;
+
+ VkAllocationCallbacks local_allocator;
+ if (!allocator)
+ local_allocator = driver::GetData(instance).allocator;
+
+ // this also destroys InstanceData
+ data.dispatch.DestroyInstance(instance, allocator);
+
+ destroy_layers(layers, layer_count,
+ (allocator) ? *allocator : local_allocator);
+}
+
+void LayerChain::destroy_device(VkDevice device,
+ const VkAllocationCallbacks* allocator) {
+ DeviceData& data = GetData(device);
+
+ ActiveLayer* layers = reinterpret_cast<ActiveLayer*>(data.layers);
+ uint32_t layer_count = data.layer_count;
+
+ VkAllocationCallbacks local_allocator;
+ if (!allocator)
+ local_allocator = driver::GetData(device).allocator;
+
+ // this also destroys DeviceData
+ data.dispatch.DestroyDevice(device, allocator);
+
+ destroy_layers(layers, layer_count,
+ (allocator) ? *allocator : local_allocator);
+}
+
+// ----------------------------------------------------------------------------
+
+bool EnsureInitialized() {
+ static std::once_flag once_flag;
+ static bool initialized;
+
+ std::call_once(once_flag, []() {
+ if (driver::OpenHAL()) {
+ DiscoverLayers();
+ initialized = true;
+ }
+ });
+
+ return initialized;
+}
+
+} // anonymous namespace
+
+VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance) {
+ if (!EnsureInitialized())
+ return VK_ERROR_INITIALIZATION_FAILED;
+
+ return LayerChain::create_instance(pCreateInfo, pAllocator, pInstance);
+}
+
+void DestroyInstance(VkInstance instance,
+ const VkAllocationCallbacks* pAllocator) {
+ if (instance != VK_NULL_HANDLE)
+ LayerChain::destroy_instance(instance, pAllocator);
+}
+
+VkResult CreateDevice(VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDevice* pDevice) {
+ return LayerChain::create_device(physicalDevice, pCreateInfo, pAllocator,
+ pDevice);
+}
+
+void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
+ if (device != VK_NULL_HANDLE)
+ LayerChain::destroy_device(device, pAllocator);
+}
+
+VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties) {
+ if (!EnsureInitialized())
+ return VK_ERROR_INITIALIZATION_FAILED;
+
+ uint32_t count =
+ EnumerateInstanceLayers(pProperties ? *pPropertyCount : 0, pProperties);
+
+ if (!pProperties || *pPropertyCount > count)
+ *pPropertyCount = count;
+
+ return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
+}
+
+VkResult EnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties) {
+ if (!EnsureInitialized())
+ return VK_ERROR_INITIALIZATION_FAILED;
+
+ if (pLayerName) {
+ const VkExtensionProperties* props;
+ uint32_t count;
+ GetInstanceLayerExtensions(pLayerName, &props, &count);
+
+ if (!pProperties || *pPropertyCount > count)
+ *pPropertyCount = count;
+ if (pProperties)
+ std::copy(props, props + *pPropertyCount, pProperties);
+
+ return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
+ }
+
+ // TODO how about extensions from implicitly enabled layers?
+ return vulkan::driver::EnumerateInstanceExtensionProperties(
+ nullptr, pPropertyCount, pProperties);
+}
+
+VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties) {
+ (void)physicalDevice;
+
+ uint32_t count =
+ EnumerateDeviceLayers(pProperties ? *pPropertyCount : 0, pProperties);
+
+ if (!pProperties || *pPropertyCount > count)
+ *pPropertyCount = count;
+
+ return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
+}
+
+VkResult EnumerateDeviceExtensionProperties(
+ VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties) {
+ if (pLayerName) {
+ const VkExtensionProperties* props;
+ uint32_t count;
+ GetDeviceLayerExtensions(pLayerName, &props, &count);
+
+ if (!pProperties || *pPropertyCount > count)
+ *pPropertyCount = count;
+ if (pProperties)
+ std::copy(props, props + *pPropertyCount, pProperties);
+
+ return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
+ }
+
+ // TODO how about extensions from implicitly enabled layers?
+ const InstanceData& data = GetData(physicalDevice);
+ return data.dispatch.EnumerateDeviceExtensionProperties(
+ physicalDevice, nullptr, pPropertyCount, pProperties);
+}
+
+} // namespace api
+} // namespace vulkan
--- /dev/null
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIBVULKAN_API_H
+#define LIBVULKAN_API_H 1
+
+#include <vulkan/vulkan.h>
+#include "api_gen.h"
+#include "driver.h"
+
+namespace vulkan {
+namespace api {
+
+// clang-format off
+VKAPI_ATTR VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+VKAPI_ATTR void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
+VKAPI_ATTR void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+VKAPI_ATTR VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+// clang-format on
+
+inline InstanceData& GetData(VkInstance instance) {
+ return driver::GetData(instance).opaque_api_data;
+}
+
+inline InstanceData& GetData(VkPhysicalDevice physical_dev) {
+ return driver::GetData(physical_dev).opaque_api_data;
+}
+
+inline DeviceData& GetData(VkDevice dev) {
+ return driver::GetData(dev).opaque_api_data;
+}
+
+inline DeviceData& GetData(VkQueue queue) {
+ return driver::GetData(queue).opaque_api_data;
+}
+
+inline DeviceData& GetData(VkCommandBuffer cmd) {
+ return driver::GetData(cmd).opaque_api_data;
+}
+
+} // namespace api
+} // namespace vulkan
+
+#endif // LIBVULKAN_API_H
--- /dev/null
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// WARNING: This file is generated. See ../README.md for instructions.
+
+#include <string.h>
+#include <algorithm>
+#include <log/log.h>
+
+#include "api.h"
+
+namespace vulkan {
+namespace api {
+
+#define UNLIKELY(expr) __builtin_expect((expr), 0)
+
+#define INIT_PROC(obj, proc) \
+ do { \
+ data.dispatch.proc = \
+ reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \
+ if (UNLIKELY(!data.dispatch.proc)) { \
+ ALOGE("missing " #obj " proc: vk" #proc); \
+ success = false; \
+ } \
+ } while (0)
+
+// TODO do we want to point to a stub or nullptr when ext is not enabled?
+#define INIT_PROC_EXT(ext, obj, proc) \
+ do { \
+ INIT_PROC(obj, proc); \
+ } while (0)
+
+bool InitDispatchTable(VkInstance instance,
+ PFN_vkGetInstanceProcAddr get_proc) {
+ auto& data = GetData(instance);
+ bool success = true;
+
+ // clang-format off
+ INIT_PROC(instance, DestroyInstance);
+ INIT_PROC(instance, EnumeratePhysicalDevices);
+ INIT_PROC(instance, GetInstanceProcAddr);
+ INIT_PROC(instance, GetPhysicalDeviceProperties);
+ INIT_PROC(instance, GetPhysicalDeviceQueueFamilyProperties);
+ INIT_PROC(instance, GetPhysicalDeviceMemoryProperties);
+ INIT_PROC(instance, GetPhysicalDeviceFeatures);
+ INIT_PROC(instance, GetPhysicalDeviceFormatProperties);
+ INIT_PROC(instance, GetPhysicalDeviceImageFormatProperties);
+ INIT_PROC(instance, CreateDevice);
+ INIT_PROC(instance, EnumerateDeviceLayerProperties);
+ INIT_PROC(instance, EnumerateDeviceExtensionProperties);
+ INIT_PROC(instance, GetPhysicalDeviceSparseImageFormatProperties);
+ INIT_PROC_EXT(KHR_surface, instance, DestroySurfaceKHR);
+ INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceSupportKHR);
+ INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceCapabilitiesKHR);
+ INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceFormatsKHR);
+ INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfacePresentModesKHR);
+ INIT_PROC_EXT(KHR_android_surface, instance, CreateAndroidSurfaceKHR);
+ // clang-format on
+
+ return success;
+}
+
+bool InitDispatchTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc) {
+ auto& data = GetData(dev);
+ bool success = true;
+
+ // clang-format off
+ INIT_PROC(dev, GetDeviceProcAddr);
+ INIT_PROC(dev, DestroyDevice);
+ INIT_PROC(dev, GetDeviceQueue);
+ INIT_PROC(dev, QueueSubmit);
+ INIT_PROC(dev, QueueWaitIdle);
+ INIT_PROC(dev, DeviceWaitIdle);
+ INIT_PROC(dev, AllocateMemory);
+ INIT_PROC(dev, FreeMemory);
+ INIT_PROC(dev, MapMemory);
+ INIT_PROC(dev, UnmapMemory);
+ INIT_PROC(dev, FlushMappedMemoryRanges);
+ INIT_PROC(dev, InvalidateMappedMemoryRanges);
+ INIT_PROC(dev, GetDeviceMemoryCommitment);
+ INIT_PROC(dev, GetBufferMemoryRequirements);
+ INIT_PROC(dev, BindBufferMemory);
+ INIT_PROC(dev, GetImageMemoryRequirements);
+ INIT_PROC(dev, BindImageMemory);
+ INIT_PROC(dev, GetImageSparseMemoryRequirements);
+ INIT_PROC(dev, QueueBindSparse);
+ INIT_PROC(dev, CreateFence);
+ INIT_PROC(dev, DestroyFence);
+ INIT_PROC(dev, ResetFences);
+ INIT_PROC(dev, GetFenceStatus);
+ INIT_PROC(dev, WaitForFences);
+ INIT_PROC(dev, CreateSemaphore);
+ INIT_PROC(dev, DestroySemaphore);
+ INIT_PROC(dev, CreateEvent);
+ INIT_PROC(dev, DestroyEvent);
+ INIT_PROC(dev, GetEventStatus);
+ INIT_PROC(dev, SetEvent);
+ INIT_PROC(dev, ResetEvent);
+ INIT_PROC(dev, CreateQueryPool);
+ INIT_PROC(dev, DestroyQueryPool);
+ INIT_PROC(dev, GetQueryPoolResults);
+ INIT_PROC(dev, CreateBuffer);
+ INIT_PROC(dev, DestroyBuffer);
+ INIT_PROC(dev, CreateBufferView);
+ INIT_PROC(dev, DestroyBufferView);
+ INIT_PROC(dev, CreateImage);
+ INIT_PROC(dev, DestroyImage);
+ INIT_PROC(dev, GetImageSubresourceLayout);
+ INIT_PROC(dev, CreateImageView);
+ INIT_PROC(dev, DestroyImageView);
+ INIT_PROC(dev, CreateShaderModule);
+ INIT_PROC(dev, DestroyShaderModule);
+ INIT_PROC(dev, CreatePipelineCache);
+ INIT_PROC(dev, DestroyPipelineCache);
+ INIT_PROC(dev, GetPipelineCacheData);
+ INIT_PROC(dev, MergePipelineCaches);
+ INIT_PROC(dev, CreateGraphicsPipelines);
+ INIT_PROC(dev, CreateComputePipelines);
+ INIT_PROC(dev, DestroyPipeline);
+ INIT_PROC(dev, CreatePipelineLayout);
+ INIT_PROC(dev, DestroyPipelineLayout);
+ INIT_PROC(dev, CreateSampler);
+ INIT_PROC(dev, DestroySampler);
+ INIT_PROC(dev, CreateDescriptorSetLayout);
+ INIT_PROC(dev, DestroyDescriptorSetLayout);
+ INIT_PROC(dev, CreateDescriptorPool);
+ INIT_PROC(dev, DestroyDescriptorPool);
+ INIT_PROC(dev, ResetDescriptorPool);
+ INIT_PROC(dev, AllocateDescriptorSets);
+ INIT_PROC(dev, FreeDescriptorSets);
+ INIT_PROC(dev, UpdateDescriptorSets);
+ INIT_PROC(dev, CreateFramebuffer);
+ INIT_PROC(dev, DestroyFramebuffer);
+ INIT_PROC(dev, CreateRenderPass);
+ INIT_PROC(dev, DestroyRenderPass);
+ INIT_PROC(dev, GetRenderAreaGranularity);
+ INIT_PROC(dev, CreateCommandPool);
+ INIT_PROC(dev, DestroyCommandPool);
+ INIT_PROC(dev, ResetCommandPool);
+ INIT_PROC(dev, AllocateCommandBuffers);
+ INIT_PROC(dev, FreeCommandBuffers);
+ INIT_PROC(dev, BeginCommandBuffer);
+ INIT_PROC(dev, EndCommandBuffer);
+ INIT_PROC(dev, ResetCommandBuffer);
+ INIT_PROC(dev, CmdBindPipeline);
+ INIT_PROC(dev, CmdSetViewport);
+ INIT_PROC(dev, CmdSetScissor);
+ INIT_PROC(dev, CmdSetLineWidth);
+ INIT_PROC(dev, CmdSetDepthBias);
+ INIT_PROC(dev, CmdSetBlendConstants);
+ INIT_PROC(dev, CmdSetDepthBounds);
+ INIT_PROC(dev, CmdSetStencilCompareMask);
+ INIT_PROC(dev, CmdSetStencilWriteMask);
+ INIT_PROC(dev, CmdSetStencilReference);
+ INIT_PROC(dev, CmdBindDescriptorSets);
+ INIT_PROC(dev, CmdBindIndexBuffer);
+ INIT_PROC(dev, CmdBindVertexBuffers);
+ INIT_PROC(dev, CmdDraw);
+ INIT_PROC(dev, CmdDrawIndexed);
+ INIT_PROC(dev, CmdDrawIndirect);
+ INIT_PROC(dev, CmdDrawIndexedIndirect);
+ INIT_PROC(dev, CmdDispatch);
+ INIT_PROC(dev, CmdDispatchIndirect);
+ INIT_PROC(dev, CmdCopyBuffer);
+ INIT_PROC(dev, CmdCopyImage);
+ INIT_PROC(dev, CmdBlitImage);
+ INIT_PROC(dev, CmdCopyBufferToImage);
+ INIT_PROC(dev, CmdCopyImageToBuffer);
+ INIT_PROC(dev, CmdUpdateBuffer);
+ INIT_PROC(dev, CmdFillBuffer);
+ INIT_PROC(dev, CmdClearColorImage);
+ INIT_PROC(dev, CmdClearDepthStencilImage);
+ INIT_PROC(dev, CmdClearAttachments);
+ INIT_PROC(dev, CmdResolveImage);
+ INIT_PROC(dev, CmdSetEvent);
+ INIT_PROC(dev, CmdResetEvent);
+ INIT_PROC(dev, CmdWaitEvents);
+ INIT_PROC(dev, CmdPipelineBarrier);
+ INIT_PROC(dev, CmdBeginQuery);
+ INIT_PROC(dev, CmdEndQuery);
+ INIT_PROC(dev, CmdResetQueryPool);
+ INIT_PROC(dev, CmdWriteTimestamp);
+ INIT_PROC(dev, CmdCopyQueryPoolResults);
+ INIT_PROC(dev, CmdPushConstants);
+ INIT_PROC(dev, CmdBeginRenderPass);
+ INIT_PROC(dev, CmdNextSubpass);
+ INIT_PROC(dev, CmdEndRenderPass);
+ INIT_PROC(dev, CmdExecuteCommands);
+ INIT_PROC_EXT(KHR_swapchain, dev, CreateSwapchainKHR);
+ INIT_PROC_EXT(KHR_swapchain, dev, DestroySwapchainKHR);
+ INIT_PROC_EXT(KHR_swapchain, dev, GetSwapchainImagesKHR);
+ INIT_PROC_EXT(KHR_swapchain, dev, AcquireNextImageKHR);
+ INIT_PROC_EXT(KHR_swapchain, dev, QueuePresentKHR);
+ // clang-format on
+
+ return success;
+}
+
+} // namespace api
+} // namespace vulkan
+
+// clang-format off
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
+ // call into api.cpp
+ return vulkan::api::CreateInstance(pCreateInfo, pAllocator, pInstance);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
+ // call into api.cpp
+ vulkan::api::DestroyInstance(instance, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
+ return vulkan::api::GetData(instance).dispatch.EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) {
+ if (device == VK_NULL_HANDLE) {
+ ALOGE("vkGetDeviceProcAddr called with invalid device");
+ return nullptr;
+ }
+
+ static const char* const known_non_device_names[] = {
+ "vkCreateAndroidSurfaceKHR",
+ "vkCreateDebugReportCallbackEXT",
+ "vkCreateDevice",
+ "vkCreateInstance",
+ "vkDebugReportMessageEXT",
+ "vkDestroyDebugReportCallbackEXT",
+ "vkDestroyInstance",
+ "vkDestroySurfaceKHR",
+ "vkEnumerateDeviceExtensionProperties",
+ "vkEnumerateDeviceLayerProperties",
+ "vkEnumerateInstanceExtensionProperties",
+ "vkEnumerateInstanceLayerProperties",
+ "vkEnumeratePhysicalDevices",
+ "vkGetInstanceProcAddr",
+ "vkGetPhysicalDeviceFeatures",
+ "vkGetPhysicalDeviceFormatProperties",
+ "vkGetPhysicalDeviceImageFormatProperties",
+ "vkGetPhysicalDeviceMemoryProperties",
+ "vkGetPhysicalDeviceProperties",
+ "vkGetPhysicalDeviceQueueFamilyProperties",
+ "vkGetPhysicalDeviceSparseImageFormatProperties",
+ "vkGetPhysicalDeviceSurfaceCapabilitiesKHR",
+ "vkGetPhysicalDeviceSurfaceFormatsKHR",
+ "vkGetPhysicalDeviceSurfacePresentModesKHR",
+ "vkGetPhysicalDeviceSurfaceSupportKHR",
+ };
+ // clang-format on
+ constexpr size_t count =
+ sizeof(known_non_device_names) / sizeof(known_non_device_names[0]);
+ if (!pName ||
+ std::binary_search(
+ known_non_device_names, known_non_device_names + count, pName,
+ [](const char* a, const char* b) { return (strcmp(a, b) < 0); })) {
+ ALOGE("vkGetDeviceProcAddr called with %s", pName);
+ return nullptr;
+ }
+ // clang-format off
+
+ return vulkan::api::GetData(device).dispatch.GetDeviceProcAddr(device, pName);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
+ // global functions
+ if (!instance) {
+ if (strcmp(pName, "vkCreateInstance") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::CreateInstance);
+ if (strcmp(pName, "vkEnumerateInstanceLayerProperties") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateInstanceLayerProperties);
+ if (strcmp(pName, "vkEnumerateInstanceExtensionProperties") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateInstanceExtensionProperties);
+
+ ALOGE("vkGetInstanceProcAddr called with %s without instance", pName);
+ return nullptr;
+ }
+
+ static const struct Hook {
+ const char* name;
+ PFN_vkVoidFunction proc;
+ } hooks[] = {
+ { "vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR) },
+ { "vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateCommandBuffers) },
+ { "vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateDescriptorSets) },
+ { "vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateMemory) },
+ { "vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer) },
+ { "vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory) },
+ { "vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory) },
+ { "vkCmdBeginQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQuery) },
+ { "vkCmdBeginRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass) },
+ { "vkCmdBindDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets) },
+ { "vkCmdBindIndexBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer) },
+ { "vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipeline) },
+ { "vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers) },
+ { "vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage) },
+ { "vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearAttachments) },
+ { "vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorImage) },
+ { "vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilImage) },
+ { "vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer) },
+ { "vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage) },
+ { "vkCmdCopyImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage) },
+ { "vkCmdCopyImageToBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer) },
+ { "vkCmdCopyQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyQueryPoolResults) },
+ { "vkCmdDispatch", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatch) },
+ { "vkCmdDispatchIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchIndirect) },
+ { "vkCmdDraw", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDraw) },
+ { "vkCmdDrawIndexed", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexed) },
+ { "vkCmdDrawIndexedIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirect) },
+ { "vkCmdDrawIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirect) },
+ { "vkCmdEndQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQuery) },
+ { "vkCmdEndRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass) },
+ { "vkCmdExecuteCommands", reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteCommands) },
+ { "vkCmdFillBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdFillBuffer) },
+ { "vkCmdNextSubpass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass) },
+ { "vkCmdPipelineBarrier", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier) },
+ { "vkCmdPushConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants) },
+ { "vkCmdResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent) },
+ { "vkCmdResetQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetQueryPool) },
+ { "vkCmdResolveImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage) },
+ { "vkCmdSetBlendConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetBlendConstants) },
+ { "vkCmdSetDepthBias", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias) },
+ { "vkCmdSetDepthBounds", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBounds) },
+ { "vkCmdSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent) },
+ { "vkCmdSetLineWidth", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineWidth) },
+ { "vkCmdSetScissor", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissor) },
+ { "vkCmdSetStencilCompareMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilCompareMask) },
+ { "vkCmdSetStencilReference", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilReference) },
+ { "vkCmdSetStencilWriteMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilWriteMask) },
+ { "vkCmdSetViewport", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewport) },
+ { "vkCmdUpdateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdateBuffer) },
+ { "vkCmdWaitEvents", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents) },
+ { "vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp) },
+ { "vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBuffer) },
+ { "vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferView) },
+ { "vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandPool) },
+ { "vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateComputePipelines) },
+ { "vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorPool) },
+ { "vkCreateDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorSetLayout) },
+ { "vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::CreateDevice) },
+ { "vkCreateEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCreateEvent) },
+ { "vkCreateFence", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFence) },
+ { "vkCreateFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFramebuffer) },
+ { "vkCreateGraphicsPipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateGraphicsPipelines) },
+ { "vkCreateImage", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImage) },
+ { "vkCreateImageView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImageView) },
+ { "vkCreateInstance", nullptr },
+ { "vkCreatePipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineCache) },
+ { "vkCreatePipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineLayout) },
+ { "vkCreateQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateQueryPool) },
+ { "vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass) },
+ { "vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSampler) },
+ { "vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore) },
+ { "vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule) },
+ { "vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR) },
+ { "vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer) },
+ { "vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView) },
+ { "vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandPool) },
+ { "vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorPool) },
+ { "vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorSetLayout) },
+ { "vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::DestroyDevice) },
+ { "vkDestroyEvent", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyEvent) },
+ { "vkDestroyFence", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFence) },
+ { "vkDestroyFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFramebuffer) },
+ { "vkDestroyImage", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImage) },
+ { "vkDestroyImageView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImageView) },
+ { "vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::DestroyInstance) },
+ { "vkDestroyPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipeline) },
+ { "vkDestroyPipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineCache) },
+ { "vkDestroyPipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineLayout) },
+ { "vkDestroyQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyQueryPool) },
+ { "vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyRenderPass) },
+ { "vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySampler) },
+ { "vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore) },
+ { "vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule) },
+ { "vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR) },
+ { "vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle) },
+ { "vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkEndCommandBuffer) },
+ { "vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateDeviceExtensionProperties) },
+ { "vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateDeviceLayerProperties) },
+ { "vkEnumerateInstanceExtensionProperties", nullptr },
+ { "vkEnumerateInstanceLayerProperties", nullptr },
+ { "vkFlushMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkFlushMappedMemoryRanges) },
+ { "vkFreeCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkFreeCommandBuffers) },
+ { "vkFreeDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkFreeDescriptorSets) },
+ { "vkFreeMemory", reinterpret_cast<PFN_vkVoidFunction>(vkFreeMemory) },
+ { "vkGetBufferMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements) },
+ { "vkGetDeviceMemoryCommitment", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryCommitment) },
+ { "vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr) },
+ { "vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue) },
+ { "vkGetEventStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetEventStatus) },
+ { "vkGetFenceStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceStatus) },
+ { "vkGetImageMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements) },
+ { "vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements) },
+ { "vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout) },
+ { "vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetInstanceProcAddr) },
+ { "vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData) },
+ { "vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults) },
+ { "vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity) },
+ { "vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR) },
+ { "vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges) },
+ { "vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory) },
+ { "vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches) },
+ { "vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparse) },
+ { "vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR) },
+ { "vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit) },
+ { "vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle) },
+ { "vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandBuffer) },
+ { "vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandPool) },
+ { "vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetDescriptorPool) },
+ { "vkResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkResetEvent) },
+ { "vkResetFences", reinterpret_cast<PFN_vkVoidFunction>(vkResetFences) },
+ { "vkSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkSetEvent) },
+ { "vkUnmapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory) },
+ { "vkUpdateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSets) },
+ { "vkWaitForFences", reinterpret_cast<PFN_vkVoidFunction>(vkWaitForFences) },
+ };
+ // clang-format on
+ constexpr size_t count = sizeof(hooks) / sizeof(hooks[0]);
+ auto hook = std::lower_bound(
+ hooks, hooks + count, pName,
+ [](const Hook& h, const char* n) { return strcmp(h.name, n) < 0; });
+ if (hook < hooks + count && strcmp(hook->name, pName) == 0) {
+ if (!hook->proc)
+ ALOGE("vkGetInstanceProcAddr called with %s with instance", pName);
+ return hook->proc;
+ }
+ // clang-format off
+
+ return vulkan::api::GetData(instance).dispatch.GetInstanceProcAddr(instance, pName);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
+ vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceProperties(physicalDevice, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+ vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
+ vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+ vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+ vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+ return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
+ // call into api.cpp
+ return vulkan::api::CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
+ // call into api.cpp
+ vulkan::api::DestroyDevice(device, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+ // call into api.cpp
+ return vulkan::api::EnumerateInstanceLayerProperties(pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+ // call into api.cpp
+ return vulkan::api::EnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+ // call into api.cpp
+ return vulkan::api::EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+ // call into api.cpp
+ return vulkan::api::EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
+ vulkan::api::GetData(device).dispatch.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
+ return vulkan::api::GetData(queue).dispatch.QueueSubmit(queue, submitCount, pSubmits, fence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueueWaitIdle(VkQueue queue) {
+ return vulkan::api::GetData(queue).dispatch.QueueWaitIdle(queue);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkDeviceWaitIdle(VkDevice device) {
+ return vulkan::api::GetData(device).dispatch.DeviceWaitIdle(device);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
+ return vulkan::api::GetData(device).dispatch.AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.FreeMemory(device, memory, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
+ return vulkan::api::GetData(device).dispatch.MapMemory(device, memory, offset, size, flags, ppData);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
+ vulkan::api::GetData(device).dispatch.UnmapMemory(device, memory);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+ return vulkan::api::GetData(device).dispatch.FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+ return vulkan::api::GetData(device).dispatch.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+ vulkan::api::GetData(device).dispatch.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
+ vulkan::api::GetData(device).dispatch.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+ return vulkan::api::GetData(device).dispatch.BindBufferMemory(device, buffer, memory, memoryOffset);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
+ vulkan::api::GetData(device).dispatch.GetImageMemoryRequirements(device, image, pMemoryRequirements);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+ return vulkan::api::GetData(device).dispatch.BindImageMemory(device, image, memory, memoryOffset);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+ vulkan::api::GetData(device).dispatch.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
+ vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
+ return vulkan::api::GetData(queue).dispatch.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+ return vulkan::api::GetData(device).dispatch.CreateFence(device, pCreateInfo, pAllocator, pFence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyFence(device, fence, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+ return vulkan::api::GetData(device).dispatch.ResetFences(device, fenceCount, pFences);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
+ return vulkan::api::GetData(device).dispatch.GetFenceStatus(device, fence);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
+ return vulkan::api::GetData(device).dispatch.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
+ return vulkan::api::GetData(device).dispatch.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroySemaphore(device, semaphore, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
+ return vulkan::api::GetData(device).dispatch.CreateEvent(device, pCreateInfo, pAllocator, pEvent);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyEvent(device, event, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetEventStatus(VkDevice device, VkEvent event) {
+ return vulkan::api::GetData(device).dispatch.GetEventStatus(device, event);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkSetEvent(VkDevice device, VkEvent event) {
+ return vulkan::api::GetData(device).dispatch.SetEvent(device, event);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetEvent(VkDevice device, VkEvent event) {
+ return vulkan::api::GetData(device).dispatch.ResetEvent(device, event);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
+ return vulkan::api::GetData(device).dispatch.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyQueryPool(device, queryPool, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
+ return vulkan::api::GetData(device).dispatch.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+ return vulkan::api::GetData(device).dispatch.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyBuffer(device, buffer, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
+ return vulkan::api::GetData(device).dispatch.CreateBufferView(device, pCreateInfo, pAllocator, pView);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyBufferView(device, bufferView, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+ return vulkan::api::GetData(device).dispatch.CreateImage(device, pCreateInfo, pAllocator, pImage);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyImage(device, image, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+ vulkan::api::GetData(device).dispatch.GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
+ return vulkan::api::GetData(device).dispatch.CreateImageView(device, pCreateInfo, pAllocator, pView);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyImageView(device, imageView, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
+ return vulkan::api::GetData(device).dispatch.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyShaderModule(device, shaderModule, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
+ return vulkan::api::GetData(device).dispatch.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyPipelineCache(device, pipelineCache, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
+ return vulkan::api::GetData(device).dispatch.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
+ return vulkan::api::GetData(device).dispatch.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+ return vulkan::api::GetData(device).dispatch.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+ return vulkan::api::GetData(device).dispatch.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyPipeline(device, pipeline, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
+ return vulkan::api::GetData(device).dispatch.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyPipelineLayout(device, pipelineLayout, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
+ return vulkan::api::GetData(device).dispatch.CreateSampler(device, pCreateInfo, pAllocator, pSampler);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroySampler(device, sampler, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+ return vulkan::api::GetData(device).dispatch.CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
+ return vulkan::api::GetData(device).dispatch.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyDescriptorPool(device, descriptorPool, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
+ return vulkan::api::GetData(device).dispatch.ResetDescriptorPool(device, descriptorPool, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
+ return vulkan::api::GetData(device).dispatch.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
+ return vulkan::api::GetData(device).dispatch.FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
+ vulkan::api::GetData(device).dispatch.UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
+ return vulkan::api::GetData(device).dispatch.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyFramebuffer(device, framebuffer, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+ return vulkan::api::GetData(device).dispatch.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyRenderPass(device, renderPass, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+ vulkan::api::GetData(device).dispatch.GetRenderAreaGranularity(device, renderPass, pGranularity);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
+ return vulkan::api::GetData(device).dispatch.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroyCommandPool(device, commandPool, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
+ return vulkan::api::GetData(device).dispatch.ResetCommandPool(device, commandPool, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
+ return vulkan::api::GetData(device).dispatch.AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+ vulkan::api::GetData(device).dispatch.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
+ return vulkan::api::GetData(commandBuffer).dispatch.BeginCommandBuffer(commandBuffer, pBeginInfo);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+ return vulkan::api::GetData(commandBuffer).dispatch.EndCommandBuffer(commandBuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
+ return vulkan::api::GetData(commandBuffer).dispatch.ResetCommandBuffer(commandBuffer, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdSetLineWidth(commandBuffer, lineWidth);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdSetBlendConstants(commandBuffer, blendConstants);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdSetStencilReference(commandBuffer, faceMask, reference);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdDispatch(commandBuffer, x, y, z);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdDispatchIndirect(commandBuffer, buffer, offset);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdSetEvent(commandBuffer, event, stageMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdResetEvent(commandBuffer, event, stageMask);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdBeginQuery(commandBuffer, queryPool, query, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdEndQuery(commandBuffer, queryPool, query);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdNextSubpass(commandBuffer, contents);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdEndRenderPass(commandBuffer);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+ vulkan::api::GetData(commandBuffer).dispatch.CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(instance).dispatch.DestroySurfaceKHR(instance, surface, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
+ return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
+ return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+ return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
+ return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
+ return vulkan::api::GetData(device).dispatch.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
+ vulkan::api::GetData(device).dispatch.DestroySwapchainKHR(device, swapchain, pAllocator);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
+ return vulkan::api::GetData(device).dispatch.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
+ return vulkan::api::GetData(device).dispatch.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
+ return vulkan::api::GetData(queue).dispatch.QueuePresentKHR(queue, pPresentInfo);
+}
+
+__attribute__((visibility("default")))
+VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+ return vulkan::api::GetData(instance).dispatch.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
+}
+
+// clang-format on
--- /dev/null
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// WARNING: This file is generated. See ../README.md for instructions.
+
+#ifndef LIBVULKAN_API_GEN_H
+#define LIBVULKAN_API_GEN_H
+
+#include <vulkan/vulkan.h>
+
+namespace vulkan {
+namespace api {
+
+struct InstanceDispatchTable {
+ // clang-format off
+ PFN_vkDestroyInstance DestroyInstance;
+ PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
+ PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
+ PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
+ PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
+ PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
+ PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
+ PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
+ PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
+ PFN_vkCreateDevice CreateDevice;
+ PFN_vkEnumerateDeviceLayerProperties EnumerateDeviceLayerProperties;
+ PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
+ PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
+ PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
+ PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
+ PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
+ PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
+ PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
+ PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
+ // clang-format on
+};
+
+struct DeviceDispatchTable {
+ // clang-format off
+ PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
+ PFN_vkDestroyDevice DestroyDevice;
+ PFN_vkGetDeviceQueue GetDeviceQueue;
+ PFN_vkQueueSubmit QueueSubmit;
+ PFN_vkQueueWaitIdle QueueWaitIdle;
+ PFN_vkDeviceWaitIdle DeviceWaitIdle;
+ PFN_vkAllocateMemory AllocateMemory;
+ PFN_vkFreeMemory FreeMemory;
+ PFN_vkMapMemory MapMemory;
+ PFN_vkUnmapMemory UnmapMemory;
+ PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges;
+ PFN_vkInvalidateMappedMemoryRanges InvalidateMappedMemoryRanges;
+ PFN_vkGetDeviceMemoryCommitment GetDeviceMemoryCommitment;
+ PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements;
+ PFN_vkBindBufferMemory BindBufferMemory;
+ PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements;
+ PFN_vkBindImageMemory BindImageMemory;
+ PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements;
+ PFN_vkQueueBindSparse QueueBindSparse;
+ PFN_vkCreateFence CreateFence;
+ PFN_vkDestroyFence DestroyFence;
+ PFN_vkResetFences ResetFences;
+ PFN_vkGetFenceStatus GetFenceStatus;
+ PFN_vkWaitForFences WaitForFences;
+ PFN_vkCreateSemaphore CreateSemaphore;
+ PFN_vkDestroySemaphore DestroySemaphore;
+ PFN_vkCreateEvent CreateEvent;
+ PFN_vkDestroyEvent DestroyEvent;
+ PFN_vkGetEventStatus GetEventStatus;
+ PFN_vkSetEvent SetEvent;
+ PFN_vkResetEvent ResetEvent;
+ PFN_vkCreateQueryPool CreateQueryPool;
+ PFN_vkDestroyQueryPool DestroyQueryPool;
+ PFN_vkGetQueryPoolResults GetQueryPoolResults;
+ PFN_vkCreateBuffer CreateBuffer;
+ PFN_vkDestroyBuffer DestroyBuffer;
+ PFN_vkCreateBufferView CreateBufferView;
+ PFN_vkDestroyBufferView DestroyBufferView;
+ PFN_vkCreateImage CreateImage;
+ PFN_vkDestroyImage DestroyImage;
+ PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout;
+ PFN_vkCreateImageView CreateImageView;
+ PFN_vkDestroyImageView DestroyImageView;
+ PFN_vkCreateShaderModule CreateShaderModule;
+ PFN_vkDestroyShaderModule DestroyShaderModule;
+ PFN_vkCreatePipelineCache CreatePipelineCache;
+ PFN_vkDestroyPipelineCache DestroyPipelineCache;
+ PFN_vkGetPipelineCacheData GetPipelineCacheData;
+ PFN_vkMergePipelineCaches MergePipelineCaches;
+ PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines;
+ PFN_vkCreateComputePipelines CreateComputePipelines;
+ PFN_vkDestroyPipeline DestroyPipeline;
+ PFN_vkCreatePipelineLayout CreatePipelineLayout;
+ PFN_vkDestroyPipelineLayout DestroyPipelineLayout;
+ PFN_vkCreateSampler CreateSampler;
+ PFN_vkDestroySampler DestroySampler;
+ PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout;
+ PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout;
+ PFN_vkCreateDescriptorPool CreateDescriptorPool;
+ PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
+ PFN_vkResetDescriptorPool ResetDescriptorPool;
+ PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
+ PFN_vkFreeDescriptorSets FreeDescriptorSets;
+ PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
+ PFN_vkCreateFramebuffer CreateFramebuffer;
+ PFN_vkDestroyFramebuffer DestroyFramebuffer;
+ PFN_vkCreateRenderPass CreateRenderPass;
+ PFN_vkDestroyRenderPass DestroyRenderPass;
+ PFN_vkGetRenderAreaGranularity GetRenderAreaGranularity;
+ PFN_vkCreateCommandPool CreateCommandPool;
+ PFN_vkDestroyCommandPool DestroyCommandPool;
+ PFN_vkResetCommandPool ResetCommandPool;
+ PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
+ PFN_vkFreeCommandBuffers FreeCommandBuffers;
+ PFN_vkBeginCommandBuffer BeginCommandBuffer;
+ PFN_vkEndCommandBuffer EndCommandBuffer;
+ PFN_vkResetCommandBuffer ResetCommandBuffer;
+ PFN_vkCmdBindPipeline CmdBindPipeline;
+ PFN_vkCmdSetViewport CmdSetViewport;
+ PFN_vkCmdSetScissor CmdSetScissor;
+ PFN_vkCmdSetLineWidth CmdSetLineWidth;
+ PFN_vkCmdSetDepthBias CmdSetDepthBias;
+ PFN_vkCmdSetBlendConstants CmdSetBlendConstants;
+ PFN_vkCmdSetDepthBounds CmdSetDepthBounds;
+ PFN_vkCmdSetStencilCompareMask CmdSetStencilCompareMask;
+ PFN_vkCmdSetStencilWriteMask CmdSetStencilWriteMask;
+ PFN_vkCmdSetStencilReference CmdSetStencilReference;
+ PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
+ PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer;
+ PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers;
+ PFN_vkCmdDraw CmdDraw;
+ PFN_vkCmdDrawIndexed CmdDrawIndexed;
+ PFN_vkCmdDrawIndirect CmdDrawIndirect;
+ PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect;
+ PFN_vkCmdDispatch CmdDispatch;
+ PFN_vkCmdDispatchIndirect CmdDispatchIndirect;
+ PFN_vkCmdCopyBuffer CmdCopyBuffer;
+ PFN_vkCmdCopyImage CmdCopyImage;
+ PFN_vkCmdBlitImage CmdBlitImage;
+ PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage;
+ PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer;
+ PFN_vkCmdUpdateBuffer CmdUpdateBuffer;
+ PFN_vkCmdFillBuffer CmdFillBuffer;
+ PFN_vkCmdClearColorImage CmdClearColorImage;
+ PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage;
+ PFN_vkCmdClearAttachments CmdClearAttachments;
+ PFN_vkCmdResolveImage CmdResolveImage;
+ PFN_vkCmdSetEvent CmdSetEvent;
+ PFN_vkCmdResetEvent CmdResetEvent;
+ PFN_vkCmdWaitEvents CmdWaitEvents;
+ PFN_vkCmdPipelineBarrier CmdPipelineBarrier;
+ PFN_vkCmdBeginQuery CmdBeginQuery;
+ PFN_vkCmdEndQuery CmdEndQuery;
+ PFN_vkCmdResetQueryPool CmdResetQueryPool;
+ PFN_vkCmdWriteTimestamp CmdWriteTimestamp;
+ PFN_vkCmdCopyQueryPoolResults CmdCopyQueryPoolResults;
+ PFN_vkCmdPushConstants CmdPushConstants;
+ PFN_vkCmdBeginRenderPass CmdBeginRenderPass;
+ PFN_vkCmdNextSubpass CmdNextSubpass;
+ PFN_vkCmdEndRenderPass CmdEndRenderPass;
+ PFN_vkCmdExecuteCommands CmdExecuteCommands;
+ PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
+ PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
+ PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
+ PFN_vkAcquireNextImageKHR AcquireNextImageKHR;
+ PFN_vkQueuePresentKHR QueuePresentKHR;
+ // clang-format on
+};
+
+bool InitDispatchTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc);
+bool InitDispatchTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc);
+
+} // namespace api
+} // namespace vulkan
+
+#endif // LIBVULKAN_API_GEN_H
--- /dev/null
+{{define "Copyright"}}
+/*
+•* Copyright 2016 The Android Open Source Project
+•*
+•* Licensed under the Apache License, Version 2.0 (the "License");
+•* you may not use this file except in compliance with the License.
+•* You may obtain a copy of the License at
+•*
+•* http://www.apache.org/licenses/LICENSE-2.0
+•*
+•* Unless required by applicable law or agreed to in writing, software
+•* distributed under the License is distributed on an "AS IS" BASIS,
+•* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+•* See the License for the specific language governing permissions and
+•* limitations under the License.
+•*/
+¶{{end}}
+
+{{Include "../api/templates/vulkan_common.tmpl"}}
+{{Global "clang-format" (Strings "clang-format" "-style=file")}}
+{{Macro "DefineGlobals" $}}
+{{$ | Macro "api_gen.h" | Format (Global "clang-format") | Write "api_gen.h" }}
+{{$ | Macro "api_gen.cpp" | Format (Global "clang-format") | Write "api_gen.cpp"}}
+
+{{/*
+-------------------------------------------------------------------------------
+ api_gen.h
+-------------------------------------------------------------------------------
+*/}}
+{{define "api_gen.h"}}
+{{Macro "Copyright"}}
+¶
+// WARNING: This file is generated. See ../README.md for instructions.
+¶
+#ifndef LIBVULKAN_API_GEN_H
+#define LIBVULKAN_API_GEN_H
+¶
+#include <vulkan/vulkan.h>
+¶
+namespace vulkan {«
+namespace api {«
+¶
+struct InstanceDispatchTable {
+ // clang-format off
+ {{range $f := AllCommands $}}
+ {{if (Macro "api.IsInstanceDispatchTableEntry" $f)}}
+ {{Macro "C++.DeclareDispatchTableEntry" $f}};
+ {{end}}
+ {{end}}
+ // clang-format on
+};
+¶
+struct DeviceDispatchTable {
+ // clang-format off
+ {{range $f := AllCommands $}}
+ {{if (Macro "api.IsDeviceDispatchTableEntry" $f)}}
+ {{Macro "C++.DeclareDispatchTableEntry" $f}};
+ {{end}}
+ {{end}}
+ // clang-format on
+};
+¶
+bool InitDispatchTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc);
+bool InitDispatchTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc);
+¶
+»} // namespace api
+»} // namespace vulkan
+¶
+#endif // LIBVULKAN_API_GEN_H
+¶{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+ api_gen.cpp
+-------------------------------------------------------------------------------
+*/}}
+{{define "api_gen.cpp"}}
+{{Macro "Copyright"}}
+¶
+// WARNING: This file is generated. See ../README.md for instructions.
+¶
+#include <string.h>
+#include <algorithm>
+#include <log/log.h>
+¶
+#include "api.h"
+¶
+namespace vulkan {«
+namespace api {«
+¶
+{{Macro "C++.DefineInitProcMacros" "dispatch"}}
+¶
+bool InitDispatchTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc) {
+ auto& data = GetData(instance);
+ bool success = true;
+ ¶
+ // clang-format off
+ {{range $f := AllCommands $}}
+ {{if (Macro "api.IsInstanceDispatchTableEntry" $f)}}
+ {{Macro "C++.InitProc" $f}}
+ {{end}}
+ {{end}}
+ // clang-format on
+ ¶
+ return success;
+}
+¶
+bool InitDispatchTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc) {
+ auto& data = GetData(dev);
+ bool success = true;
+ ¶
+ // clang-format off
+ {{range $f := AllCommands $}}
+ {{if (Macro "api.IsDeviceDispatchTableEntry" $f)}}
+ {{Macro "C++.InitProc" $f}}
+ {{end}}
+ {{end}}
+ // clang-format on
+ ¶
+ return success;
+}
+¶
+»} // namespace api
+»} // namespace vulkan
+¶
+// clang-format off
+¶
+{{range $f := AllCommands $}}
+ {{if (Macro "IsFunctionExported" $f)}}
+ __attribute__((visibility("default")))
+ VKAPI_ATTR {{Node "Type" $f.Return}} {{$f.Name}}({{Macro "Parameters" $f}}) {
+ {{ if eq $f.Name "vkGetInstanceProcAddr"}}
+ {{Macro "api.C++.InterceptInstanceProcAddr" $}}
+ {{else if eq $f.Name "vkGetDeviceProcAddr"}}
+ {{Macro "api.C++.InterceptDeviceProcAddr" $}}
+ {{end}}
+
+ {{Macro "api.C++.Dispatch" $f}}
+ }
+ ¶
+ {{end}}
+{{end}}
+¶
+// clang-format on
+¶{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emits a declaration of a dispatch table entry.
+------------------------------------------------------------------------------
+*/}}
+{{define "C++.DeclareDispatchTableEntry"}}
+ {{AssertType $ "Function"}}
+
+ {{Macro "FunctionPtrName" $}} {{Macro "BaseName" $}}
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+ Emits macros to help initialize dispatch tables.
+-------------------------------------------------------------------------------
+*/}}
+{{define "C++.DefineInitProcMacros"}}
+ #define UNLIKELY(expr) __builtin_expect((expr), 0)
+ ¶
+ #define INIT_PROC(obj, proc) do { \
+ data.{{$}}.proc = reinterpret_cast<PFN_vk ## proc>( \
+ get_proc(obj, "vk" # proc)); \
+ if (UNLIKELY(!data.{{$}}.proc)) { \
+ ALOGE("missing " # obj " proc: vk" # proc); \
+ success = false; \
+ } \
+ } while(0)
+ ¶
+ // TODO do we want to point to a stub or nullptr when ext is not enabled?
+ #define INIT_PROC_EXT(ext, obj, proc) do { \
+ INIT_PROC(obj, proc); \
+ } while(0)
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+ Emits code to invoke INIT_PROC or INIT_PROC_EXT.
+-------------------------------------------------------------------------------
+*/}}
+{{define "C++.InitProc"}}
+ {{AssertType $ "Function"}}
+
+ {{$ext := GetAnnotation $ "extension"}}
+ {{if $ext}}
+ INIT_PROC_EXT({{Macro "BaseName" $ext}}, §
+ {{else}}
+ INIT_PROC(§
+ {{end}}
+
+ {{if (Macro "IsInstanceDispatched" $)}}
+ instance, §
+ {{else}}
+ dev, §
+ {{end}}
+
+ {{Macro "BaseName" $}});
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emits true if a function is exported and instance-dispatched.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.IsInstanceDispatchTableEntry"}}
+ {{AssertType $ "Function"}}
+
+ {{if and (Macro "IsFunctionExported" $) (Macro "IsInstanceDispatched" $)}}
+ true
+ {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emits true if a function is exported and device-dispatched.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.IsDeviceDispatchTableEntry"}}
+ {{AssertType $ "Function"}}
+
+ {{if and (Macro "IsFunctionExported" $) (Macro "IsDeviceDispatched" $)}}
+ true
+ {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emits true if a function is intercepted by vulkan::api.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.IsIntercepted"}}
+ {{AssertType $ "Function"}}
+
+ {{if (Macro "IsFunctionSupported" $)}}
+ {{/* Global functions cannot be dispatched at all */}}
+ {{ if (Macro "IsGloballyDispatched" $)}}true
+
+ {{/* VkPhysicalDevice functions that manage device layers */}}
+ {{else if eq $.Name "vkCreateDevice"}}true
+ {{else if eq $.Name "vkEnumerateDeviceLayerProperties"}}true
+ {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true
+
+ {{/* Destroy functions of dispatchable objects */}}
+ {{else if eq $.Name "vkDestroyInstance"}}true
+ {{else if eq $.Name "vkDestroyDevice"}}true
+
+ {{end}}
+ {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emits code for vkGetInstanceProcAddr for function interception.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.C++.InterceptInstanceProcAddr"}}
+ {{AssertType $ "API"}}
+
+ // global functions
+ if (!instance) {
+ {{range $f := AllCommands $}}
+ {{if (Macro "IsGloballyDispatched" $f)}}
+ if (strcmp(pName, "{{$f.Name}}") == 0) return §
+ reinterpret_cast<PFN_vkVoidFunction>(§
+ vulkan::api::{{Macro "BaseName" $f}});
+ {{end}}
+ {{end}}
+ ¶
+ ALOGE("vkGetInstanceProcAddr called with %s without instance", pName);
+ return nullptr;
+ }
+ ¶
+ static const struct Hook {
+ const char* name;
+ PFN_vkVoidFunction proc;
+ } hooks[] = {
+ {{range $f := SortBy (AllCommands $) "FunctionName"}}
+ {{if (Macro "IsFunctionExported" $f)}}
+ {{/* hide global functions */}}
+ {{if (Macro "IsGloballyDispatched" $f)}}
+ { "{{$f.Name}}", nullptr },
+
+ {{/* redirect intercepted functions */}}
+ {{else if (Macro "api.IsIntercepted" $f)}}
+ { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
+ vulkan::api::{{Macro "BaseName" $f}}) },
+
+ {{/* redirect vkGetInstanceProcAddr to itself */}}
+ {{else if eq $f.Name "vkGetInstanceProcAddr"}}
+ { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{$f.Name}}) },
+
+ {{/* redirect device functions to themselves as a workaround for
+ layers that do not intercept in their vkGetInstanceProcAddr */}}
+ {{else if (Macro "IsDeviceDispatched" $f)}}
+ { "{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{$f.Name}}) },
+
+ {{end}}
+ {{end}}
+ {{end}}
+ };
+ // clang-format on
+ constexpr size_t count = sizeof(hooks) / sizeof(hooks[0]);
+ auto hook = std::lower_bound(
+ hooks, hooks + count, pName,
+ [](const Hook& h, const char* n) { return strcmp(h.name, n) < 0; });
+ if (hook < hooks + count && strcmp(hook->name, pName) == 0) {
+ if (!hook->proc)
+ ALOGE("vkGetInstanceProcAddr called with %s with instance", pName);
+ return hook->proc;
+ }
+ // clang-format off
+ ¶
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emits code for vkGetDeviceProcAddr for function interception.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.C++.InterceptDeviceProcAddr"}}
+ {{AssertType $ "API"}}
+
+ if (device == VK_NULL_HANDLE) {
+ ALOGE("vkGetDeviceProcAddr called with invalid device");
+ return nullptr;
+ }
+ ¶
+ static const char* const known_non_device_names[] = {
+ {{range $f := SortBy (AllCommands $) "FunctionName"}}
+ {{if (Macro "IsFunctionSupported" $f)}}
+ {{if not (Macro "IsDeviceDispatched" $f)}}
+ "{{$f.Name}}",
+ {{end}}
+ {{end}}
+ {{end}}
+ };
+ // clang-format on
+ constexpr size_t count = sizeof(known_non_device_names) /
+ sizeof(known_non_device_names[0]);
+ if (!pName ||
+ std::binary_search(
+ known_non_device_names, known_non_device_names + count, pName,
+ [](const char* a, const char* b) { return (strcmp(a, b) < 0); })) {
+ ALOGE("vkGetDeviceProcAddr called with %s", pName);
+ return nullptr;
+ }
+ // clang-format off
+ ¶
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emits code to dispatch a function.
+------------------------------------------------------------------------------
+*/}}
+{{define "api.C++.Dispatch"}}
+ {{AssertType $ "Function"}}
+
+ {{if (Macro "api.IsIntercepted" $)}}// call into api.cpp{{end}}
+ {{if not (IsVoid $.Return.Type)}}return §{{end}}
+
+ {{if (Macro "api.IsIntercepted" $)}}
+ vulkan::api::§
+ {{else}}
+ {{$p0 := index $.CallParameters 0}}
+ vulkan::api::GetData({{$p0.Name}}).dispatch.§
+ {{end}}
+
+ {{Macro "BaseName" $}}({{Macro "Arguments" $}});
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+ Emits a function/extension name without the "vk"/"VK_" prefix.
+-------------------------------------------------------------------------------
+*/}}
+{{define "BaseName"}}
+ {{ if IsFunction $}}{{TrimPrefix "vk" $.Name}}
+ {{else if eq $.Name "extension"}}{{TrimPrefix "VK_" (index $.Arguments 0)}}
+ {{else}}{{Error "invalid use of BaseName"}}
+ {{end}}
+{{end}}
+
+
+{{/*
+-------------------------------------------------------------------------------
+ Emits a comma-separated list of C parameter names for the given command.
+-------------------------------------------------------------------------------
+*/}}
+{{define "Arguments"}}
+ {{AssertType $ "Function"}}
+
+ {{ForEach $.CallParameters "ParameterName" | JoinWith ", "}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+------------------------------------------------------------------------------
+*/}}
+{{define "IsGloballyDispatched"}}
+ {{AssertType $ "Function"}}
+ {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Global")}}
+ true
+ {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emit "true" for supported functions that undergo table dispatch. Only global
+ functions and functions handled in the loader top without calling into
+ lower layers are not dispatched.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsInstanceDispatched"}}
+ {{AssertType $ "Function"}}
+ {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Instance")}}
+ true
+ {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emit "true" for supported functions that can have device-specific dispatch.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsDeviceDispatched"}}
+ {{AssertType $ "Function"}}
+ {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Device")}}
+ true
+ {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emit "true" if a function is core or from a supportable extension.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsFunctionSupported"}}
+ {{AssertType $ "Function"}}
+ {{if not (GetAnnotation $ "pfn")}}
+ {{$ext := GetAnnotation $ "extension"}}
+ {{if not $ext}}true
+ {{else if not (Macro "IsExtensionBlacklisted" $ext)}}true
+ {{end}}
+ {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Decides whether a function should be exported from the Android Vulkan
+ library. Functions in the core API and in loader extensions are exported.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsFunctionExported"}}
+ {{AssertType $ "Function"}}
+
+ {{if (Macro "IsFunctionSupported" $)}}
+ {{$ext := GetAnnotation $ "extension"}}
+ {{if $ext}}
+ {{Macro "IsExtensionExported" $ext}}
+ {{else}}
+ true
+ {{end}}
+ {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Emit "true" if an extension is unsupportable on Android.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsExtensionBlacklisted"}}
+ {{$ext := index $.Arguments 0}}
+ {{ if eq $ext "VK_KHR_display"}}true
+ {{else if eq $ext "VK_KHR_display_swapchain"}}true
+ {{else if eq $ext "VK_KHR_xlib_surface"}}true
+ {{else if eq $ext "VK_KHR_xcb_surface"}}true
+ {{else if eq $ext "VK_KHR_wayland_surface"}}true
+ {{else if eq $ext "VK_KHR_mir_surface"}}true
+ {{else if eq $ext "VK_KHR_win32_surface"}}true
+ {{end}}
+{{end}}
+
+
+{{/*
+------------------------------------------------------------------------------
+ Reports whether an extension is implemented entirely by the loader,
+ so drivers should not enumerate it.
+------------------------------------------------------------------------------
+*/}}
+{{define "IsExtensionExported"}}
+ {{$ext := index $.Arguments 0}}
+ {{ if eq $ext "VK_KHR_surface"}}true
+ {{else if eq $ext "VK_KHR_swapchain"}}true
+ {{else if eq $ext "VK_KHR_android_surface"}}true
+ {{end}}
+{{end}}
¶
// WARNING: This file is generated. See ../README.md for instructions.
¶
-#define VK_USE_PLATFORM_ANDROID_KHR
#include <vulkan/vk_android_native_buffer.h>
#include <vulkan/vulkan.h>
¶
namespace vulkan {
¶
-struct InstanceDispatchTable {«
- // clang-format off
- {{range $f := AllCommands $}}
- {{if (Macro "IsInstanceDispatched" $f)}}
- {{Macro "FunctionPtrName" $f}} {{Macro "BaseName" $f}};
- {{end}}
- {{end}}
- // clang-format on
-»};
-¶
-struct DeviceDispatchTable {«
- // clang-format off
- {{range $f := AllCommands $}}
- {{if (Macro "IsDeviceDispatched" $f)}}
- {{Macro "FunctionPtrName" $f}} {{Macro "BaseName" $f}};
- {{end}}
- {{end}}
- // clang-format on
-»};
-¶
struct DriverDispatchTable {«
// clang-format off
{{range $f := AllCommands $}}
PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
+ PFN_vkDestroyDevice DestroyDevice;
+ PFN_vkGetDeviceQueue GetDeviceQueue;
+ PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
+
{{/* TODO(jessehall): Needed by swapchain code. Figure out a better way of
handling this that avoids the special case. Probably should rework
things so the driver dispatch table has all driver functions. Probably
return Lookup(name, procs, procs + N);
}
¶
-const NameProc kLoaderExportProcs[] = {«
- // clang-format off
- {{range $f := SortBy (AllCommands $) "FunctionName"}}
- {{if (Macro "IsExported" $f)}}
- {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>({{$f.Name}})},
- {{end}}
- {{end}}
- // clang-format on
-»};
-¶
-const NameProc kLoaderGlobalProcs[] = {«
- // clang-format off
- {{range $f := SortBy (AllCommands $) "FunctionName"}}
- {{if and (Macro "HasLoaderTopImpl" $f) (eq (Macro "Vtbl" $f) "Global")}}
- {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
- static_cast<{{Macro "FunctionPtrName" $f}}>(§
- {{Macro "BaseName" $f}}_Top))},
- {{end}}
- {{end}}
- // clang-format on
-»};
-¶
-const NameProc kLoaderTopProcs[] = {«
- // clang-format off
- {{range $f := SortBy (AllCommands $) "FunctionName"}}
- {{if (Macro "HasLoaderTopImpl" $f)}}
- {"{{$f.Name}}", reinterpret_cast<PFN_vkVoidFunction>(§
- static_cast<{{Macro "FunctionPtrName" $f}}>(§
- {{Macro "BaseName" $f}}_Top))},
- {{end}}
- {{end}}
- // clang-format on
-»};
-¶
const NameProc kLoaderBottomProcs[] = {«
// clang-format off
{{range $f := SortBy (AllCommands $) "FunctionName"}}
// clang-format on
»};
¶
-struct NameOffset {
- const char* name;
- size_t offset;
-};
-¶
-ssize_t Lookup(const char* name,
- const NameOffset* begin,
- const NameOffset* end) {
- const auto& entry = std::lower_bound(
- begin, end, name, [](const NameOffset& e, const char* n) {
- return strcmp(e.name, n) < 0;
- });
- if (entry == end || strcmp(entry->name, name) != 0)
- return -1;
- return static_cast<ssize_t>(entry->offset);
-}
-¶
-template <size_t N, class Table>
-PFN_vkVoidFunction Lookup(const char* name,
- const NameOffset (&offsets)[N],
- const Table& table) {
- ssize_t offset = Lookup(name, offsets, offsets + N);
- if (offset < 0)
- return nullptr;
- uintptr_t base = reinterpret_cast<uintptr_t>(&table);
- return *reinterpret_cast<PFN_vkVoidFunction*>(base +
- static_cast<size_t>(offset));
-}
-¶
-const NameOffset kInstanceDispatchOffsets[] = {«
- // clang-format off
- {{range $f := SortBy (AllCommands $) "FunctionName"}}
- {{if (Macro "IsInstanceDispatched" $f)}}
- {"{{$f.Name}}", offsetof(InstanceDispatchTable, {{Macro "BaseName" $f}})},
- {{end}}
- {{end}}
- // clang-format on
-»};
-¶
-const NameOffset kDeviceDispatchOffsets[] = {«
- // clang-format off
- {{range $f := SortBy (AllCommands $) "FunctionName"}}
- {{if (Macro "IsDeviceDispatched" $f)}}
- {"{{$f.Name}}", offsetof(DeviceDispatchTable, {{Macro "BaseName" $f}})},
- {{end}}
- {{end}}
- // clang-format on
-»};
-¶
} // anonymous namespace
¶
namespace vulkan {
¶
-PFN_vkVoidFunction GetLoaderExportProcAddr(const char* name) {
- return Lookup(name, kLoaderExportProcs);
-}
-¶
-PFN_vkVoidFunction GetLoaderGlobalProcAddr(const char* name) {
- return Lookup(name, kLoaderGlobalProcs);
-}
-¶
-PFN_vkVoidFunction GetLoaderTopProcAddr(const char* name) {
- return Lookup(name, kLoaderTopProcs);
-}
-¶
PFN_vkVoidFunction GetLoaderBottomProcAddr(const char* name) {
return Lookup(name, kLoaderBottomProcs);
}
¶
-PFN_vkVoidFunction GetDispatchProcAddr(const InstanceDispatchTable& dispatch,
- const char* name) {
- return Lookup(name, kInstanceDispatchOffsets, dispatch);
-}
-¶
-PFN_vkVoidFunction GetDispatchProcAddr(const DeviceDispatchTable& dispatch,
- const char* name) {
- return Lookup(name, kDeviceDispatchOffsets, dispatch);
-}
-¶
-bool LoadInstanceDispatchTable(VkInstance instance,
- PFN_vkGetInstanceProcAddr get_proc_addr,
- InstanceDispatchTable& dispatch) {«
- bool success = true;
- // clang-format off
- {{range $f := AllCommands $}}
- {{if (Macro "IsInstanceDispatched" $f)}}
- dispatch.{{Macro "BaseName" $f}} = §
- reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
- get_proc_addr(instance, "{{$f.Name}}"));
- if (UNLIKELY(!dispatch.{{Macro "BaseName" $f}})) {
- ALOGE("missing instance proc: %s", "{{$f.Name}}");
- success = false;
- }
- {{end}}
- {{end}}
- // clang-format on
- return success;
-»}
-¶
-bool LoadDeviceDispatchTable(VkDevice device,
- PFN_vkGetDeviceProcAddr get_proc_addr,
- DeviceDispatchTable& dispatch) {«
- bool success = true;
- // clang-format off
- {{range $f := AllCommands $}}
- {{if (Macro "IsDeviceDispatched" $f)}}
- dispatch.{{Macro "BaseName" $f}} = §
- reinterpret_cast<{{Macro "FunctionPtrName" $f}}>(§
- get_proc_addr(device, "{{$f.Name}}"));
- if (UNLIKELY(!dispatch.{{Macro "BaseName" $f}})) {
- ALOGE("missing device proc: %s", "{{$f.Name}}");
- success = false;
- }
- {{end}}
- {{end}}
- // clang-format on
- return success;
-»}
-¶
bool LoadDriverDispatchTable(VkInstance instance,
PFN_vkGetInstanceProcAddr get_proc_addr,
const InstanceExtensionSet& extensions,
ALOGE("missing driver proc: %s", "vkGetDeviceProcAddr");
success = false;
}
+ dispatch.DestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(get_proc_addr(instance, "vkDestroyDevice"));
+ if (UNLIKELY(!dispatch.DestroyDevice)) {
+ ALOGE("missing driver proc: %s", "vkDestroyDevice");
+ success = false;
+ }
+ dispatch.GetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(get_proc_addr(instance, "vkGetDeviceQueue"));
+ if (UNLIKELY(!dispatch.GetDeviceQueue)) {
+ ALOGE("missing driver proc: %s", "vkGetDeviceQueue");
+ success = false;
+ }
+ dispatch.AllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(get_proc_addr(instance, "vkAllocateCommandBuffers"));
+ if (UNLIKELY(!dispatch.AllocateCommandBuffers)) {
+ ALOGE("missing driver proc: %s", "vkAllocateCommandBuffers");
+ success = false;
+ }
dispatch.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(instance, "vkCreateImage"));
if (UNLIKELY(!dispatch.CreateImage)) {
ALOGE("missing driver proc: %s", "vkCreateImage");
»}
¶
} // namespace vulkan
-¶
-// clang-format off
-¶
-{{range $f := AllCommands $}}
- {{if and (not (GetAnnotation $f "pfn")) (Macro "IsExported" $f)}}
- __attribute__((visibility("default")))
- VKAPI_ATTR {{Node "Type" $f.Return}} {{$f.Name}}({{Macro "Parameters" $f}}) {
- {{if not (IsVoid $f.Return.Type)}}return §{{end}}
- {{Macro "Dispatch" $f}}({{Macro "Arguments" $f}});
- }
- ¶
- {{end}}
-{{end}}
-¶
-// clang-format on
¶{{end}}
{{/*
-------------------------------------------------------------------------------
- Emit the dispatch lookup for a function based on its first parameter.
--------------------------------------------------------------------------------
-*/}}
-{{define "Dispatch"}}
- {{AssertType $ "Function"}}
-
- {{if (Macro "HasLoaderTopImpl" $)}}
- {{Macro "BaseName" $}}_Top§
- {{else}}
- {{$p0 := index $.CallParameters 0}}
- GetDispatchTable({{$p0.Name}}).{{Macro "BaseName" $}}§
- {{end}}
-{{end}}
-
-
-{{/*
--------------------------------------------------------------------------------
Map an extension name to InstanceExtension or DeviceExtension enum value
-------------------------------------------------------------------------------
*/}}
{{/*
--------------------------------------------------------------------------------
- Emits a comma-separated list of C parameter names for the given command.
--------------------------------------------------------------------------------
-*/}}
-{{define "Arguments"}}
- {{AssertType $ "Function"}}
-
- {{ForEach $.CallParameters "ParameterName" | JoinWith ", "}}
-{{end}}
-
-
-{{/*
------------------------------------------------------------------------------
Emit "true" for supported functions that undergo table dispatch. Only global
functions and functions handled in the loader top without calling into
{{/*
------------------------------------------------------------------------------
- Emit "true" for supported functions that can have device-specific dispatch.
-------------------------------------------------------------------------------
-*/}}
-{{define "IsDeviceDispatched"}}
- {{AssertType $ "Function"}}
- {{if (Macro "IsFunctionSupported" $)}}
- {{if eq (Macro "Vtbl" $) "Device"}}
- {{if ne $.Name "vkGetDeviceProcAddr"}}
- true
- {{end}}
- {{end}}
- {{end}}
-{{end}}
-
-
-{{/*
-------------------------------------------------------------------------------
Emit "true" if a function is core or from a supportable extension.
------------------------------------------------------------------------------
*/}}
{{/*
------------------------------------------------------------------------------
- Decides whether a function should be exported from the Android Vulkan
- library. Functions in the core API and in loader extensions are exported.
-------------------------------------------------------------------------------
-*/}}
-{{define "IsExported"}}
- {{AssertType $ "Function"}}
-
- {{if (Macro "IsFunctionSupported" $)}}
- {{$ext := GetAnnotation $ "extension"}}
- {{if $ext}}
- {{Macro "IsLoaderExtension" $ext}}
- {{else}}
- true
- {{end}}
- {{end}}
-{{end}}
-
-
-{{/*
-------------------------------------------------------------------------------
Reports whether an extension function is implemented entirely by the loader,
and not implemented by drivers.
------------------------------------------------------------------------------
{{/*
-------------------------------------------------------------------------------
- Emit "true" if the loader has a top-level implementation for the function
- that should be called directly rather than dispatching to the first layer.
--------------------------------------------------------------------------------
-*/}}
-{{define "HasLoaderTopImpl"}}
- {{AssertType $ "Function"}}
-
- {{/* Global functions can't be dispatched */}}
- {{ if and (not (GetAnnotation $ "pfn")) (eq (Macro "Vtbl" $) "Global")}}true
-
- {{/* G*PA are implemented by reading the dispatch table, not by dispatching
- through it. */}}
- {{else if eq $.Name "vkGetInstanceProcAddr"}}true
- {{else if eq $.Name "vkGetDeviceProcAddr"}}true
-
- {{/* Loader top needs to initialize dispatch for device-level dispatchable
- objects */}}
- {{else if eq $.Name "vkGetDeviceQueue"}}true
- {{else if eq $.Name "vkAllocateCommandBuffers"}}true
- {{else if eq $.Name "vkCreateDevice"}}true
- {{else if eq $.Name "vkEnumerateDeviceLayerProperties"}}true
- {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true
-
- {{/* vkDestroy for dispatchable objects needs to handle VK_NULL_HANDLE;
- trying to dispatch through that would crash. */}}
- {{else if eq $.Name "vkDestroyInstance"}}true
- {{else if eq $.Name "vkDestroyDevice"}}true
-
- {{end}}
-{{end}}
-
-
-{{/*
--------------------------------------------------------------------------------
Emit "true" if the loader has a bottom-level implementation for the function
which terminates the dispatch chain.
-------------------------------------------------------------------------------
{{else if (Macro "IsLoaderFunction" $)}}true
{{else if (eq $.Name "vkCreateInstance")}}true
{{else if (eq $.Name "vkGetDeviceProcAddr")}}true
+ {{else if (eq $.Name "vkDestroyDevice")}}true
+ {{else if (eq $.Name "vkGetDeviceQueue")}}true
+ {{else if (eq $.Name "vkAllocateCommandBuffers")}}true
{{end}}
{{end}}
{{end}}
return Lookup(name, procs, procs + N);
}
-const NameProc kLoaderExportProcs[] = {
- // clang-format off
- {"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR)},
- {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateCommandBuffers)},
- {"vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateDescriptorSets)},
- {"vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateMemory)},
- {"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer)},
- {"vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory)},
- {"vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory)},
- {"vkCmdBeginQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQuery)},
- {"vkCmdBeginRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass)},
- {"vkCmdBindDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets)},
- {"vkCmdBindIndexBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer)},
- {"vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipeline)},
- {"vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers)},
- {"vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage)},
- {"vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearAttachments)},
- {"vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorImage)},
- {"vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilImage)},
- {"vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer)},
- {"vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage)},
- {"vkCmdCopyImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage)},
- {"vkCmdCopyImageToBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer)},
- {"vkCmdCopyQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyQueryPoolResults)},
- {"vkCmdDispatch", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatch)},
- {"vkCmdDispatchIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchIndirect)},
- {"vkCmdDraw", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDraw)},
- {"vkCmdDrawIndexed", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexed)},
- {"vkCmdDrawIndexedIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirect)},
- {"vkCmdDrawIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirect)},
- {"vkCmdEndQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQuery)},
- {"vkCmdEndRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass)},
- {"vkCmdExecuteCommands", reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteCommands)},
- {"vkCmdFillBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdFillBuffer)},
- {"vkCmdNextSubpass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass)},
- {"vkCmdPipelineBarrier", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier)},
- {"vkCmdPushConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants)},
- {"vkCmdResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent)},
- {"vkCmdResetQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetQueryPool)},
- {"vkCmdResolveImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage)},
- {"vkCmdSetBlendConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetBlendConstants)},
- {"vkCmdSetDepthBias", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias)},
- {"vkCmdSetDepthBounds", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBounds)},
- {"vkCmdSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent)},
- {"vkCmdSetLineWidth", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineWidth)},
- {"vkCmdSetScissor", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissor)},
- {"vkCmdSetStencilCompareMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilCompareMask)},
- {"vkCmdSetStencilReference", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilReference)},
- {"vkCmdSetStencilWriteMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilWriteMask)},
- {"vkCmdSetViewport", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewport)},
- {"vkCmdUpdateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdateBuffer)},
- {"vkCmdWaitEvents", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents)},
- {"vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp)},
- {"vkCreateAndroidSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateAndroidSurfaceKHR)},
- {"vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBuffer)},
- {"vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferView)},
- {"vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandPool)},
- {"vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateComputePipelines)},
- {"vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorPool)},
- {"vkCreateDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorSetLayout)},
- {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDevice)},
- {"vkCreateEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCreateEvent)},
- {"vkCreateFence", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFence)},
- {"vkCreateFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFramebuffer)},
- {"vkCreateGraphicsPipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateGraphicsPipelines)},
- {"vkCreateImage", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImage)},
- {"vkCreateImageView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImageView)},
- {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(vkCreateInstance)},
- {"vkCreatePipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineCache)},
- {"vkCreatePipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineLayout)},
- {"vkCreateQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateQueryPool)},
- {"vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass)},
- {"vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSampler)},
- {"vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore)},
- {"vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule)},
- {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR)},
- {"vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer)},
- {"vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView)},
- {"vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandPool)},
- {"vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorPool)},
- {"vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorSetLayout)},
- {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDevice)},
- {"vkDestroyEvent", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyEvent)},
- {"vkDestroyFence", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFence)},
- {"vkDestroyFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFramebuffer)},
- {"vkDestroyImage", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImage)},
- {"vkDestroyImageView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImageView)},
- {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyInstance)},
- {"vkDestroyPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipeline)},
- {"vkDestroyPipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineCache)},
- {"vkDestroyPipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineLayout)},
- {"vkDestroyQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyQueryPool)},
- {"vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyRenderPass)},
- {"vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySampler)},
- {"vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore)},
- {"vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule)},
- {"vkDestroySurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySurfaceKHR)},
- {"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR)},
- {"vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle)},
- {"vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkEndCommandBuffer)},
- {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateDeviceExtensionProperties)},
- {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateDeviceLayerProperties)},
- {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateInstanceExtensionProperties)},
- {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(vkEnumerateInstanceLayerProperties)},
- {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(vkEnumeratePhysicalDevices)},
- {"vkFlushMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkFlushMappedMemoryRanges)},
- {"vkFreeCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkFreeCommandBuffers)},
- {"vkFreeDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkFreeDescriptorSets)},
- {"vkFreeMemory", reinterpret_cast<PFN_vkVoidFunction>(vkFreeMemory)},
- {"vkGetBufferMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements)},
- {"vkGetDeviceMemoryCommitment", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryCommitment)},
- {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr)},
- {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue)},
- {"vkGetEventStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetEventStatus)},
- {"vkGetFenceStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceStatus)},
- {"vkGetImageMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements)},
- {"vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements)},
- {"vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout)},
- {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetInstanceProcAddr)},
- {"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures)},
- {"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFormatProperties)},
- {"vkGetPhysicalDeviceImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceImageFormatProperties)},
- {"vkGetPhysicalDeviceMemoryProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceMemoryProperties)},
- {"vkGetPhysicalDeviceProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties)},
- {"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceQueueFamilyProperties)},
- {"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSparseImageFormatProperties)},
- {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)},
- {"vkGetPhysicalDeviceSurfaceFormatsKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceFormatsKHR)},
- {"vkGetPhysicalDeviceSurfacePresentModesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfacePresentModesKHR)},
- {"vkGetPhysicalDeviceSurfaceSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceSupportKHR)},
- {"vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData)},
- {"vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults)},
- {"vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity)},
- {"vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR)},
- {"vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges)},
- {"vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory)},
- {"vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches)},
- {"vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparse)},
- {"vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR)},
- {"vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit)},
- {"vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle)},
- {"vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandBuffer)},
- {"vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandPool)},
- {"vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetDescriptorPool)},
- {"vkResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkResetEvent)},
- {"vkResetFences", reinterpret_cast<PFN_vkVoidFunction>(vkResetFences)},
- {"vkSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkSetEvent)},
- {"vkUnmapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory)},
- {"vkUpdateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSets)},
- {"vkWaitForFences", reinterpret_cast<PFN_vkVoidFunction>(vkWaitForFences)},
- // clang-format on
-};
-
-const NameProc kLoaderGlobalProcs[] = {
- // clang-format off
- {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateInstance>(CreateInstance_Top))},
- {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceExtensionProperties>(EnumerateInstanceExtensionProperties_Top))},
- {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceLayerProperties>(EnumerateInstanceLayerProperties_Top))},
- // clang-format on
-};
-
-const NameProc kLoaderTopProcs[] = {
- // clang-format off
- {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateCommandBuffers>(AllocateCommandBuffers_Top))},
- {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDevice>(CreateDevice_Top))},
- {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateInstance>(CreateInstance_Top))},
- {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyDevice>(DestroyDevice_Top))},
- {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyInstance>(DestroyInstance_Top))},
- {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceExtensionProperties>(EnumerateDeviceExtensionProperties_Top))},
- {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceLayerProperties>(EnumerateDeviceLayerProperties_Top))},
- {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceExtensionProperties>(EnumerateInstanceExtensionProperties_Top))},
- {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceLayerProperties>(EnumerateInstanceLayerProperties_Top))},
- {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceProcAddr>(GetDeviceProcAddr_Top))},
- {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceQueue>(GetDeviceQueue_Top))},
- {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetInstanceProcAddr>(GetInstanceProcAddr_Top))},
- // clang-format on
-};
-
const NameProc kLoaderBottomProcs[] = {
// clang-format off
{"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAcquireNextImageKHR>(AcquireNextImageKHR_Bottom))},
+ {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateCommandBuffers>(AllocateCommandBuffers_Bottom))},
{"vkCreateAndroidSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateAndroidSurfaceKHR>(CreateAndroidSurfaceKHR_Bottom))},
{"vkCreateDebugReportCallbackEXT", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDebugReportCallbackEXT>(CreateDebugReportCallbackEXT_Bottom))},
{"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateDevice>(CreateDevice_Bottom))},
{"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateSwapchainKHR>(CreateSwapchainKHR_Bottom))},
{"vkDebugReportMessageEXT", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDebugReportMessageEXT>(DebugReportMessageEXT_Bottom))},
{"vkDestroyDebugReportCallbackEXT", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyDebugReportCallbackEXT>(DestroyDebugReportCallbackEXT_Bottom))},
+ {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyDevice>(DestroyDevice_Bottom))},
{"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyInstance>(DestroyInstance_Bottom))},
{"vkDestroySurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroySurfaceKHR>(DestroySurfaceKHR_Bottom))},
{"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroySwapchainKHR>(DestroySwapchainKHR_Bottom))},
{"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceLayerProperties>(EnumerateDeviceLayerProperties_Bottom))},
{"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumeratePhysicalDevices>(EnumeratePhysicalDevices_Bottom))},
{"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceProcAddr>(GetDeviceProcAddr_Bottom))},
+ {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceQueue>(GetDeviceQueue_Bottom))},
{"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetInstanceProcAddr>(GetInstanceProcAddr_Bottom))},
{"vkGetPhysicalDeviceFeatures", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFeatures>(GetPhysicalDeviceFeatures_Bottom))},
{"vkGetPhysicalDeviceFormatProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetPhysicalDeviceFormatProperties>(GetPhysicalDeviceFormatProperties_Bottom))},
// clang-format on
};
-struct NameOffset {
- const char* name;
- size_t offset;
-};
-
-ssize_t Lookup(const char* name,
- const NameOffset* begin,
- const NameOffset* end) {
- const auto& entry = std::lower_bound(
- begin, end, name, [](const NameOffset& e, const char* n) {
- return strcmp(e.name, n) < 0;
- });
- if (entry == end || strcmp(entry->name, name) != 0)
- return -1;
- return static_cast<ssize_t>(entry->offset);
-}
-
-template <size_t N, class Table>
-PFN_vkVoidFunction Lookup(const char* name,
- const NameOffset (&offsets)[N],
- const Table& table) {
- ssize_t offset = Lookup(name, offsets, offsets + N);
- if (offset < 0)
- return nullptr;
- uintptr_t base = reinterpret_cast<uintptr_t>(&table);
- return *reinterpret_cast<PFN_vkVoidFunction*>(base +
- static_cast<size_t>(offset));
-}
-
-const NameOffset kInstanceDispatchOffsets[] = {
- // clang-format off
- {"vkCreateAndroidSurfaceKHR", offsetof(InstanceDispatchTable, CreateAndroidSurfaceKHR)},
- {"vkCreateDebugReportCallbackEXT", offsetof(InstanceDispatchTable, CreateDebugReportCallbackEXT)},
- {"vkCreateDevice", offsetof(InstanceDispatchTable, CreateDevice)},
- {"vkDebugReportMessageEXT", offsetof(InstanceDispatchTable, DebugReportMessageEXT)},
- {"vkDestroyDebugReportCallbackEXT", offsetof(InstanceDispatchTable, DestroyDebugReportCallbackEXT)},
- {"vkDestroyInstance", offsetof(InstanceDispatchTable, DestroyInstance)},
- {"vkDestroySurfaceKHR", offsetof(InstanceDispatchTable, DestroySurfaceKHR)},
- {"vkEnumerateDeviceExtensionProperties", offsetof(InstanceDispatchTable, EnumerateDeviceExtensionProperties)},
- {"vkEnumeratePhysicalDevices", offsetof(InstanceDispatchTable, EnumeratePhysicalDevices)},
- {"vkGetPhysicalDeviceFeatures", offsetof(InstanceDispatchTable, GetPhysicalDeviceFeatures)},
- {"vkGetPhysicalDeviceFormatProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceFormatProperties)},
- {"vkGetPhysicalDeviceImageFormatProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceImageFormatProperties)},
- {"vkGetPhysicalDeviceMemoryProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceMemoryProperties)},
- {"vkGetPhysicalDeviceProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceProperties)},
- {"vkGetPhysicalDeviceQueueFamilyProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceQueueFamilyProperties)},
- {"vkGetPhysicalDeviceSparseImageFormatProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceSparseImageFormatProperties)},
- {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfaceCapabilitiesKHR)},
- {"vkGetPhysicalDeviceSurfaceFormatsKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfaceFormatsKHR)},
- {"vkGetPhysicalDeviceSurfacePresentModesKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfacePresentModesKHR)},
- {"vkGetPhysicalDeviceSurfaceSupportKHR", offsetof(InstanceDispatchTable, GetPhysicalDeviceSurfaceSupportKHR)},
- // clang-format on
-};
-
-const NameOffset kDeviceDispatchOffsets[] = {
- // clang-format off
- {"vkAcquireNextImageKHR", offsetof(DeviceDispatchTable, AcquireNextImageKHR)},
- {"vkAllocateCommandBuffers", offsetof(DeviceDispatchTable, AllocateCommandBuffers)},
- {"vkAllocateDescriptorSets", offsetof(DeviceDispatchTable, AllocateDescriptorSets)},
- {"vkAllocateMemory", offsetof(DeviceDispatchTable, AllocateMemory)},
- {"vkBeginCommandBuffer", offsetof(DeviceDispatchTable, BeginCommandBuffer)},
- {"vkBindBufferMemory", offsetof(DeviceDispatchTable, BindBufferMemory)},
- {"vkBindImageMemory", offsetof(DeviceDispatchTable, BindImageMemory)},
- {"vkCmdBeginQuery", offsetof(DeviceDispatchTable, CmdBeginQuery)},
- {"vkCmdBeginRenderPass", offsetof(DeviceDispatchTable, CmdBeginRenderPass)},
- {"vkCmdBindDescriptorSets", offsetof(DeviceDispatchTable, CmdBindDescriptorSets)},
- {"vkCmdBindIndexBuffer", offsetof(DeviceDispatchTable, CmdBindIndexBuffer)},
- {"vkCmdBindPipeline", offsetof(DeviceDispatchTable, CmdBindPipeline)},
- {"vkCmdBindVertexBuffers", offsetof(DeviceDispatchTable, CmdBindVertexBuffers)},
- {"vkCmdBlitImage", offsetof(DeviceDispatchTable, CmdBlitImage)},
- {"vkCmdClearAttachments", offsetof(DeviceDispatchTable, CmdClearAttachments)},
- {"vkCmdClearColorImage", offsetof(DeviceDispatchTable, CmdClearColorImage)},
- {"vkCmdClearDepthStencilImage", offsetof(DeviceDispatchTable, CmdClearDepthStencilImage)},
- {"vkCmdCopyBuffer", offsetof(DeviceDispatchTable, CmdCopyBuffer)},
- {"vkCmdCopyBufferToImage", offsetof(DeviceDispatchTable, CmdCopyBufferToImage)},
- {"vkCmdCopyImage", offsetof(DeviceDispatchTable, CmdCopyImage)},
- {"vkCmdCopyImageToBuffer", offsetof(DeviceDispatchTable, CmdCopyImageToBuffer)},
- {"vkCmdCopyQueryPoolResults", offsetof(DeviceDispatchTable, CmdCopyQueryPoolResults)},
- {"vkCmdDispatch", offsetof(DeviceDispatchTable, CmdDispatch)},
- {"vkCmdDispatchIndirect", offsetof(DeviceDispatchTable, CmdDispatchIndirect)},
- {"vkCmdDraw", offsetof(DeviceDispatchTable, CmdDraw)},
- {"vkCmdDrawIndexed", offsetof(DeviceDispatchTable, CmdDrawIndexed)},
- {"vkCmdDrawIndexedIndirect", offsetof(DeviceDispatchTable, CmdDrawIndexedIndirect)},
- {"vkCmdDrawIndirect", offsetof(DeviceDispatchTable, CmdDrawIndirect)},
- {"vkCmdEndQuery", offsetof(DeviceDispatchTable, CmdEndQuery)},
- {"vkCmdEndRenderPass", offsetof(DeviceDispatchTable, CmdEndRenderPass)},
- {"vkCmdExecuteCommands", offsetof(DeviceDispatchTable, CmdExecuteCommands)},
- {"vkCmdFillBuffer", offsetof(DeviceDispatchTable, CmdFillBuffer)},
- {"vkCmdNextSubpass", offsetof(DeviceDispatchTable, CmdNextSubpass)},
- {"vkCmdPipelineBarrier", offsetof(DeviceDispatchTable, CmdPipelineBarrier)},
- {"vkCmdPushConstants", offsetof(DeviceDispatchTable, CmdPushConstants)},
- {"vkCmdResetEvent", offsetof(DeviceDispatchTable, CmdResetEvent)},
- {"vkCmdResetQueryPool", offsetof(DeviceDispatchTable, CmdResetQueryPool)},
- {"vkCmdResolveImage", offsetof(DeviceDispatchTable, CmdResolveImage)},
- {"vkCmdSetBlendConstants", offsetof(DeviceDispatchTable, CmdSetBlendConstants)},
- {"vkCmdSetDepthBias", offsetof(DeviceDispatchTable, CmdSetDepthBias)},
- {"vkCmdSetDepthBounds", offsetof(DeviceDispatchTable, CmdSetDepthBounds)},
- {"vkCmdSetEvent", offsetof(DeviceDispatchTable, CmdSetEvent)},
- {"vkCmdSetLineWidth", offsetof(DeviceDispatchTable, CmdSetLineWidth)},
- {"vkCmdSetScissor", offsetof(DeviceDispatchTable, CmdSetScissor)},
- {"vkCmdSetStencilCompareMask", offsetof(DeviceDispatchTable, CmdSetStencilCompareMask)},
- {"vkCmdSetStencilReference", offsetof(DeviceDispatchTable, CmdSetStencilReference)},
- {"vkCmdSetStencilWriteMask", offsetof(DeviceDispatchTable, CmdSetStencilWriteMask)},
- {"vkCmdSetViewport", offsetof(DeviceDispatchTable, CmdSetViewport)},
- {"vkCmdUpdateBuffer", offsetof(DeviceDispatchTable, CmdUpdateBuffer)},
- {"vkCmdWaitEvents", offsetof(DeviceDispatchTable, CmdWaitEvents)},
- {"vkCmdWriteTimestamp", offsetof(DeviceDispatchTable, CmdWriteTimestamp)},
- {"vkCreateBuffer", offsetof(DeviceDispatchTable, CreateBuffer)},
- {"vkCreateBufferView", offsetof(DeviceDispatchTable, CreateBufferView)},
- {"vkCreateCommandPool", offsetof(DeviceDispatchTable, CreateCommandPool)},
- {"vkCreateComputePipelines", offsetof(DeviceDispatchTable, CreateComputePipelines)},
- {"vkCreateDescriptorPool", offsetof(DeviceDispatchTable, CreateDescriptorPool)},
- {"vkCreateDescriptorSetLayout", offsetof(DeviceDispatchTable, CreateDescriptorSetLayout)},
- {"vkCreateEvent", offsetof(DeviceDispatchTable, CreateEvent)},
- {"vkCreateFence", offsetof(DeviceDispatchTable, CreateFence)},
- {"vkCreateFramebuffer", offsetof(DeviceDispatchTable, CreateFramebuffer)},
- {"vkCreateGraphicsPipelines", offsetof(DeviceDispatchTable, CreateGraphicsPipelines)},
- {"vkCreateImage", offsetof(DeviceDispatchTable, CreateImage)},
- {"vkCreateImageView", offsetof(DeviceDispatchTable, CreateImageView)},
- {"vkCreatePipelineCache", offsetof(DeviceDispatchTable, CreatePipelineCache)},
- {"vkCreatePipelineLayout", offsetof(DeviceDispatchTable, CreatePipelineLayout)},
- {"vkCreateQueryPool", offsetof(DeviceDispatchTable, CreateQueryPool)},
- {"vkCreateRenderPass", offsetof(DeviceDispatchTable, CreateRenderPass)},
- {"vkCreateSampler", offsetof(DeviceDispatchTable, CreateSampler)},
- {"vkCreateSemaphore", offsetof(DeviceDispatchTable, CreateSemaphore)},
- {"vkCreateShaderModule", offsetof(DeviceDispatchTable, CreateShaderModule)},
- {"vkCreateSwapchainKHR", offsetof(DeviceDispatchTable, CreateSwapchainKHR)},
- {"vkDestroyBuffer", offsetof(DeviceDispatchTable, DestroyBuffer)},
- {"vkDestroyBufferView", offsetof(DeviceDispatchTable, DestroyBufferView)},
- {"vkDestroyCommandPool", offsetof(DeviceDispatchTable, DestroyCommandPool)},
- {"vkDestroyDescriptorPool", offsetof(DeviceDispatchTable, DestroyDescriptorPool)},
- {"vkDestroyDescriptorSetLayout", offsetof(DeviceDispatchTable, DestroyDescriptorSetLayout)},
- {"vkDestroyDevice", offsetof(DeviceDispatchTable, DestroyDevice)},
- {"vkDestroyEvent", offsetof(DeviceDispatchTable, DestroyEvent)},
- {"vkDestroyFence", offsetof(DeviceDispatchTable, DestroyFence)},
- {"vkDestroyFramebuffer", offsetof(DeviceDispatchTable, DestroyFramebuffer)},
- {"vkDestroyImage", offsetof(DeviceDispatchTable, DestroyImage)},
- {"vkDestroyImageView", offsetof(DeviceDispatchTable, DestroyImageView)},
- {"vkDestroyPipeline", offsetof(DeviceDispatchTable, DestroyPipeline)},
- {"vkDestroyPipelineCache", offsetof(DeviceDispatchTable, DestroyPipelineCache)},
- {"vkDestroyPipelineLayout", offsetof(DeviceDispatchTable, DestroyPipelineLayout)},
- {"vkDestroyQueryPool", offsetof(DeviceDispatchTable, DestroyQueryPool)},
- {"vkDestroyRenderPass", offsetof(DeviceDispatchTable, DestroyRenderPass)},
- {"vkDestroySampler", offsetof(DeviceDispatchTable, DestroySampler)},
- {"vkDestroySemaphore", offsetof(DeviceDispatchTable, DestroySemaphore)},
- {"vkDestroyShaderModule", offsetof(DeviceDispatchTable, DestroyShaderModule)},
- {"vkDestroySwapchainKHR", offsetof(DeviceDispatchTable, DestroySwapchainKHR)},
- {"vkDeviceWaitIdle", offsetof(DeviceDispatchTable, DeviceWaitIdle)},
- {"vkEndCommandBuffer", offsetof(DeviceDispatchTable, EndCommandBuffer)},
- {"vkFlushMappedMemoryRanges", offsetof(DeviceDispatchTable, FlushMappedMemoryRanges)},
- {"vkFreeCommandBuffers", offsetof(DeviceDispatchTable, FreeCommandBuffers)},
- {"vkFreeDescriptorSets", offsetof(DeviceDispatchTable, FreeDescriptorSets)},
- {"vkFreeMemory", offsetof(DeviceDispatchTable, FreeMemory)},
- {"vkGetBufferMemoryRequirements", offsetof(DeviceDispatchTable, GetBufferMemoryRequirements)},
- {"vkGetDeviceMemoryCommitment", offsetof(DeviceDispatchTable, GetDeviceMemoryCommitment)},
- {"vkGetDeviceQueue", offsetof(DeviceDispatchTable, GetDeviceQueue)},
- {"vkGetEventStatus", offsetof(DeviceDispatchTable, GetEventStatus)},
- {"vkGetFenceStatus", offsetof(DeviceDispatchTable, GetFenceStatus)},
- {"vkGetImageMemoryRequirements", offsetof(DeviceDispatchTable, GetImageMemoryRequirements)},
- {"vkGetImageSparseMemoryRequirements", offsetof(DeviceDispatchTable, GetImageSparseMemoryRequirements)},
- {"vkGetImageSubresourceLayout", offsetof(DeviceDispatchTable, GetImageSubresourceLayout)},
- {"vkGetPipelineCacheData", offsetof(DeviceDispatchTable, GetPipelineCacheData)},
- {"vkGetQueryPoolResults", offsetof(DeviceDispatchTable, GetQueryPoolResults)},
- {"vkGetRenderAreaGranularity", offsetof(DeviceDispatchTable, GetRenderAreaGranularity)},
- {"vkGetSwapchainImagesKHR", offsetof(DeviceDispatchTable, GetSwapchainImagesKHR)},
- {"vkInvalidateMappedMemoryRanges", offsetof(DeviceDispatchTable, InvalidateMappedMemoryRanges)},
- {"vkMapMemory", offsetof(DeviceDispatchTable, MapMemory)},
- {"vkMergePipelineCaches", offsetof(DeviceDispatchTable, MergePipelineCaches)},
- {"vkQueueBindSparse", offsetof(DeviceDispatchTable, QueueBindSparse)},
- {"vkQueuePresentKHR", offsetof(DeviceDispatchTable, QueuePresentKHR)},
- {"vkQueueSubmit", offsetof(DeviceDispatchTable, QueueSubmit)},
- {"vkQueueWaitIdle", offsetof(DeviceDispatchTable, QueueWaitIdle)},
- {"vkResetCommandBuffer", offsetof(DeviceDispatchTable, ResetCommandBuffer)},
- {"vkResetCommandPool", offsetof(DeviceDispatchTable, ResetCommandPool)},
- {"vkResetDescriptorPool", offsetof(DeviceDispatchTable, ResetDescriptorPool)},
- {"vkResetEvent", offsetof(DeviceDispatchTable, ResetEvent)},
- {"vkResetFences", offsetof(DeviceDispatchTable, ResetFences)},
- {"vkSetEvent", offsetof(DeviceDispatchTable, SetEvent)},
- {"vkUnmapMemory", offsetof(DeviceDispatchTable, UnmapMemory)},
- {"vkUpdateDescriptorSets", offsetof(DeviceDispatchTable, UpdateDescriptorSets)},
- {"vkWaitForFences", offsetof(DeviceDispatchTable, WaitForFences)},
- // clang-format on
-};
-
} // anonymous namespace
namespace vulkan {
-PFN_vkVoidFunction GetLoaderExportProcAddr(const char* name) {
- return Lookup(name, kLoaderExportProcs);
-}
-
-PFN_vkVoidFunction GetLoaderGlobalProcAddr(const char* name) {
- return Lookup(name, kLoaderGlobalProcs);
-}
-
-PFN_vkVoidFunction GetLoaderTopProcAddr(const char* name) {
- return Lookup(name, kLoaderTopProcs);
-}
-
PFN_vkVoidFunction GetLoaderBottomProcAddr(const char* name) {
return Lookup(name, kLoaderBottomProcs);
}
-PFN_vkVoidFunction GetDispatchProcAddr(const InstanceDispatchTable& dispatch,
- const char* name) {
- return Lookup(name, kInstanceDispatchOffsets, dispatch);
-}
-
-PFN_vkVoidFunction GetDispatchProcAddr(const DeviceDispatchTable& dispatch,
- const char* name) {
- return Lookup(name, kDeviceDispatchOffsets, dispatch);
-}
-
-bool LoadInstanceDispatchTable(VkInstance instance,
- PFN_vkGetInstanceProcAddr get_proc_addr,
- InstanceDispatchTable& dispatch) {
+bool LoadDriverDispatchTable(VkInstance instance,
+ PFN_vkGetInstanceProcAddr get_proc_addr,
+ const InstanceExtensionSet& extensions,
+ DriverDispatchTable& dispatch) {
bool success = true;
// clang-format off
dispatch.DestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(get_proc_addr(instance, "vkDestroyInstance"));
if (UNLIKELY(!dispatch.DestroyInstance)) {
- ALOGE("missing instance proc: %s", "vkDestroyInstance");
+ ALOGE("missing driver proc: %s", "vkDestroyInstance");
success = false;
}
dispatch.EnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(get_proc_addr(instance, "vkEnumeratePhysicalDevices"));
if (UNLIKELY(!dispatch.EnumeratePhysicalDevices)) {
- ALOGE("missing instance proc: %s", "vkEnumeratePhysicalDevices");
+ ALOGE("missing driver proc: %s", "vkEnumeratePhysicalDevices");
success = false;
}
dispatch.GetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceProperties"));
if (UNLIKELY(!dispatch.GetPhysicalDeviceProperties)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceProperties");
+ ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceProperties");
success = false;
}
dispatch.GetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceQueueFamilyProperties"));
if (UNLIKELY(!dispatch.GetPhysicalDeviceQueueFamilyProperties)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceQueueFamilyProperties");
+ ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceQueueFamilyProperties");
success = false;
}
dispatch.GetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceMemoryProperties"));
if (UNLIKELY(!dispatch.GetPhysicalDeviceMemoryProperties)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceMemoryProperties");
+ ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceMemoryProperties");
success = false;
}
dispatch.GetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(get_proc_addr(instance, "vkGetPhysicalDeviceFeatures"));
if (UNLIKELY(!dispatch.GetPhysicalDeviceFeatures)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceFeatures");
+ ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceFeatures");
success = false;
}
dispatch.GetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceFormatProperties"));
if (UNLIKELY(!dispatch.GetPhysicalDeviceFormatProperties)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceFormatProperties");
+ ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceFormatProperties");
success = false;
}
dispatch.GetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceImageFormatProperties"));
if (UNLIKELY(!dispatch.GetPhysicalDeviceImageFormatProperties)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceImageFormatProperties");
+ ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceImageFormatProperties");
success = false;
}
dispatch.CreateDevice = reinterpret_cast<PFN_vkCreateDevice>(get_proc_addr(instance, "vkCreateDevice"));
if (UNLIKELY(!dispatch.CreateDevice)) {
- ALOGE("missing instance proc: %s", "vkCreateDevice");
+ ALOGE("missing driver proc: %s", "vkCreateDevice");
success = false;
}
dispatch.EnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(get_proc_addr(instance, "vkEnumerateDeviceExtensionProperties"));
if (UNLIKELY(!dispatch.EnumerateDeviceExtensionProperties)) {
- ALOGE("missing instance proc: %s", "vkEnumerateDeviceExtensionProperties");
+ ALOGE("missing driver proc: %s", "vkEnumerateDeviceExtensionProperties");
success = false;
}
dispatch.GetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"));
if (UNLIKELY(!dispatch.GetPhysicalDeviceSparseImageFormatProperties)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSparseImageFormatProperties");
- success = false;
- }
- dispatch.DestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(get_proc_addr(instance, "vkDestroySurfaceKHR"));
- if (UNLIKELY(!dispatch.DestroySurfaceKHR)) {
- ALOGE("missing instance proc: %s", "vkDestroySurfaceKHR");
- success = false;
- }
- dispatch.GetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfaceSupportKHR)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfaceSupportKHR");
- success = false;
- }
- dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
- success = false;
- }
- dispatch.GetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfaceFormatsKHR)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfaceFormatsKHR");
- success = false;
- }
- dispatch.GetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(get_proc_addr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceSurfacePresentModesKHR)) {
- ALOGE("missing instance proc: %s", "vkGetPhysicalDeviceSurfacePresentModesKHR");
+ ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceSparseImageFormatProperties");
success = false;
}
- dispatch.CreateAndroidSurfaceKHR = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(get_proc_addr(instance, "vkCreateAndroidSurfaceKHR"));
- if (UNLIKELY(!dispatch.CreateAndroidSurfaceKHR)) {
- ALOGE("missing instance proc: %s", "vkCreateAndroidSurfaceKHR");
- success = false;
+ if (extensions[kEXT_debug_report]) {
+ dispatch.CreateDebugReportCallbackEXT = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(get_proc_addr(instance, "vkCreateDebugReportCallbackEXT"));
+ if (UNLIKELY(!dispatch.CreateDebugReportCallbackEXT)) {
+ ALOGE("missing driver proc: %s", "vkCreateDebugReportCallbackEXT");
+ success = false;
+ }
}
- dispatch.CreateDebugReportCallbackEXT = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(get_proc_addr(instance, "vkCreateDebugReportCallbackEXT"));
- if (UNLIKELY(!dispatch.CreateDebugReportCallbackEXT)) {
- ALOGE("missing instance proc: %s", "vkCreateDebugReportCallbackEXT");
- success = false;
+ if (extensions[kEXT_debug_report]) {
+ dispatch.DestroyDebugReportCallbackEXT = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(get_proc_addr(instance, "vkDestroyDebugReportCallbackEXT"));
+ if (UNLIKELY(!dispatch.DestroyDebugReportCallbackEXT)) {
+ ALOGE("missing driver proc: %s", "vkDestroyDebugReportCallbackEXT");
+ success = false;
+ }
}
- dispatch.DestroyDebugReportCallbackEXT = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(get_proc_addr(instance, "vkDestroyDebugReportCallbackEXT"));
- if (UNLIKELY(!dispatch.DestroyDebugReportCallbackEXT)) {
- ALOGE("missing instance proc: %s", "vkDestroyDebugReportCallbackEXT");
- success = false;
+ if (extensions[kEXT_debug_report]) {
+ dispatch.DebugReportMessageEXT = reinterpret_cast<PFN_vkDebugReportMessageEXT>(get_proc_addr(instance, "vkDebugReportMessageEXT"));
+ if (UNLIKELY(!dispatch.DebugReportMessageEXT)) {
+ ALOGE("missing driver proc: %s", "vkDebugReportMessageEXT");
+ success = false;
+ }
}
- dispatch.DebugReportMessageEXT = reinterpret_cast<PFN_vkDebugReportMessageEXT>(get_proc_addr(instance, "vkDebugReportMessageEXT"));
- if (UNLIKELY(!dispatch.DebugReportMessageEXT)) {
- ALOGE("missing instance proc: %s", "vkDebugReportMessageEXT");
+ dispatch.GetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(get_proc_addr(instance, "vkGetDeviceProcAddr"));
+ if (UNLIKELY(!dispatch.GetDeviceProcAddr)) {
+ ALOGE("missing driver proc: %s", "vkGetDeviceProcAddr");
success = false;
}
- // clang-format on
- return success;
-}
-
-bool LoadDeviceDispatchTable(VkDevice device,
- PFN_vkGetDeviceProcAddr get_proc_addr,
- DeviceDispatchTable& dispatch) {
- bool success = true;
- // clang-format off
- dispatch.DestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(get_proc_addr(device, "vkDestroyDevice"));
+ dispatch.DestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(get_proc_addr(instance, "vkDestroyDevice"));
if (UNLIKELY(!dispatch.DestroyDevice)) {
- ALOGE("missing device proc: %s", "vkDestroyDevice");
+ ALOGE("missing driver proc: %s", "vkDestroyDevice");
success = false;
}
- dispatch.GetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(get_proc_addr(device, "vkGetDeviceQueue"));
+ dispatch.GetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(get_proc_addr(instance, "vkGetDeviceQueue"));
if (UNLIKELY(!dispatch.GetDeviceQueue)) {
- ALOGE("missing device proc: %s", "vkGetDeviceQueue");
- success = false;
- }
- dispatch.QueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(get_proc_addr(device, "vkQueueSubmit"));
- if (UNLIKELY(!dispatch.QueueSubmit)) {
- ALOGE("missing device proc: %s", "vkQueueSubmit");
- success = false;
- }
- dispatch.QueueWaitIdle = reinterpret_cast<PFN_vkQueueWaitIdle>(get_proc_addr(device, "vkQueueWaitIdle"));
- if (UNLIKELY(!dispatch.QueueWaitIdle)) {
- ALOGE("missing device proc: %s", "vkQueueWaitIdle");
- success = false;
- }
- dispatch.DeviceWaitIdle = reinterpret_cast<PFN_vkDeviceWaitIdle>(get_proc_addr(device, "vkDeviceWaitIdle"));
- if (UNLIKELY(!dispatch.DeviceWaitIdle)) {
- ALOGE("missing device proc: %s", "vkDeviceWaitIdle");
- success = false;
- }
- dispatch.AllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(get_proc_addr(device, "vkAllocateMemory"));
- if (UNLIKELY(!dispatch.AllocateMemory)) {
- ALOGE("missing device proc: %s", "vkAllocateMemory");
- success = false;
- }
- dispatch.FreeMemory = reinterpret_cast<PFN_vkFreeMemory>(get_proc_addr(device, "vkFreeMemory"));
- if (UNLIKELY(!dispatch.FreeMemory)) {
- ALOGE("missing device proc: %s", "vkFreeMemory");
- success = false;
- }
- dispatch.MapMemory = reinterpret_cast<PFN_vkMapMemory>(get_proc_addr(device, "vkMapMemory"));
- if (UNLIKELY(!dispatch.MapMemory)) {
- ALOGE("missing device proc: %s", "vkMapMemory");
- success = false;
- }
- dispatch.UnmapMemory = reinterpret_cast<PFN_vkUnmapMemory>(get_proc_addr(device, "vkUnmapMemory"));
- if (UNLIKELY(!dispatch.UnmapMemory)) {
- ALOGE("missing device proc: %s", "vkUnmapMemory");
- success = false;
- }
- dispatch.FlushMappedMemoryRanges = reinterpret_cast<PFN_vkFlushMappedMemoryRanges>(get_proc_addr(device, "vkFlushMappedMemoryRanges"));
- if (UNLIKELY(!dispatch.FlushMappedMemoryRanges)) {
- ALOGE("missing device proc: %s", "vkFlushMappedMemoryRanges");
- success = false;
- }
- dispatch.InvalidateMappedMemoryRanges = reinterpret_cast<PFN_vkInvalidateMappedMemoryRanges>(get_proc_addr(device, "vkInvalidateMappedMemoryRanges"));
- if (UNLIKELY(!dispatch.InvalidateMappedMemoryRanges)) {
- ALOGE("missing device proc: %s", "vkInvalidateMappedMemoryRanges");
- success = false;
- }
- dispatch.GetDeviceMemoryCommitment = reinterpret_cast<PFN_vkGetDeviceMemoryCommitment>(get_proc_addr(device, "vkGetDeviceMemoryCommitment"));
- if (UNLIKELY(!dispatch.GetDeviceMemoryCommitment)) {
- ALOGE("missing device proc: %s", "vkGetDeviceMemoryCommitment");
- success = false;
- }
- dispatch.GetBufferMemoryRequirements = reinterpret_cast<PFN_vkGetBufferMemoryRequirements>(get_proc_addr(device, "vkGetBufferMemoryRequirements"));
- if (UNLIKELY(!dispatch.GetBufferMemoryRequirements)) {
- ALOGE("missing device proc: %s", "vkGetBufferMemoryRequirements");
- success = false;
- }
- dispatch.BindBufferMemory = reinterpret_cast<PFN_vkBindBufferMemory>(get_proc_addr(device, "vkBindBufferMemory"));
- if (UNLIKELY(!dispatch.BindBufferMemory)) {
- ALOGE("missing device proc: %s", "vkBindBufferMemory");
- success = false;
- }
- dispatch.GetImageMemoryRequirements = reinterpret_cast<PFN_vkGetImageMemoryRequirements>(get_proc_addr(device, "vkGetImageMemoryRequirements"));
- if (UNLIKELY(!dispatch.GetImageMemoryRequirements)) {
- ALOGE("missing device proc: %s", "vkGetImageMemoryRequirements");
- success = false;
- }
- dispatch.BindImageMemory = reinterpret_cast<PFN_vkBindImageMemory>(get_proc_addr(device, "vkBindImageMemory"));
- if (UNLIKELY(!dispatch.BindImageMemory)) {
- ALOGE("missing device proc: %s", "vkBindImageMemory");
- success = false;
- }
- dispatch.GetImageSparseMemoryRequirements = reinterpret_cast<PFN_vkGetImageSparseMemoryRequirements>(get_proc_addr(device, "vkGetImageSparseMemoryRequirements"));
- if (UNLIKELY(!dispatch.GetImageSparseMemoryRequirements)) {
- ALOGE("missing device proc: %s", "vkGetImageSparseMemoryRequirements");
- success = false;
- }
- dispatch.QueueBindSparse = reinterpret_cast<PFN_vkQueueBindSparse>(get_proc_addr(device, "vkQueueBindSparse"));
- if (UNLIKELY(!dispatch.QueueBindSparse)) {
- ALOGE("missing device proc: %s", "vkQueueBindSparse");
+ ALOGE("missing driver proc: %s", "vkGetDeviceQueue");
success = false;
}
- dispatch.CreateFence = reinterpret_cast<PFN_vkCreateFence>(get_proc_addr(device, "vkCreateFence"));
- if (UNLIKELY(!dispatch.CreateFence)) {
- ALOGE("missing device proc: %s", "vkCreateFence");
- success = false;
- }
- dispatch.DestroyFence = reinterpret_cast<PFN_vkDestroyFence>(get_proc_addr(device, "vkDestroyFence"));
- if (UNLIKELY(!dispatch.DestroyFence)) {
- ALOGE("missing device proc: %s", "vkDestroyFence");
- success = false;
- }
- dispatch.ResetFences = reinterpret_cast<PFN_vkResetFences>(get_proc_addr(device, "vkResetFences"));
- if (UNLIKELY(!dispatch.ResetFences)) {
- ALOGE("missing device proc: %s", "vkResetFences");
- success = false;
- }
- dispatch.GetFenceStatus = reinterpret_cast<PFN_vkGetFenceStatus>(get_proc_addr(device, "vkGetFenceStatus"));
- if (UNLIKELY(!dispatch.GetFenceStatus)) {
- ALOGE("missing device proc: %s", "vkGetFenceStatus");
- success = false;
- }
- dispatch.WaitForFences = reinterpret_cast<PFN_vkWaitForFences>(get_proc_addr(device, "vkWaitForFences"));
- if (UNLIKELY(!dispatch.WaitForFences)) {
- ALOGE("missing device proc: %s", "vkWaitForFences");
- success = false;
- }
- dispatch.CreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(get_proc_addr(device, "vkCreateSemaphore"));
- if (UNLIKELY(!dispatch.CreateSemaphore)) {
- ALOGE("missing device proc: %s", "vkCreateSemaphore");
- success = false;
- }
- dispatch.DestroySemaphore = reinterpret_cast<PFN_vkDestroySemaphore>(get_proc_addr(device, "vkDestroySemaphore"));
- if (UNLIKELY(!dispatch.DestroySemaphore)) {
- ALOGE("missing device proc: %s", "vkDestroySemaphore");
- success = false;
- }
- dispatch.CreateEvent = reinterpret_cast<PFN_vkCreateEvent>(get_proc_addr(device, "vkCreateEvent"));
- if (UNLIKELY(!dispatch.CreateEvent)) {
- ALOGE("missing device proc: %s", "vkCreateEvent");
- success = false;
- }
- dispatch.DestroyEvent = reinterpret_cast<PFN_vkDestroyEvent>(get_proc_addr(device, "vkDestroyEvent"));
- if (UNLIKELY(!dispatch.DestroyEvent)) {
- ALOGE("missing device proc: %s", "vkDestroyEvent");
- success = false;
- }
- dispatch.GetEventStatus = reinterpret_cast<PFN_vkGetEventStatus>(get_proc_addr(device, "vkGetEventStatus"));
- if (UNLIKELY(!dispatch.GetEventStatus)) {
- ALOGE("missing device proc: %s", "vkGetEventStatus");
- success = false;
- }
- dispatch.SetEvent = reinterpret_cast<PFN_vkSetEvent>(get_proc_addr(device, "vkSetEvent"));
- if (UNLIKELY(!dispatch.SetEvent)) {
- ALOGE("missing device proc: %s", "vkSetEvent");
- success = false;
- }
- dispatch.ResetEvent = reinterpret_cast<PFN_vkResetEvent>(get_proc_addr(device, "vkResetEvent"));
- if (UNLIKELY(!dispatch.ResetEvent)) {
- ALOGE("missing device proc: %s", "vkResetEvent");
- success = false;
- }
- dispatch.CreateQueryPool = reinterpret_cast<PFN_vkCreateQueryPool>(get_proc_addr(device, "vkCreateQueryPool"));
- if (UNLIKELY(!dispatch.CreateQueryPool)) {
- ALOGE("missing device proc: %s", "vkCreateQueryPool");
- success = false;
- }
- dispatch.DestroyQueryPool = reinterpret_cast<PFN_vkDestroyQueryPool>(get_proc_addr(device, "vkDestroyQueryPool"));
- if (UNLIKELY(!dispatch.DestroyQueryPool)) {
- ALOGE("missing device proc: %s", "vkDestroyQueryPool");
- success = false;
- }
- dispatch.GetQueryPoolResults = reinterpret_cast<PFN_vkGetQueryPoolResults>(get_proc_addr(device, "vkGetQueryPoolResults"));
- if (UNLIKELY(!dispatch.GetQueryPoolResults)) {
- ALOGE("missing device proc: %s", "vkGetQueryPoolResults");
- success = false;
- }
- dispatch.CreateBuffer = reinterpret_cast<PFN_vkCreateBuffer>(get_proc_addr(device, "vkCreateBuffer"));
- if (UNLIKELY(!dispatch.CreateBuffer)) {
- ALOGE("missing device proc: %s", "vkCreateBuffer");
- success = false;
- }
- dispatch.DestroyBuffer = reinterpret_cast<PFN_vkDestroyBuffer>(get_proc_addr(device, "vkDestroyBuffer"));
- if (UNLIKELY(!dispatch.DestroyBuffer)) {
- ALOGE("missing device proc: %s", "vkDestroyBuffer");
- success = false;
- }
- dispatch.CreateBufferView = reinterpret_cast<PFN_vkCreateBufferView>(get_proc_addr(device, "vkCreateBufferView"));
- if (UNLIKELY(!dispatch.CreateBufferView)) {
- ALOGE("missing device proc: %s", "vkCreateBufferView");
- success = false;
- }
- dispatch.DestroyBufferView = reinterpret_cast<PFN_vkDestroyBufferView>(get_proc_addr(device, "vkDestroyBufferView"));
- if (UNLIKELY(!dispatch.DestroyBufferView)) {
- ALOGE("missing device proc: %s", "vkDestroyBufferView");
+ dispatch.AllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(get_proc_addr(instance, "vkAllocateCommandBuffers"));
+ if (UNLIKELY(!dispatch.AllocateCommandBuffers)) {
+ ALOGE("missing driver proc: %s", "vkAllocateCommandBuffers");
success = false;
}
- dispatch.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(device, "vkCreateImage"));
+ dispatch.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(instance, "vkCreateImage"));
if (UNLIKELY(!dispatch.CreateImage)) {
- ALOGE("missing device proc: %s", "vkCreateImage");
+ ALOGE("missing driver proc: %s", "vkCreateImage");
success = false;
}
- dispatch.DestroyImage = reinterpret_cast<PFN_vkDestroyImage>(get_proc_addr(device, "vkDestroyImage"));
+ dispatch.DestroyImage = reinterpret_cast<PFN_vkDestroyImage>(get_proc_addr(instance, "vkDestroyImage"));
if (UNLIKELY(!dispatch.DestroyImage)) {
- ALOGE("missing device proc: %s", "vkDestroyImage");
- success = false;
- }
- dispatch.GetImageSubresourceLayout = reinterpret_cast<PFN_vkGetImageSubresourceLayout>(get_proc_addr(device, "vkGetImageSubresourceLayout"));
- if (UNLIKELY(!dispatch.GetImageSubresourceLayout)) {
- ALOGE("missing device proc: %s", "vkGetImageSubresourceLayout");
- success = false;
- }
- dispatch.CreateImageView = reinterpret_cast<PFN_vkCreateImageView>(get_proc_addr(device, "vkCreateImageView"));
- if (UNLIKELY(!dispatch.CreateImageView)) {
- ALOGE("missing device proc: %s", "vkCreateImageView");
- success = false;
- }
- dispatch.DestroyImageView = reinterpret_cast<PFN_vkDestroyImageView>(get_proc_addr(device, "vkDestroyImageView"));
- if (UNLIKELY(!dispatch.DestroyImageView)) {
- ALOGE("missing device proc: %s", "vkDestroyImageView");
- success = false;
- }
- dispatch.CreateShaderModule = reinterpret_cast<PFN_vkCreateShaderModule>(get_proc_addr(device, "vkCreateShaderModule"));
- if (UNLIKELY(!dispatch.CreateShaderModule)) {
- ALOGE("missing device proc: %s", "vkCreateShaderModule");
- success = false;
- }
- dispatch.DestroyShaderModule = reinterpret_cast<PFN_vkDestroyShaderModule>(get_proc_addr(device, "vkDestroyShaderModule"));
- if (UNLIKELY(!dispatch.DestroyShaderModule)) {
- ALOGE("missing device proc: %s", "vkDestroyShaderModule");
- success = false;
- }
- dispatch.CreatePipelineCache = reinterpret_cast<PFN_vkCreatePipelineCache>(get_proc_addr(device, "vkCreatePipelineCache"));
- if (UNLIKELY(!dispatch.CreatePipelineCache)) {
- ALOGE("missing device proc: %s", "vkCreatePipelineCache");
- success = false;
- }
- dispatch.DestroyPipelineCache = reinterpret_cast<PFN_vkDestroyPipelineCache>(get_proc_addr(device, "vkDestroyPipelineCache"));
- if (UNLIKELY(!dispatch.DestroyPipelineCache)) {
- ALOGE("missing device proc: %s", "vkDestroyPipelineCache");
- success = false;
- }
- dispatch.GetPipelineCacheData = reinterpret_cast<PFN_vkGetPipelineCacheData>(get_proc_addr(device, "vkGetPipelineCacheData"));
- if (UNLIKELY(!dispatch.GetPipelineCacheData)) {
- ALOGE("missing device proc: %s", "vkGetPipelineCacheData");
- success = false;
- }
- dispatch.MergePipelineCaches = reinterpret_cast<PFN_vkMergePipelineCaches>(get_proc_addr(device, "vkMergePipelineCaches"));
- if (UNLIKELY(!dispatch.MergePipelineCaches)) {
- ALOGE("missing device proc: %s", "vkMergePipelineCaches");
- success = false;
- }
- dispatch.CreateGraphicsPipelines = reinterpret_cast<PFN_vkCreateGraphicsPipelines>(get_proc_addr(device, "vkCreateGraphicsPipelines"));
- if (UNLIKELY(!dispatch.CreateGraphicsPipelines)) {
- ALOGE("missing device proc: %s", "vkCreateGraphicsPipelines");
- success = false;
- }
- dispatch.CreateComputePipelines = reinterpret_cast<PFN_vkCreateComputePipelines>(get_proc_addr(device, "vkCreateComputePipelines"));
- if (UNLIKELY(!dispatch.CreateComputePipelines)) {
- ALOGE("missing device proc: %s", "vkCreateComputePipelines");
- success = false;
- }
- dispatch.DestroyPipeline = reinterpret_cast<PFN_vkDestroyPipeline>(get_proc_addr(device, "vkDestroyPipeline"));
- if (UNLIKELY(!dispatch.DestroyPipeline)) {
- ALOGE("missing device proc: %s", "vkDestroyPipeline");
- success = false;
- }
- dispatch.CreatePipelineLayout = reinterpret_cast<PFN_vkCreatePipelineLayout>(get_proc_addr(device, "vkCreatePipelineLayout"));
- if (UNLIKELY(!dispatch.CreatePipelineLayout)) {
- ALOGE("missing device proc: %s", "vkCreatePipelineLayout");
- success = false;
- }
- dispatch.DestroyPipelineLayout = reinterpret_cast<PFN_vkDestroyPipelineLayout>(get_proc_addr(device, "vkDestroyPipelineLayout"));
- if (UNLIKELY(!dispatch.DestroyPipelineLayout)) {
- ALOGE("missing device proc: %s", "vkDestroyPipelineLayout");
- success = false;
- }
- dispatch.CreateSampler = reinterpret_cast<PFN_vkCreateSampler>(get_proc_addr(device, "vkCreateSampler"));
- if (UNLIKELY(!dispatch.CreateSampler)) {
- ALOGE("missing device proc: %s", "vkCreateSampler");
- success = false;
- }
- dispatch.DestroySampler = reinterpret_cast<PFN_vkDestroySampler>(get_proc_addr(device, "vkDestroySampler"));
- if (UNLIKELY(!dispatch.DestroySampler)) {
- ALOGE("missing device proc: %s", "vkDestroySampler");
- success = false;
- }
- dispatch.CreateDescriptorSetLayout = reinterpret_cast<PFN_vkCreateDescriptorSetLayout>(get_proc_addr(device, "vkCreateDescriptorSetLayout"));
- if (UNLIKELY(!dispatch.CreateDescriptorSetLayout)) {
- ALOGE("missing device proc: %s", "vkCreateDescriptorSetLayout");
- success = false;
- }
- dispatch.DestroyDescriptorSetLayout = reinterpret_cast<PFN_vkDestroyDescriptorSetLayout>(get_proc_addr(device, "vkDestroyDescriptorSetLayout"));
- if (UNLIKELY(!dispatch.DestroyDescriptorSetLayout)) {
- ALOGE("missing device proc: %s", "vkDestroyDescriptorSetLayout");
- success = false;
- }
- dispatch.CreateDescriptorPool = reinterpret_cast<PFN_vkCreateDescriptorPool>(get_proc_addr(device, "vkCreateDescriptorPool"));
- if (UNLIKELY(!dispatch.CreateDescriptorPool)) {
- ALOGE("missing device proc: %s", "vkCreateDescriptorPool");
- success = false;
- }
- dispatch.DestroyDescriptorPool = reinterpret_cast<PFN_vkDestroyDescriptorPool>(get_proc_addr(device, "vkDestroyDescriptorPool"));
- if (UNLIKELY(!dispatch.DestroyDescriptorPool)) {
- ALOGE("missing device proc: %s", "vkDestroyDescriptorPool");
- success = false;
- }
- dispatch.ResetDescriptorPool = reinterpret_cast<PFN_vkResetDescriptorPool>(get_proc_addr(device, "vkResetDescriptorPool"));
- if (UNLIKELY(!dispatch.ResetDescriptorPool)) {
- ALOGE("missing device proc: %s", "vkResetDescriptorPool");
- success = false;
- }
- dispatch.AllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(get_proc_addr(device, "vkAllocateDescriptorSets"));
- if (UNLIKELY(!dispatch.AllocateDescriptorSets)) {
- ALOGE("missing device proc: %s", "vkAllocateDescriptorSets");
- success = false;
- }
- dispatch.FreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(get_proc_addr(device, "vkFreeDescriptorSets"));
- if (UNLIKELY(!dispatch.FreeDescriptorSets)) {
- ALOGE("missing device proc: %s", "vkFreeDescriptorSets");
- success = false;
- }
- dispatch.UpdateDescriptorSets = reinterpret_cast<PFN_vkUpdateDescriptorSets>(get_proc_addr(device, "vkUpdateDescriptorSets"));
- if (UNLIKELY(!dispatch.UpdateDescriptorSets)) {
- ALOGE("missing device proc: %s", "vkUpdateDescriptorSets");
- success = false;
- }
- dispatch.CreateFramebuffer = reinterpret_cast<PFN_vkCreateFramebuffer>(get_proc_addr(device, "vkCreateFramebuffer"));
- if (UNLIKELY(!dispatch.CreateFramebuffer)) {
- ALOGE("missing device proc: %s", "vkCreateFramebuffer");
- success = false;
- }
- dispatch.DestroyFramebuffer = reinterpret_cast<PFN_vkDestroyFramebuffer>(get_proc_addr(device, "vkDestroyFramebuffer"));
- if (UNLIKELY(!dispatch.DestroyFramebuffer)) {
- ALOGE("missing device proc: %s", "vkDestroyFramebuffer");
- success = false;
- }
- dispatch.CreateRenderPass = reinterpret_cast<PFN_vkCreateRenderPass>(get_proc_addr(device, "vkCreateRenderPass"));
- if (UNLIKELY(!dispatch.CreateRenderPass)) {
- ALOGE("missing device proc: %s", "vkCreateRenderPass");
- success = false;
- }
- dispatch.DestroyRenderPass = reinterpret_cast<PFN_vkDestroyRenderPass>(get_proc_addr(device, "vkDestroyRenderPass"));
- if (UNLIKELY(!dispatch.DestroyRenderPass)) {
- ALOGE("missing device proc: %s", "vkDestroyRenderPass");
- success = false;
- }
- dispatch.GetRenderAreaGranularity = reinterpret_cast<PFN_vkGetRenderAreaGranularity>(get_proc_addr(device, "vkGetRenderAreaGranularity"));
- if (UNLIKELY(!dispatch.GetRenderAreaGranularity)) {
- ALOGE("missing device proc: %s", "vkGetRenderAreaGranularity");
- success = false;
- }
- dispatch.CreateCommandPool = reinterpret_cast<PFN_vkCreateCommandPool>(get_proc_addr(device, "vkCreateCommandPool"));
- if (UNLIKELY(!dispatch.CreateCommandPool)) {
- ALOGE("missing device proc: %s", "vkCreateCommandPool");
- success = false;
- }
- dispatch.DestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(get_proc_addr(device, "vkDestroyCommandPool"));
- if (UNLIKELY(!dispatch.DestroyCommandPool)) {
- ALOGE("missing device proc: %s", "vkDestroyCommandPool");
- success = false;
- }
- dispatch.ResetCommandPool = reinterpret_cast<PFN_vkResetCommandPool>(get_proc_addr(device, "vkResetCommandPool"));
- if (UNLIKELY(!dispatch.ResetCommandPool)) {
- ALOGE("missing device proc: %s", "vkResetCommandPool");
- success = false;
- }
- dispatch.AllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(get_proc_addr(device, "vkAllocateCommandBuffers"));
- if (UNLIKELY(!dispatch.AllocateCommandBuffers)) {
- ALOGE("missing device proc: %s", "vkAllocateCommandBuffers");
- success = false;
- }
- dispatch.FreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(get_proc_addr(device, "vkFreeCommandBuffers"));
- if (UNLIKELY(!dispatch.FreeCommandBuffers)) {
- ALOGE("missing device proc: %s", "vkFreeCommandBuffers");
- success = false;
- }
- dispatch.BeginCommandBuffer = reinterpret_cast<PFN_vkBeginCommandBuffer>(get_proc_addr(device, "vkBeginCommandBuffer"));
- if (UNLIKELY(!dispatch.BeginCommandBuffer)) {
- ALOGE("missing device proc: %s", "vkBeginCommandBuffer");
- success = false;
- }
- dispatch.EndCommandBuffer = reinterpret_cast<PFN_vkEndCommandBuffer>(get_proc_addr(device, "vkEndCommandBuffer"));
- if (UNLIKELY(!dispatch.EndCommandBuffer)) {
- ALOGE("missing device proc: %s", "vkEndCommandBuffer");
- success = false;
- }
- dispatch.ResetCommandBuffer = reinterpret_cast<PFN_vkResetCommandBuffer>(get_proc_addr(device, "vkResetCommandBuffer"));
- if (UNLIKELY(!dispatch.ResetCommandBuffer)) {
- ALOGE("missing device proc: %s", "vkResetCommandBuffer");
- success = false;
- }
- dispatch.CmdBindPipeline = reinterpret_cast<PFN_vkCmdBindPipeline>(get_proc_addr(device, "vkCmdBindPipeline"));
- if (UNLIKELY(!dispatch.CmdBindPipeline)) {
- ALOGE("missing device proc: %s", "vkCmdBindPipeline");
+ ALOGE("missing driver proc: %s", "vkDestroyImage");
success = false;
}
- dispatch.CmdSetViewport = reinterpret_cast<PFN_vkCmdSetViewport>(get_proc_addr(device, "vkCmdSetViewport"));
- if (UNLIKELY(!dispatch.CmdSetViewport)) {
- ALOGE("missing device proc: %s", "vkCmdSetViewport");
+ dispatch.GetSwapchainGrallocUsageANDROID = reinterpret_cast<PFN_vkGetSwapchainGrallocUsageANDROID>(get_proc_addr(instance, "vkGetSwapchainGrallocUsageANDROID"));
+ if (UNLIKELY(!dispatch.GetSwapchainGrallocUsageANDROID)) {
+ ALOGE("missing driver proc: %s", "vkGetSwapchainGrallocUsageANDROID");
success = false;
}
- dispatch.CmdSetScissor = reinterpret_cast<PFN_vkCmdSetScissor>(get_proc_addr(device, "vkCmdSetScissor"));
- if (UNLIKELY(!dispatch.CmdSetScissor)) {
- ALOGE("missing device proc: %s", "vkCmdSetScissor");
+ dispatch.AcquireImageANDROID = reinterpret_cast<PFN_vkAcquireImageANDROID>(get_proc_addr(instance, "vkAcquireImageANDROID"));
+ if (UNLIKELY(!dispatch.AcquireImageANDROID)) {
+ ALOGE("missing driver proc: %s", "vkAcquireImageANDROID");
success = false;
}
- dispatch.CmdSetLineWidth = reinterpret_cast<PFN_vkCmdSetLineWidth>(get_proc_addr(device, "vkCmdSetLineWidth"));
- if (UNLIKELY(!dispatch.CmdSetLineWidth)) {
- ALOGE("missing device proc: %s", "vkCmdSetLineWidth");
- success = false;
- }
- dispatch.CmdSetDepthBias = reinterpret_cast<PFN_vkCmdSetDepthBias>(get_proc_addr(device, "vkCmdSetDepthBias"));
- if (UNLIKELY(!dispatch.CmdSetDepthBias)) {
- ALOGE("missing device proc: %s", "vkCmdSetDepthBias");
- success = false;
- }
- dispatch.CmdSetBlendConstants = reinterpret_cast<PFN_vkCmdSetBlendConstants>(get_proc_addr(device, "vkCmdSetBlendConstants"));
- if (UNLIKELY(!dispatch.CmdSetBlendConstants)) {
- ALOGE("missing device proc: %s", "vkCmdSetBlendConstants");
- success = false;
- }
- dispatch.CmdSetDepthBounds = reinterpret_cast<PFN_vkCmdSetDepthBounds>(get_proc_addr(device, "vkCmdSetDepthBounds"));
- if (UNLIKELY(!dispatch.CmdSetDepthBounds)) {
- ALOGE("missing device proc: %s", "vkCmdSetDepthBounds");
- success = false;
- }
- dispatch.CmdSetStencilCompareMask = reinterpret_cast<PFN_vkCmdSetStencilCompareMask>(get_proc_addr(device, "vkCmdSetStencilCompareMask"));
- if (UNLIKELY(!dispatch.CmdSetStencilCompareMask)) {
- ALOGE("missing device proc: %s", "vkCmdSetStencilCompareMask");
- success = false;
- }
- dispatch.CmdSetStencilWriteMask = reinterpret_cast<PFN_vkCmdSetStencilWriteMask>(get_proc_addr(device, "vkCmdSetStencilWriteMask"));
- if (UNLIKELY(!dispatch.CmdSetStencilWriteMask)) {
- ALOGE("missing device proc: %s", "vkCmdSetStencilWriteMask");
- success = false;
- }
- dispatch.CmdSetStencilReference = reinterpret_cast<PFN_vkCmdSetStencilReference>(get_proc_addr(device, "vkCmdSetStencilReference"));
- if (UNLIKELY(!dispatch.CmdSetStencilReference)) {
- ALOGE("missing device proc: %s", "vkCmdSetStencilReference");
- success = false;
- }
- dispatch.CmdBindDescriptorSets = reinterpret_cast<PFN_vkCmdBindDescriptorSets>(get_proc_addr(device, "vkCmdBindDescriptorSets"));
- if (UNLIKELY(!dispatch.CmdBindDescriptorSets)) {
- ALOGE("missing device proc: %s", "vkCmdBindDescriptorSets");
- success = false;
- }
- dispatch.CmdBindIndexBuffer = reinterpret_cast<PFN_vkCmdBindIndexBuffer>(get_proc_addr(device, "vkCmdBindIndexBuffer"));
- if (UNLIKELY(!dispatch.CmdBindIndexBuffer)) {
- ALOGE("missing device proc: %s", "vkCmdBindIndexBuffer");
- success = false;
- }
- dispatch.CmdBindVertexBuffers = reinterpret_cast<PFN_vkCmdBindVertexBuffers>(get_proc_addr(device, "vkCmdBindVertexBuffers"));
- if (UNLIKELY(!dispatch.CmdBindVertexBuffers)) {
- ALOGE("missing device proc: %s", "vkCmdBindVertexBuffers");
- success = false;
- }
- dispatch.CmdDraw = reinterpret_cast<PFN_vkCmdDraw>(get_proc_addr(device, "vkCmdDraw"));
- if (UNLIKELY(!dispatch.CmdDraw)) {
- ALOGE("missing device proc: %s", "vkCmdDraw");
- success = false;
- }
- dispatch.CmdDrawIndexed = reinterpret_cast<PFN_vkCmdDrawIndexed>(get_proc_addr(device, "vkCmdDrawIndexed"));
- if (UNLIKELY(!dispatch.CmdDrawIndexed)) {
- ALOGE("missing device proc: %s", "vkCmdDrawIndexed");
- success = false;
- }
- dispatch.CmdDrawIndirect = reinterpret_cast<PFN_vkCmdDrawIndirect>(get_proc_addr(device, "vkCmdDrawIndirect"));
- if (UNLIKELY(!dispatch.CmdDrawIndirect)) {
- ALOGE("missing device proc: %s", "vkCmdDrawIndirect");
- success = false;
- }
- dispatch.CmdDrawIndexedIndirect = reinterpret_cast<PFN_vkCmdDrawIndexedIndirect>(get_proc_addr(device, "vkCmdDrawIndexedIndirect"));
- if (UNLIKELY(!dispatch.CmdDrawIndexedIndirect)) {
- ALOGE("missing device proc: %s", "vkCmdDrawIndexedIndirect");
- success = false;
- }
- dispatch.CmdDispatch = reinterpret_cast<PFN_vkCmdDispatch>(get_proc_addr(device, "vkCmdDispatch"));
- if (UNLIKELY(!dispatch.CmdDispatch)) {
- ALOGE("missing device proc: %s", "vkCmdDispatch");
- success = false;
- }
- dispatch.CmdDispatchIndirect = reinterpret_cast<PFN_vkCmdDispatchIndirect>(get_proc_addr(device, "vkCmdDispatchIndirect"));
- if (UNLIKELY(!dispatch.CmdDispatchIndirect)) {
- ALOGE("missing device proc: %s", "vkCmdDispatchIndirect");
- success = false;
- }
- dispatch.CmdCopyBuffer = reinterpret_cast<PFN_vkCmdCopyBuffer>(get_proc_addr(device, "vkCmdCopyBuffer"));
- if (UNLIKELY(!dispatch.CmdCopyBuffer)) {
- ALOGE("missing device proc: %s", "vkCmdCopyBuffer");
- success = false;
- }
- dispatch.CmdCopyImage = reinterpret_cast<PFN_vkCmdCopyImage>(get_proc_addr(device, "vkCmdCopyImage"));
- if (UNLIKELY(!dispatch.CmdCopyImage)) {
- ALOGE("missing device proc: %s", "vkCmdCopyImage");
- success = false;
- }
- dispatch.CmdBlitImage = reinterpret_cast<PFN_vkCmdBlitImage>(get_proc_addr(device, "vkCmdBlitImage"));
- if (UNLIKELY(!dispatch.CmdBlitImage)) {
- ALOGE("missing device proc: %s", "vkCmdBlitImage");
- success = false;
- }
- dispatch.CmdCopyBufferToImage = reinterpret_cast<PFN_vkCmdCopyBufferToImage>(get_proc_addr(device, "vkCmdCopyBufferToImage"));
- if (UNLIKELY(!dispatch.CmdCopyBufferToImage)) {
- ALOGE("missing device proc: %s", "vkCmdCopyBufferToImage");
- success = false;
- }
- dispatch.CmdCopyImageToBuffer = reinterpret_cast<PFN_vkCmdCopyImageToBuffer>(get_proc_addr(device, "vkCmdCopyImageToBuffer"));
- if (UNLIKELY(!dispatch.CmdCopyImageToBuffer)) {
- ALOGE("missing device proc: %s", "vkCmdCopyImageToBuffer");
- success = false;
- }
- dispatch.CmdUpdateBuffer = reinterpret_cast<PFN_vkCmdUpdateBuffer>(get_proc_addr(device, "vkCmdUpdateBuffer"));
- if (UNLIKELY(!dispatch.CmdUpdateBuffer)) {
- ALOGE("missing device proc: %s", "vkCmdUpdateBuffer");
- success = false;
- }
- dispatch.CmdFillBuffer = reinterpret_cast<PFN_vkCmdFillBuffer>(get_proc_addr(device, "vkCmdFillBuffer"));
- if (UNLIKELY(!dispatch.CmdFillBuffer)) {
- ALOGE("missing device proc: %s", "vkCmdFillBuffer");
- success = false;
- }
- dispatch.CmdClearColorImage = reinterpret_cast<PFN_vkCmdClearColorImage>(get_proc_addr(device, "vkCmdClearColorImage"));
- if (UNLIKELY(!dispatch.CmdClearColorImage)) {
- ALOGE("missing device proc: %s", "vkCmdClearColorImage");
- success = false;
- }
- dispatch.CmdClearDepthStencilImage = reinterpret_cast<PFN_vkCmdClearDepthStencilImage>(get_proc_addr(device, "vkCmdClearDepthStencilImage"));
- if (UNLIKELY(!dispatch.CmdClearDepthStencilImage)) {
- ALOGE("missing device proc: %s", "vkCmdClearDepthStencilImage");
- success = false;
- }
- dispatch.CmdClearAttachments = reinterpret_cast<PFN_vkCmdClearAttachments>(get_proc_addr(device, "vkCmdClearAttachments"));
- if (UNLIKELY(!dispatch.CmdClearAttachments)) {
- ALOGE("missing device proc: %s", "vkCmdClearAttachments");
- success = false;
- }
- dispatch.CmdResolveImage = reinterpret_cast<PFN_vkCmdResolveImage>(get_proc_addr(device, "vkCmdResolveImage"));
- if (UNLIKELY(!dispatch.CmdResolveImage)) {
- ALOGE("missing device proc: %s", "vkCmdResolveImage");
- success = false;
- }
- dispatch.CmdSetEvent = reinterpret_cast<PFN_vkCmdSetEvent>(get_proc_addr(device, "vkCmdSetEvent"));
- if (UNLIKELY(!dispatch.CmdSetEvent)) {
- ALOGE("missing device proc: %s", "vkCmdSetEvent");
- success = false;
- }
- dispatch.CmdResetEvent = reinterpret_cast<PFN_vkCmdResetEvent>(get_proc_addr(device, "vkCmdResetEvent"));
- if (UNLIKELY(!dispatch.CmdResetEvent)) {
- ALOGE("missing device proc: %s", "vkCmdResetEvent");
- success = false;
- }
- dispatch.CmdWaitEvents = reinterpret_cast<PFN_vkCmdWaitEvents>(get_proc_addr(device, "vkCmdWaitEvents"));
- if (UNLIKELY(!dispatch.CmdWaitEvents)) {
- ALOGE("missing device proc: %s", "vkCmdWaitEvents");
- success = false;
- }
- dispatch.CmdPipelineBarrier = reinterpret_cast<PFN_vkCmdPipelineBarrier>(get_proc_addr(device, "vkCmdPipelineBarrier"));
- if (UNLIKELY(!dispatch.CmdPipelineBarrier)) {
- ALOGE("missing device proc: %s", "vkCmdPipelineBarrier");
- success = false;
- }
- dispatch.CmdBeginQuery = reinterpret_cast<PFN_vkCmdBeginQuery>(get_proc_addr(device, "vkCmdBeginQuery"));
- if (UNLIKELY(!dispatch.CmdBeginQuery)) {
- ALOGE("missing device proc: %s", "vkCmdBeginQuery");
- success = false;
- }
- dispatch.CmdEndQuery = reinterpret_cast<PFN_vkCmdEndQuery>(get_proc_addr(device, "vkCmdEndQuery"));
- if (UNLIKELY(!dispatch.CmdEndQuery)) {
- ALOGE("missing device proc: %s", "vkCmdEndQuery");
- success = false;
- }
- dispatch.CmdResetQueryPool = reinterpret_cast<PFN_vkCmdResetQueryPool>(get_proc_addr(device, "vkCmdResetQueryPool"));
- if (UNLIKELY(!dispatch.CmdResetQueryPool)) {
- ALOGE("missing device proc: %s", "vkCmdResetQueryPool");
- success = false;
- }
- dispatch.CmdWriteTimestamp = reinterpret_cast<PFN_vkCmdWriteTimestamp>(get_proc_addr(device, "vkCmdWriteTimestamp"));
- if (UNLIKELY(!dispatch.CmdWriteTimestamp)) {
- ALOGE("missing device proc: %s", "vkCmdWriteTimestamp");
- success = false;
- }
- dispatch.CmdCopyQueryPoolResults = reinterpret_cast<PFN_vkCmdCopyQueryPoolResults>(get_proc_addr(device, "vkCmdCopyQueryPoolResults"));
- if (UNLIKELY(!dispatch.CmdCopyQueryPoolResults)) {
- ALOGE("missing device proc: %s", "vkCmdCopyQueryPoolResults");
- success = false;
- }
- dispatch.CmdPushConstants = reinterpret_cast<PFN_vkCmdPushConstants>(get_proc_addr(device, "vkCmdPushConstants"));
- if (UNLIKELY(!dispatch.CmdPushConstants)) {
- ALOGE("missing device proc: %s", "vkCmdPushConstants");
- success = false;
- }
- dispatch.CmdBeginRenderPass = reinterpret_cast<PFN_vkCmdBeginRenderPass>(get_proc_addr(device, "vkCmdBeginRenderPass"));
- if (UNLIKELY(!dispatch.CmdBeginRenderPass)) {
- ALOGE("missing device proc: %s", "vkCmdBeginRenderPass");
- success = false;
- }
- dispatch.CmdNextSubpass = reinterpret_cast<PFN_vkCmdNextSubpass>(get_proc_addr(device, "vkCmdNextSubpass"));
- if (UNLIKELY(!dispatch.CmdNextSubpass)) {
- ALOGE("missing device proc: %s", "vkCmdNextSubpass");
- success = false;
- }
- dispatch.CmdEndRenderPass = reinterpret_cast<PFN_vkCmdEndRenderPass>(get_proc_addr(device, "vkCmdEndRenderPass"));
- if (UNLIKELY(!dispatch.CmdEndRenderPass)) {
- ALOGE("missing device proc: %s", "vkCmdEndRenderPass");
- success = false;
- }
- dispatch.CmdExecuteCommands = reinterpret_cast<PFN_vkCmdExecuteCommands>(get_proc_addr(device, "vkCmdExecuteCommands"));
- if (UNLIKELY(!dispatch.CmdExecuteCommands)) {
- ALOGE("missing device proc: %s", "vkCmdExecuteCommands");
- success = false;
- }
- dispatch.CreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(get_proc_addr(device, "vkCreateSwapchainKHR"));
- if (UNLIKELY(!dispatch.CreateSwapchainKHR)) {
- ALOGE("missing device proc: %s", "vkCreateSwapchainKHR");
- success = false;
- }
- dispatch.DestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(get_proc_addr(device, "vkDestroySwapchainKHR"));
- if (UNLIKELY(!dispatch.DestroySwapchainKHR)) {
- ALOGE("missing device proc: %s", "vkDestroySwapchainKHR");
- success = false;
- }
- dispatch.GetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(get_proc_addr(device, "vkGetSwapchainImagesKHR"));
- if (UNLIKELY(!dispatch.GetSwapchainImagesKHR)) {
- ALOGE("missing device proc: %s", "vkGetSwapchainImagesKHR");
- success = false;
- }
- dispatch.AcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(get_proc_addr(device, "vkAcquireNextImageKHR"));
- if (UNLIKELY(!dispatch.AcquireNextImageKHR)) {
- ALOGE("missing device proc: %s", "vkAcquireNextImageKHR");
- success = false;
- }
- dispatch.QueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(get_proc_addr(device, "vkQueuePresentKHR"));
- if (UNLIKELY(!dispatch.QueuePresentKHR)) {
- ALOGE("missing device proc: %s", "vkQueuePresentKHR");
- success = false;
- }
- // clang-format on
- return success;
-}
-
-bool LoadDriverDispatchTable(VkInstance instance,
- PFN_vkGetInstanceProcAddr get_proc_addr,
- const InstanceExtensionSet& extensions,
- DriverDispatchTable& dispatch) {
- bool success = true;
- // clang-format off
- dispatch.DestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(get_proc_addr(instance, "vkDestroyInstance"));
- if (UNLIKELY(!dispatch.DestroyInstance)) {
- ALOGE("missing driver proc: %s", "vkDestroyInstance");
- success = false;
- }
- dispatch.EnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(get_proc_addr(instance, "vkEnumeratePhysicalDevices"));
- if (UNLIKELY(!dispatch.EnumeratePhysicalDevices)) {
- ALOGE("missing driver proc: %s", "vkEnumeratePhysicalDevices");
- success = false;
- }
- dispatch.GetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceProperties"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceProperties)) {
- ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceProperties");
- success = false;
- }
- dispatch.GetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceQueueFamilyProperties"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceQueueFamilyProperties)) {
- ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceQueueFamilyProperties");
- success = false;
- }
- dispatch.GetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceMemoryProperties"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceMemoryProperties)) {
- ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceMemoryProperties");
- success = false;
- }
- dispatch.GetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(get_proc_addr(instance, "vkGetPhysicalDeviceFeatures"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceFeatures)) {
- ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceFeatures");
- success = false;
- }
- dispatch.GetPhysicalDeviceFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceFormatProperties"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceFormatProperties)) {
- ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceFormatProperties");
- success = false;
- }
- dispatch.GetPhysicalDeviceImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceImageFormatProperties"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceImageFormatProperties)) {
- ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceImageFormatProperties");
- success = false;
- }
- dispatch.CreateDevice = reinterpret_cast<PFN_vkCreateDevice>(get_proc_addr(instance, "vkCreateDevice"));
- if (UNLIKELY(!dispatch.CreateDevice)) {
- ALOGE("missing driver proc: %s", "vkCreateDevice");
- success = false;
- }
- dispatch.EnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(get_proc_addr(instance, "vkEnumerateDeviceExtensionProperties"));
- if (UNLIKELY(!dispatch.EnumerateDeviceExtensionProperties)) {
- ALOGE("missing driver proc: %s", "vkEnumerateDeviceExtensionProperties");
- success = false;
- }
- dispatch.GetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceSparseImageFormatProperties>(get_proc_addr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"));
- if (UNLIKELY(!dispatch.GetPhysicalDeviceSparseImageFormatProperties)) {
- ALOGE("missing driver proc: %s", "vkGetPhysicalDeviceSparseImageFormatProperties");
- success = false;
- }
- if (extensions[kEXT_debug_report]) {
- dispatch.CreateDebugReportCallbackEXT = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(get_proc_addr(instance, "vkCreateDebugReportCallbackEXT"));
- if (UNLIKELY(!dispatch.CreateDebugReportCallbackEXT)) {
- ALOGE("missing driver proc: %s", "vkCreateDebugReportCallbackEXT");
- success = false;
- }
- }
- if (extensions[kEXT_debug_report]) {
- dispatch.DestroyDebugReportCallbackEXT = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(get_proc_addr(instance, "vkDestroyDebugReportCallbackEXT"));
- if (UNLIKELY(!dispatch.DestroyDebugReportCallbackEXT)) {
- ALOGE("missing driver proc: %s", "vkDestroyDebugReportCallbackEXT");
- success = false;
- }
- }
- if (extensions[kEXT_debug_report]) {
- dispatch.DebugReportMessageEXT = reinterpret_cast<PFN_vkDebugReportMessageEXT>(get_proc_addr(instance, "vkDebugReportMessageEXT"));
- if (UNLIKELY(!dispatch.DebugReportMessageEXT)) {
- ALOGE("missing driver proc: %s", "vkDebugReportMessageEXT");
- success = false;
- }
- }
- dispatch.GetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(get_proc_addr(instance, "vkGetDeviceProcAddr"));
- if (UNLIKELY(!dispatch.GetDeviceProcAddr)) {
- ALOGE("missing driver proc: %s", "vkGetDeviceProcAddr");
- success = false;
- }
- dispatch.CreateImage = reinterpret_cast<PFN_vkCreateImage>(get_proc_addr(instance, "vkCreateImage"));
- if (UNLIKELY(!dispatch.CreateImage)) {
- ALOGE("missing driver proc: %s", "vkCreateImage");
- success = false;
- }
- dispatch.DestroyImage = reinterpret_cast<PFN_vkDestroyImage>(get_proc_addr(instance, "vkDestroyImage"));
- if (UNLIKELY(!dispatch.DestroyImage)) {
- ALOGE("missing driver proc: %s", "vkDestroyImage");
- success = false;
- }
- dispatch.GetSwapchainGrallocUsageANDROID = reinterpret_cast<PFN_vkGetSwapchainGrallocUsageANDROID>(get_proc_addr(instance, "vkGetSwapchainGrallocUsageANDROID"));
- if (UNLIKELY(!dispatch.GetSwapchainGrallocUsageANDROID)) {
- ALOGE("missing driver proc: %s", "vkGetSwapchainGrallocUsageANDROID");
- success = false;
- }
- dispatch.AcquireImageANDROID = reinterpret_cast<PFN_vkAcquireImageANDROID>(get_proc_addr(instance, "vkAcquireImageANDROID"));
- if (UNLIKELY(!dispatch.AcquireImageANDROID)) {
- ALOGE("missing driver proc: %s", "vkAcquireImageANDROID");
- success = false;
- }
- dispatch.QueueSignalReleaseImageANDROID = reinterpret_cast<PFN_vkQueueSignalReleaseImageANDROID>(get_proc_addr(instance, "vkQueueSignalReleaseImageANDROID"));
- if (UNLIKELY(!dispatch.QueueSignalReleaseImageANDROID)) {
- ALOGE("missing driver proc: %s", "vkQueueSignalReleaseImageANDROID");
+ dispatch.QueueSignalReleaseImageANDROID = reinterpret_cast<PFN_vkQueueSignalReleaseImageANDROID>(get_proc_addr(instance, "vkQueueSignalReleaseImageANDROID"));
+ if (UNLIKELY(!dispatch.QueueSignalReleaseImageANDROID)) {
+ ALOGE("missing driver proc: %s", "vkQueueSignalReleaseImageANDROID");
success = false;
}
// clang-format on
}
} // namespace vulkan
-
-// clang-format off
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
- return CreateInstance_Top(pCreateInfo, pAllocator, pInstance);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
- DestroyInstance_Top(instance, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) {
- return GetDispatchTable(instance).EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) {
- return GetDeviceProcAddr_Top(device, pName);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
- return GetInstanceProcAddr_Top(instance, pName);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
- GetDispatchTable(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
- GetDispatchTable(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
- GetDispatchTable(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
- GetDispatchTable(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
- GetDispatchTable(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
- return GetDispatchTable(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
- return CreateDevice_Top(physicalDevice, pCreateInfo, pAllocator, pDevice);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
- DestroyDevice_Top(device, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
- return EnumerateInstanceLayerProperties_Top(pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
- return EnumerateInstanceExtensionProperties_Top(pLayerName, pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
- return EnumerateDeviceLayerProperties_Top(physicalDevice, pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
- return EnumerateDeviceExtensionProperties_Top(physicalDevice, pLayerName, pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
- GetDeviceQueue_Top(device, queueFamilyIndex, queueIndex, pQueue);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
- return GetDispatchTable(queue).QueueSubmit(queue, submitCount, pSubmits, fence);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkQueueWaitIdle(VkQueue queue) {
- return GetDispatchTable(queue).QueueWaitIdle(queue);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkDeviceWaitIdle(VkDevice device) {
- return GetDispatchTable(device).DeviceWaitIdle(device);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
- return GetDispatchTable(device).AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).FreeMemory(device, memory, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
- return GetDispatchTable(device).MapMemory(device, memory, offset, size, flags, ppData);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
- GetDispatchTable(device).UnmapMemory(device, memory);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
- return GetDispatchTable(device).FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
- return GetDispatchTable(device).InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
- GetDispatchTable(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
- GetDispatchTable(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
- return GetDispatchTable(device).BindBufferMemory(device, buffer, memory, memoryOffset);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
- GetDispatchTable(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
- return GetDispatchTable(device).BindImageMemory(device, image, memory, memoryOffset);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
- GetDispatchTable(device).GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
- GetDispatchTable(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) {
- return GetDispatchTable(queue).QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
- return GetDispatchTable(device).CreateFence(device, pCreateInfo, pAllocator, pFence);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyFence(device, fence, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
- return GetDispatchTable(device).ResetFences(device, fenceCount, pFences);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
- return GetDispatchTable(device).GetFenceStatus(device, fence);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
- return GetDispatchTable(device).WaitForFences(device, fenceCount, pFences, waitAll, timeout);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
- return GetDispatchTable(device).CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroySemaphore(device, semaphore, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
- return GetDispatchTable(device).CreateEvent(device, pCreateInfo, pAllocator, pEvent);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyEvent(device, event, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetEventStatus(VkDevice device, VkEvent event) {
- return GetDispatchTable(device).GetEventStatus(device, event);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkSetEvent(VkDevice device, VkEvent event) {
- return GetDispatchTable(device).SetEvent(device, event);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetEvent(VkDevice device, VkEvent event) {
- return GetDispatchTable(device).ResetEvent(device, event);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
- return GetDispatchTable(device).CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyQueryPool(device, queryPool, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
- return GetDispatchTable(device).GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
- return GetDispatchTable(device).CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyBuffer(device, buffer, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
- return GetDispatchTable(device).CreateBufferView(device, pCreateInfo, pAllocator, pView);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyBufferView(device, bufferView, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
- return GetDispatchTable(device).CreateImage(device, pCreateInfo, pAllocator, pImage);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyImage(device, image, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
- GetDispatchTable(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
- return GetDispatchTable(device).CreateImageView(device, pCreateInfo, pAllocator, pView);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyImageView(device, imageView, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
- return GetDispatchTable(device).CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyShaderModule(device, shaderModule, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
- return GetDispatchTable(device).CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyPipelineCache(device, pipelineCache, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
- return GetDispatchTable(device).GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
- return GetDispatchTable(device).MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
- return GetDispatchTable(device).CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
- return GetDispatchTable(device).CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyPipeline(device, pipeline, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
- return GetDispatchTable(device).CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyPipelineLayout(device, pipelineLayout, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
- return GetDispatchTable(device).CreateSampler(device, pCreateInfo, pAllocator, pSampler);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroySampler(device, sampler, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
- return GetDispatchTable(device).CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
- return GetDispatchTable(device).CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyDescriptorPool(device, descriptorPool, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
- return GetDispatchTable(device).ResetDescriptorPool(device, descriptorPool, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
- return GetDispatchTable(device).AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
- return GetDispatchTable(device).FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
- GetDispatchTable(device).UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
- return GetDispatchTable(device).CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyFramebuffer(device, framebuffer, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
- return GetDispatchTable(device).CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyRenderPass(device, renderPass, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
- GetDispatchTable(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
- return GetDispatchTable(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroyCommandPool(device, commandPool, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
- return GetDispatchTable(device).ResetCommandPool(device, commandPool, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
- return AllocateCommandBuffers_Top(device, pAllocateInfo, pCommandBuffers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
- GetDispatchTable(device).FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
- return GetDispatchTable(commandBuffer).BeginCommandBuffer(commandBuffer, pBeginInfo);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
- return GetDispatchTable(commandBuffer).EndCommandBuffer(commandBuffer);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
- return GetDispatchTable(commandBuffer).ResetCommandBuffer(commandBuffer, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
- GetDispatchTable(commandBuffer).CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) {
- GetDispatchTable(commandBuffer).CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) {
- GetDispatchTable(commandBuffer).CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
- GetDispatchTable(commandBuffer).CmdSetLineWidth(commandBuffer, lineWidth);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
- GetDispatchTable(commandBuffer).CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
- GetDispatchTable(commandBuffer).CmdSetBlendConstants(commandBuffer, blendConstants);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
- GetDispatchTable(commandBuffer).CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
- GetDispatchTable(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
- GetDispatchTable(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
- GetDispatchTable(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, reference);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
- GetDispatchTable(commandBuffer).CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
- GetDispatchTable(commandBuffer).CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
- GetDispatchTable(commandBuffer).CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
- GetDispatchTable(commandBuffer).CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
- GetDispatchTable(commandBuffer).CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
- GetDispatchTable(commandBuffer).CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
- GetDispatchTable(commandBuffer).CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
- GetDispatchTable(commandBuffer).CmdDispatch(commandBuffer, x, y, z);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
- GetDispatchTable(commandBuffer).CmdDispatchIndirect(commandBuffer, buffer, offset);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
- GetDispatchTable(commandBuffer).CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
- GetDispatchTable(commandBuffer).CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
- GetDispatchTable(commandBuffer).CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
- GetDispatchTable(commandBuffer).CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
- GetDispatchTable(commandBuffer).CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) {
- GetDispatchTable(commandBuffer).CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
- GetDispatchTable(commandBuffer).CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
- GetDispatchTable(commandBuffer).CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
- GetDispatchTable(commandBuffer).CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
- GetDispatchTable(commandBuffer).CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
- GetDispatchTable(commandBuffer).CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
- GetDispatchTable(commandBuffer).CmdSetEvent(commandBuffer, event, stageMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
- GetDispatchTable(commandBuffer).CmdResetEvent(commandBuffer, event, stageMask);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
- GetDispatchTable(commandBuffer).CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
- GetDispatchTable(commandBuffer).CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {
- GetDispatchTable(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, query, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
- GetDispatchTable(commandBuffer).CmdEndQuery(commandBuffer, queryPool, query);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
- GetDispatchTable(commandBuffer).CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {
- GetDispatchTable(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
- GetDispatchTable(commandBuffer).CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) {
- GetDispatchTable(commandBuffer).CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
- GetDispatchTable(commandBuffer).CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
- GetDispatchTable(commandBuffer).CmdNextSubpass(commandBuffer, contents);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
- GetDispatchTable(commandBuffer).CmdEndRenderPass(commandBuffer);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
- GetDispatchTable(commandBuffer).CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(instance).DestroySurfaceKHR(instance, surface, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) {
- return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
- return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
- return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
- return GetDispatchTable(physicalDevice).GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
- return GetDispatchTable(device).CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
- GetDispatchTable(device).DestroySwapchainKHR(device, swapchain, pAllocator);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
- return GetDispatchTable(device).GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
- return GetDispatchTable(device).AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
- return GetDispatchTable(queue).QueuePresentKHR(queue, pPresentInfo);
-}
-
-__attribute__((visibility("default")))
-VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
- return GetDispatchTable(instance).CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-}
-
-// clang-format on
// WARNING: This file is generated. See ../README.md for instructions.
-#define VK_USE_PLATFORM_ANDROID_KHR
#include <vulkan/vk_android_native_buffer.h>
#include <vulkan/vulkan.h>
namespace vulkan {
-struct InstanceDispatchTable {
+struct DriverDispatchTable {
// clang-format off
PFN_vkDestroyInstance DestroyInstance;
PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
PFN_vkCreateDevice CreateDevice;
PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
- PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
- PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
- PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
- PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
- PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
- PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;
PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT;
PFN_vkDebugReportMessageEXT DebugReportMessageEXT;
- // clang-format on
-};
-
-struct DeviceDispatchTable {
- // clang-format off
+ PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
PFN_vkDestroyDevice DestroyDevice;
PFN_vkGetDeviceQueue GetDeviceQueue;
- PFN_vkQueueSubmit QueueSubmit;
- PFN_vkQueueWaitIdle QueueWaitIdle;
- PFN_vkDeviceWaitIdle DeviceWaitIdle;
- PFN_vkAllocateMemory AllocateMemory;
- PFN_vkFreeMemory FreeMemory;
- PFN_vkMapMemory MapMemory;
- PFN_vkUnmapMemory UnmapMemory;
- PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges;
- PFN_vkInvalidateMappedMemoryRanges InvalidateMappedMemoryRanges;
- PFN_vkGetDeviceMemoryCommitment GetDeviceMemoryCommitment;
- PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements;
- PFN_vkBindBufferMemory BindBufferMemory;
- PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements;
- PFN_vkBindImageMemory BindImageMemory;
- PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements;
- PFN_vkQueueBindSparse QueueBindSparse;
- PFN_vkCreateFence CreateFence;
- PFN_vkDestroyFence DestroyFence;
- PFN_vkResetFences ResetFences;
- PFN_vkGetFenceStatus GetFenceStatus;
- PFN_vkWaitForFences WaitForFences;
- PFN_vkCreateSemaphore CreateSemaphore;
- PFN_vkDestroySemaphore DestroySemaphore;
- PFN_vkCreateEvent CreateEvent;
- PFN_vkDestroyEvent DestroyEvent;
- PFN_vkGetEventStatus GetEventStatus;
- PFN_vkSetEvent SetEvent;
- PFN_vkResetEvent ResetEvent;
- PFN_vkCreateQueryPool CreateQueryPool;
- PFN_vkDestroyQueryPool DestroyQueryPool;
- PFN_vkGetQueryPoolResults GetQueryPoolResults;
- PFN_vkCreateBuffer CreateBuffer;
- PFN_vkDestroyBuffer DestroyBuffer;
- PFN_vkCreateBufferView CreateBufferView;
- PFN_vkDestroyBufferView DestroyBufferView;
- PFN_vkCreateImage CreateImage;
- PFN_vkDestroyImage DestroyImage;
- PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout;
- PFN_vkCreateImageView CreateImageView;
- PFN_vkDestroyImageView DestroyImageView;
- PFN_vkCreateShaderModule CreateShaderModule;
- PFN_vkDestroyShaderModule DestroyShaderModule;
- PFN_vkCreatePipelineCache CreatePipelineCache;
- PFN_vkDestroyPipelineCache DestroyPipelineCache;
- PFN_vkGetPipelineCacheData GetPipelineCacheData;
- PFN_vkMergePipelineCaches MergePipelineCaches;
- PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines;
- PFN_vkCreateComputePipelines CreateComputePipelines;
- PFN_vkDestroyPipeline DestroyPipeline;
- PFN_vkCreatePipelineLayout CreatePipelineLayout;
- PFN_vkDestroyPipelineLayout DestroyPipelineLayout;
- PFN_vkCreateSampler CreateSampler;
- PFN_vkDestroySampler DestroySampler;
- PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout;
- PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout;
- PFN_vkCreateDescriptorPool CreateDescriptorPool;
- PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
- PFN_vkResetDescriptorPool ResetDescriptorPool;
- PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
- PFN_vkFreeDescriptorSets FreeDescriptorSets;
- PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
- PFN_vkCreateFramebuffer CreateFramebuffer;
- PFN_vkDestroyFramebuffer DestroyFramebuffer;
- PFN_vkCreateRenderPass CreateRenderPass;
- PFN_vkDestroyRenderPass DestroyRenderPass;
- PFN_vkGetRenderAreaGranularity GetRenderAreaGranularity;
- PFN_vkCreateCommandPool CreateCommandPool;
- PFN_vkDestroyCommandPool DestroyCommandPool;
- PFN_vkResetCommandPool ResetCommandPool;
PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
- PFN_vkFreeCommandBuffers FreeCommandBuffers;
- PFN_vkBeginCommandBuffer BeginCommandBuffer;
- PFN_vkEndCommandBuffer EndCommandBuffer;
- PFN_vkResetCommandBuffer ResetCommandBuffer;
- PFN_vkCmdBindPipeline CmdBindPipeline;
- PFN_vkCmdSetViewport CmdSetViewport;
- PFN_vkCmdSetScissor CmdSetScissor;
- PFN_vkCmdSetLineWidth CmdSetLineWidth;
- PFN_vkCmdSetDepthBias CmdSetDepthBias;
- PFN_vkCmdSetBlendConstants CmdSetBlendConstants;
- PFN_vkCmdSetDepthBounds CmdSetDepthBounds;
- PFN_vkCmdSetStencilCompareMask CmdSetStencilCompareMask;
- PFN_vkCmdSetStencilWriteMask CmdSetStencilWriteMask;
- PFN_vkCmdSetStencilReference CmdSetStencilReference;
- PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
- PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer;
- PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers;
- PFN_vkCmdDraw CmdDraw;
- PFN_vkCmdDrawIndexed CmdDrawIndexed;
- PFN_vkCmdDrawIndirect CmdDrawIndirect;
- PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect;
- PFN_vkCmdDispatch CmdDispatch;
- PFN_vkCmdDispatchIndirect CmdDispatchIndirect;
- PFN_vkCmdCopyBuffer CmdCopyBuffer;
- PFN_vkCmdCopyImage CmdCopyImage;
- PFN_vkCmdBlitImage CmdBlitImage;
- PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage;
- PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer;
- PFN_vkCmdUpdateBuffer CmdUpdateBuffer;
- PFN_vkCmdFillBuffer CmdFillBuffer;
- PFN_vkCmdClearColorImage CmdClearColorImage;
- PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage;
- PFN_vkCmdClearAttachments CmdClearAttachments;
- PFN_vkCmdResolveImage CmdResolveImage;
- PFN_vkCmdSetEvent CmdSetEvent;
- PFN_vkCmdResetEvent CmdResetEvent;
- PFN_vkCmdWaitEvents CmdWaitEvents;
- PFN_vkCmdPipelineBarrier CmdPipelineBarrier;
- PFN_vkCmdBeginQuery CmdBeginQuery;
- PFN_vkCmdEndQuery CmdEndQuery;
- PFN_vkCmdResetQueryPool CmdResetQueryPool;
- PFN_vkCmdWriteTimestamp CmdWriteTimestamp;
- PFN_vkCmdCopyQueryPoolResults CmdCopyQueryPoolResults;
- PFN_vkCmdPushConstants CmdPushConstants;
- PFN_vkCmdBeginRenderPass CmdBeginRenderPass;
- PFN_vkCmdNextSubpass CmdNextSubpass;
- PFN_vkCmdEndRenderPass CmdEndRenderPass;
- PFN_vkCmdExecuteCommands CmdExecuteCommands;
- PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
- PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
- PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
- PFN_vkAcquireNextImageKHR AcquireNextImageKHR;
- PFN_vkQueuePresentKHR QueuePresentKHR;
- // clang-format on
-};
-
-struct DriverDispatchTable {
- // clang-format off
- PFN_vkDestroyInstance DestroyInstance;
- PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
- PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
- PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
- PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
- PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
- PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
- PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
- PFN_vkCreateDevice CreateDevice;
- PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
- PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
- PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;
- PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT;
- PFN_vkDebugReportMessageEXT DebugReportMessageEXT;
- PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
PFN_vkCreateImage CreateImage;
PFN_vkDestroyImage DestroyImage;
PFN_vkGetSwapchainGrallocUsageANDROID GetSwapchainGrallocUsageANDROID;
--- /dev/null
+/*
+ * Copyright 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIBVULKAN_DRIVER_H
+#define LIBVULKAN_DRIVER_H 1
+
+#include <inttypes.h>
+#include <type_traits>
+#include <log/log.h>
+
+#include <vulkan/vulkan.h>
+#include <hardware/hwvulkan.h>
+
+#include "api_gen.h"
+
+namespace vulkan {
+
+// This is here so that we can embed api::{Instance,Device}Data in
+// driver::{Instance,Device}Data to avoid pointer chasing. They are
+// considered opaque to the driver layer.
+namespace api {
+
+struct InstanceData {
+ InstanceDispatchTable dispatch;
+
+ // for VkPhysicalDevice->VkInstance mapping
+ VkInstance instance;
+
+ // LayerChain::ActiveLayer array
+ void* layers;
+ uint32_t layer_count;
+
+ // debug.vulkan.enable_callback
+ PFN_vkDestroyDebugReportCallbackEXT destroy_debug_callback;
+ VkDebugReportCallbackEXT debug_callback;
+};
+
+struct DeviceData {
+ DeviceDispatchTable dispatch;
+
+ // LayerChain::ActiveLayer array
+ void* layers;
+ uint32_t layer_count;
+};
+
+} // namespace api
+
+namespace driver {
+
+struct InstanceData {
+ api::InstanceData opaque_api_data;
+
+ const VkAllocationCallbacks allocator;
+};
+
+struct DeviceData {
+ api::DeviceData opaque_api_data;
+
+ const VkAllocationCallbacks allocator;
+};
+
+bool Debuggable();
+bool OpenHAL();
+const VkAllocationCallbacks& GetDefaultAllocator();
+
+// clang-format off
+VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
+VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
+VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+// clang-format on
+
+template <typename DispatchableType>
+void StaticAssertDispatchable(DispatchableType) {
+ static_assert(std::is_same<DispatchableType, VkInstance>::value ||
+ std::is_same<DispatchableType, VkPhysicalDevice>::value ||
+ std::is_same<DispatchableType, VkDevice>::value ||
+ std::is_same<DispatchableType, VkQueue>::value ||
+ std::is_same<DispatchableType, VkCommandBuffer>::value,
+ "unrecognized dispatchable type");
+}
+
+template <typename DispatchableType>
+bool SetDataInternal(DispatchableType dispatchable, const void* data) {
+ StaticAssertDispatchable(dispatchable);
+
+ hwvulkan_dispatch_t* dispatch =
+ reinterpret_cast<hwvulkan_dispatch_t*>(dispatchable);
+ // must be magic or already set
+ if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC && dispatch->vtbl != data) {
+ ALOGE("invalid dispatchable object magic 0x%" PRIxPTR, dispatch->magic);
+ return false;
+ }
+
+ dispatch->vtbl = data;
+
+ return true;
+}
+
+template <typename DispatchableType>
+void* GetDataInternal(DispatchableType dispatchable) {
+ StaticAssertDispatchable(dispatchable);
+
+ const hwvulkan_dispatch_t* dispatch =
+ reinterpret_cast<const hwvulkan_dispatch_t*>(dispatchable);
+
+ return const_cast<void*>(dispatch->vtbl);
+}
+
+inline bool SetData(VkInstance instance, const InstanceData& data) {
+ return SetDataInternal(instance, &data);
+}
+
+inline bool SetData(VkPhysicalDevice physical_dev, const InstanceData& data) {
+ return SetDataInternal(physical_dev, &data);
+}
+
+inline bool SetData(VkDevice dev, const DeviceData& data) {
+ return SetDataInternal(dev, &data);
+}
+
+inline bool SetData(VkQueue queue, const DeviceData& data) {
+ return SetDataInternal(queue, &data);
+}
+
+inline bool SetData(VkCommandBuffer cmd, const DeviceData& data) {
+ return SetDataInternal(cmd, &data);
+}
+
+inline InstanceData& GetData(VkInstance instance) {
+ return *reinterpret_cast<InstanceData*>(GetDataInternal(instance));
+}
+
+inline InstanceData& GetData(VkPhysicalDevice physical_dev) {
+ return *reinterpret_cast<InstanceData*>(GetDataInternal(physical_dev));
+}
+
+inline DeviceData& GetData(VkDevice dev) {
+ return *reinterpret_cast<DeviceData*>(GetDataInternal(dev));
+}
+
+inline DeviceData& GetData(VkQueue queue) {
+ return *reinterpret_cast<DeviceData*>(GetDataInternal(queue));
+}
+
+inline DeviceData& GetData(VkCommandBuffer cmd) {
+ return *reinterpret_cast<DeviceData*>(GetDataInternal(cmd));
+}
+
+} // namespace driver
+} // namespace vulkan
+
+#endif // LIBVULKAN_DRIVER_H
// module header
#include "loader.h"
+#include "driver.h"
// standard C headers
#include <dirent.h>
#include <dlfcn.h>
return ptr;
void* new_ptr = nullptr;
- if (posix_memalign(&new_ptr, alignment, size) != 0)
+ if (posix_memalign(&new_ptr, std::max(alignment, sizeof(void*)), size) != 0)
return nullptr;
if (ptr) {
memcpy(new_ptr, ptr, std::min(old_size, size));
g_driver_instance_extensions.reset(kKHR_android_surface);
}
-bool EnsureInitialized() {
- static std::once_flag once_flag;
- std::call_once(once_flag, []() {
- LoadVulkanHAL();
- DiscoverLayers();
- });
- return g_hwdevice != nullptr;
-}
-
// -----------------------------------------------------------------------------
struct Instance {
Instance(const VkAllocationCallbacks* alloc_callbacks)
- : dispatch_ptr(&dispatch),
- handle(reinterpret_cast<VkInstance>(&dispatch_ptr)),
- alloc(alloc_callbacks),
- num_physical_devices(0),
- active_layers(CallbackAllocator<LayerRef>(alloc)),
- message(VK_NULL_HANDLE) {
- memset(&dispatch, 0, sizeof(dispatch));
+ : base{{}, *alloc_callbacks},
+ alloc(&base.allocator),
+ num_physical_devices(0) {
memset(physical_devices, 0, sizeof(physical_devices));
enabled_extensions.reset();
- drv.instance = VK_NULL_HANDLE;
memset(&drv.dispatch, 0, sizeof(drv.dispatch));
- drv.num_physical_devices = 0;
}
~Instance() {}
- const InstanceDispatchTable* dispatch_ptr;
- const VkInstance handle;
- InstanceDispatchTable dispatch;
+ driver::InstanceData base;
const VkAllocationCallbacks* alloc;
uint32_t num_physical_devices;
VkPhysicalDevice physical_devices[kMaxPhysicalDevices];
DeviceExtensionSet physical_device_driver_extensions[kMaxPhysicalDevices];
- Vector<LayerRef> active_layers;
- VkDebugReportCallbackEXT message;
DebugReportCallbackList debug_report_callbacks;
InstanceExtensionSet enabled_extensions;
struct {
- VkInstance instance;
DriverDispatchTable dispatch;
- uint32_t num_physical_devices;
} drv; // may eventually be an array
};
struct Device {
Device(Instance* instance_)
- : instance(instance_),
- active_layers(CallbackAllocator<LayerRef>(instance->alloc)) {
- memset(&dispatch, 0, sizeof(dispatch));
+ : base{{}, *instance_->alloc}, instance(instance_) {
enabled_extensions.reset();
}
- DeviceDispatchTable dispatch;
+
+ driver::DeviceData base;
+
Instance* instance;
PFN_vkGetDeviceProcAddr get_device_proc_addr;
- Vector<LayerRef> active_layers;
DeviceExtensionSet enabled_extensions;
};
typedef typename HandleTraits<THandle>::LoaderObjectType ObjectType;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
- const size_t kDispatchOffset = offsetof(ObjectType, dispatch);
+ const size_t kBaseOffset = offsetof(ObjectType, base);
#pragma clang diagnostic pop
- const auto& dispatch = GetDispatchTable(handle);
- uintptr_t dispatch_addr = reinterpret_cast<uintptr_t>(&dispatch);
- uintptr_t object_addr = dispatch_addr - kDispatchOffset;
+ const auto& base = driver::GetData(handle);
+ uintptr_t base_addr = reinterpret_cast<uintptr_t>(&base);
+ uintptr_t object_addr = base_addr - kBaseOffset;
return *reinterpret_cast<ObjectType*>(object_addr);
}
// -----------------------------------------------------------------------------
-void DestroyDevice(Device* device) {
- const VkAllocationCallbacks* alloc = device->instance->alloc;
- device->~Device();
- alloc->pfnFree(alloc->pUserData, device);
-}
-
-template <class TObject>
-LayerRef GetLayerRef(const char* name);
-template <>
-LayerRef GetLayerRef<Instance>(const char* name) {
- return GetInstanceLayerRef(name);
-}
-template <>
-LayerRef GetLayerRef<Device>(const char* name) {
- return GetDeviceLayerRef(name);
-}
-
-template <class TObject>
-bool ActivateLayer(TObject* object, const char* name) {
- LayerRef layer(GetLayerRef<TObject>(name));
- if (!layer)
- return false;
- if (std::find(object->active_layers.begin(), object->active_layers.end(),
- layer) == object->active_layers.end()) {
- try {
- object->active_layers.push_back(std::move(layer));
- } catch (std::bad_alloc&) {
- // TODO(jessehall): We should fail with VK_ERROR_OUT_OF_MEMORY
- // if we can't enable a requested layer. Callers currently ignore
- // ActivateLayer's return value.
- ALOGW("failed to activate layer '%s': out of memory", name);
- return false;
- }
- }
- ALOGV("activated layer '%s'", name);
- return true;
-}
+void DestroyDevice(Device* device, VkDevice vkdevice) {
+ const auto& instance = *device->instance;
-struct InstanceNamesPair {
- Instance* instance;
- Vector<String>* layer_names;
-};
+ if (vkdevice != VK_NULL_HANDLE)
+ instance.drv.dispatch.DestroyDevice(vkdevice, instance.alloc);
-void SetLayerNamesFromProperty(const char* name,
- const char* value,
- void* data) {
- try {
- const char prefix[] = "debug.vulkan.layer.";
- const size_t prefixlen = sizeof(prefix) - 1;
- if (value[0] == '\0' || strncmp(name, prefix, prefixlen) != 0)
- return;
- const char* number_str = name + prefixlen;
- long layer_number = strtol(number_str, nullptr, 10);
- if (layer_number <= 0 || layer_number == LONG_MAX) {
- ALOGW("Cannot use a layer at number %ld from string %s",
- layer_number, number_str);
- return;
- }
- auto instance_names_pair = static_cast<InstanceNamesPair*>(data);
- Vector<String>* layer_names = instance_names_pair->layer_names;
- Instance* instance = instance_names_pair->instance;
- size_t layer_size = static_cast<size_t>(layer_number);
- if (layer_size > layer_names->size()) {
- layer_names->resize(
- layer_size, String(CallbackAllocator<char>(instance->alloc)));
- }
- (*layer_names)[layer_size - 1] = value;
- } catch (std::bad_alloc&) {
- ALOGW("failed to handle property '%s'='%s': out of memory", name,
- value);
- return;
- }
-}
-
-template <class TInfo, class TObject>
-VkResult ActivateAllLayers(TInfo create_info,
- Instance* instance,
- TObject* object) {
- ALOG_ASSERT(create_info->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO ||
- create_info->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
- "Cannot activate layers for unknown object %p", object);
- CallbackAllocator<char> string_allocator(instance->alloc);
- // Load system layers
- if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
- char layer_prop[PROPERTY_VALUE_MAX];
- property_get("debug.vulkan.layers", layer_prop, "");
- char* strtok_state;
- char* layer_name = nullptr;
- while ((layer_name = strtok_r(layer_name ? nullptr : layer_prop, ":",
- &strtok_state))) {
- ActivateLayer(object, layer_name);
- }
- Vector<String> layer_names(CallbackAllocator<String>(instance->alloc));
- InstanceNamesPair instance_names_pair = {.instance = instance,
- .layer_names = &layer_names};
- property_list(SetLayerNamesFromProperty,
- static_cast<void*>(&instance_names_pair));
- for (auto layer_name_element : layer_names) {
- ActivateLayer(object, layer_name_element.c_str());
- }
- }
- // Load app layers
- for (uint32_t i = 0; i < create_info->enabledLayerCount; ++i) {
- if (!ActivateLayer(object, create_info->ppEnabledLayerNames[i])) {
- ALOGE("requested %s layer '%s' not present",
- create_info->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
- ? "instance"
- : "device",
- create_info->ppEnabledLayerNames[i]);
- return VK_ERROR_LAYER_NOT_PRESENT;
- }
- }
- return VK_SUCCESS;
-}
-
-template <class TCreateInfo, class TObject>
-bool AddLayersToCreateInfo(TCreateInfo& local_create_info,
- const TObject& object,
- const VkAllocationCallbacks* alloc,
- bool& allocatedMemory) {
- // This should never happen and means there is a likely a bug in layer
- // tracking
- if (object->active_layers.size() < local_create_info.enabledLayerCount) {
- ALOGE("Total number of layers is less than those enabled by the app!");
- return false;
- }
- // Check if the total number of layers enabled is greater than those
- // enabled by the application. If it is then we have system enabled
- // layers which need to be added to the list of layers passed in through
- // create.
- if (object->active_layers.size() > local_create_info.enabledLayerCount) {
- void* mem = alloc->pfnAllocation(
- alloc->pUserData, object->active_layers.size() * sizeof(char*),
- alignof(char*), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
- if (mem) {
- local_create_info.enabledLayerCount = 0;
- const char** names = static_cast<const char**>(mem);
- for (const auto& layer : object->active_layers) {
- const char* name = layer.GetName();
- names[local_create_info.enabledLayerCount++] = name;
- }
- local_create_info.ppEnabledLayerNames = names;
- } else {
- ALOGE("System layers cannot be enabled: memory allocation failed");
- return false;
- }
- allocatedMemory = true;
- } else {
- allocatedMemory = false;
- }
- return true;
-}
-
-template <class T>
-void FreeAllocatedLayerCreateInfo(T& local_create_info,
- const VkAllocationCallbacks* alloc) {
- alloc->pfnFree(alloc->pUserData,
- const_cast<char**>(local_create_info.ppEnabledLayerNames));
-}
-
-template <class TCreateInfo>
-bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
- const char* extension_name,
- const VkAllocationCallbacks* alloc) {
- uint32_t extension_count = local_create_info.enabledExtensionCount;
- local_create_info.enabledExtensionCount++;
- void* mem = alloc->pfnAllocation(
- alloc->pUserData,
- local_create_info.enabledExtensionCount * sizeof(char*), alignof(char*),
- VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
- if (mem) {
- const char** enabled_extensions = static_cast<const char**>(mem);
- for (uint32_t i = 0; i < extension_count; ++i) {
- enabled_extensions[i] =
- local_create_info.ppEnabledExtensionNames[i];
- }
- enabled_extensions[extension_count] = extension_name;
- local_create_info.ppEnabledExtensionNames = enabled_extensions;
- } else {
- ALOGE("%s extension cannot be enabled: memory allocation failed",
- extension_name);
- return false;
- }
- return true;
-}
-
-template <class T>
-void FreeAllocatedExtensionCreateInfo(T& local_create_info,
- const VkAllocationCallbacks* alloc) {
- alloc->pfnFree(
- alloc->pUserData,
- const_cast<char**>(local_create_info.ppEnabledExtensionNames));
-}
-
-VKAPI_ATTR
-VkBool32 LogDebugMessageCallback(VkDebugReportFlagsEXT flags,
- VkDebugReportObjectTypeEXT /*objectType*/,
- uint64_t /*object*/,
- size_t /*location*/,
- int32_t message_code,
- const char* layer_prefix,
- const char* message,
- void* /*user_data*/) {
- if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
- ALOGE("[%s] Code %d : %s", layer_prefix, message_code, message);
- } else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
- ALOGW("[%s] Code %d : %s", layer_prefix, message_code, message);
- }
- return false;
-}
-
-VkResult Noop() {
- return VK_SUCCESS;
+ device->~Device();
+ instance.alloc->pfnFree(instance.alloc->pUserData, device);
}
/*
// function, iff the lower vkCreateInstance call has been made and returned
// successfully.
void DestroyInstance(Instance* instance,
- const VkAllocationCallbacks* allocator) {
- if (instance->message) {
- PFN_vkDestroyDebugReportCallbackEXT destroy_debug_report_callback;
- destroy_debug_report_callback =
- reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
- GetInstanceProcAddr_Top(instance->handle,
- "vkDestroyDebugReportCallbackEXT"));
- destroy_debug_report_callback(instance->handle, instance->message,
- allocator);
- }
+ const VkAllocationCallbacks* allocator,
+ VkInstance vkinstance) {
+ if (vkinstance != VK_NULL_HANDLE && instance->drv.dispatch.DestroyInstance)
+ instance->drv.dispatch.DestroyInstance(vkinstance, allocator);
+
instance->~Instance();
allocator->pfnFree(allocator->pUserData, instance);
}
VkInstance* vkinstance) {
VkResult result;
- VkLayerInstanceCreateInfo* chain_info =
- const_cast<VkLayerInstanceCreateInfo*>(
- static_cast<const VkLayerInstanceCreateInfo*>(create_info->pNext));
- while (
- chain_info &&
- !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO &&
- chain_info->function == VK_LAYER_FUNCTION_INSTANCE)) {
- chain_info = const_cast<VkLayerInstanceCreateInfo*>(
- static_cast<const VkLayerInstanceCreateInfo*>(chain_info->pNext));
- }
- ALOG_ASSERT(chain_info != nullptr, "Missing initialization chain info!");
+ if (!allocator)
+ allocator = &kDefaultAllocCallbacks;
- Instance& instance = GetDispatchParent(
- static_cast<VkInstance>(chain_info->u.instanceInfo.instance_info));
+ void* instance_mem = allocator->pfnAllocation(
+ allocator->pUserData, sizeof(Instance), alignof(Instance),
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ if (!instance_mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ Instance& instance = *new (instance_mem) Instance(allocator);
// Check that all enabled extensions are supported
uint32_t num_driver_extensions = 0;
continue;
}
}
- bool supported = false;
- for (const auto& layer : instance.active_layers) {
- if (layer.SupportsExtension(name))
- supported = true;
- }
- if (!supported) {
- ALOGE(
- "requested instance extension '%s' not supported by "
- "loader, driver, or any active layers",
- name);
- DestroyInstance_Bottom(instance.handle, allocator);
- return VK_ERROR_EXTENSION_NOT_PRESENT;
- }
}
VkInstanceCreateInfo driver_create_info = *create_info;
"different answers!");
}
+ VkInstance drv_instance;
result = g_hwdevice->CreateInstance(&driver_create_info, instance.alloc,
- &instance.drv.instance);
+ &drv_instance);
if (result != VK_SUCCESS) {
- DestroyInstance_Bottom(instance.handle, allocator);
+ DestroyInstance(&instance, allocator, VK_NULL_HANDLE);
return result;
}
- hwvulkan_dispatch_t* drv_dispatch =
- reinterpret_cast<hwvulkan_dispatch_t*>(instance.drv.instance);
- if (drv_dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
- ALOGE("invalid VkInstance dispatch magic: 0x%" PRIxPTR,
- drv_dispatch->magic);
- DestroyInstance_Bottom(instance.handle, allocator);
+ if (!driver::SetData(drv_instance, instance.base)) {
+ DestroyInstance(&instance, allocator, drv_instance);
return VK_ERROR_INITIALIZATION_FAILED;
}
- // Skip setting drv_dispatch->vtbl, since we never call through it;
- // we go through instance.drv.dispatch instead.
- if (!LoadDriverDispatchTable(
- instance.drv.instance, g_hwdevice->GetInstanceProcAddr,
- instance.enabled_extensions, instance.drv.dispatch)) {
- DestroyInstance_Bottom(instance.handle, allocator);
+ if (!LoadDriverDispatchTable(drv_instance, g_hwdevice->GetInstanceProcAddr,
+ instance.enabled_extensions,
+ instance.drv.dispatch)) {
+ DestroyInstance(&instance, allocator, drv_instance);
return VK_ERROR_INITIALIZATION_FAILED;
}
uint32_t num_physical_devices = 0;
result = instance.drv.dispatch.EnumeratePhysicalDevices(
- instance.drv.instance, &num_physical_devices, nullptr);
+ drv_instance, &num_physical_devices, nullptr);
if (result != VK_SUCCESS) {
- DestroyInstance_Bottom(instance.handle, allocator);
+ DestroyInstance(&instance, allocator, drv_instance);
return VK_ERROR_INITIALIZATION_FAILED;
}
num_physical_devices = std::min(num_physical_devices, kMaxPhysicalDevices);
result = instance.drv.dispatch.EnumeratePhysicalDevices(
- instance.drv.instance, &num_physical_devices,
- instance.physical_devices);
+ drv_instance, &num_physical_devices, instance.physical_devices);
if (result != VK_SUCCESS) {
- DestroyInstance_Bottom(instance.handle, allocator);
+ DestroyInstance(&instance, allocator, drv_instance);
return VK_ERROR_INITIALIZATION_FAILED;
}
Vector<VkExtensionProperties> extensions(
Vector<VkExtensionProperties>::allocator_type(instance.alloc));
for (uint32_t i = 0; i < num_physical_devices; i++) {
- hwvulkan_dispatch_t* pdev_dispatch =
- reinterpret_cast<hwvulkan_dispatch_t*>(
- instance.physical_devices[i]);
- if (pdev_dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
- ALOGE("invalid VkPhysicalDevice dispatch magic: 0x%" PRIxPTR,
- pdev_dispatch->magic);
- DestroyInstance_Bottom(instance.handle, allocator);
+ if (!driver::SetData(instance.physical_devices[i], instance.base)) {
+ DestroyInstance(&instance, allocator, drv_instance);
return VK_ERROR_INITIALIZATION_FAILED;
}
- pdev_dispatch->vtbl = instance.dispatch_ptr;
uint32_t count;
if ((result = instance.drv.dispatch.EnumerateDeviceExtensionProperties(
extensions.resize(count);
} catch (std::bad_alloc&) {
ALOGE("instance creation failed: out of memory");
- DestroyInstance_Bottom(instance.handle, allocator);
+ DestroyInstance(&instance, allocator, drv_instance);
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
if ((result = instance.drv.dispatch.EnumerateDeviceExtensionProperties(
// Ignore driver attempts to support loader extensions
instance.physical_device_driver_extensions[i].reset(kKHR_swapchain);
}
- instance.drv.num_physical_devices = num_physical_devices;
- instance.num_physical_devices = instance.drv.num_physical_devices;
+ instance.num_physical_devices = num_physical_devices;
- *vkinstance = instance.handle;
+ *vkinstance = drv_instance;
return VK_SUCCESS;
}
}
if ((pfn = GetLoaderBottomProcAddr(name)))
return pfn;
- return nullptr;
+ return g_hwdevice->GetInstanceProcAddr(vkinstance, name);
}
VkResult EnumeratePhysicalDevices_Bottom(VkInstance vkinstance,
properties);
}
-// This is a no-op, the Top function returns the aggregate layer property
-// data. This is to keep the dispatch generator happy.
VKAPI_ATTR
VkResult EnumerateDeviceExtensionProperties_Bottom(
- VkPhysicalDevice /*pdev*/,
- const char* /*layer_name*/,
- uint32_t* /*properties_count*/,
- VkExtensionProperties* /*properties*/) {
- return VK_SUCCESS;
+ VkPhysicalDevice pdev,
+ const char* layer_name,
+ uint32_t* properties_count,
+ VkExtensionProperties* properties) {
+ (void)layer_name;
+
+ Instance& instance = GetDispatchParent(pdev);
+
+ size_t gpu_idx = 0;
+ while (instance.physical_devices[gpu_idx] != pdev)
+ gpu_idx++;
+ const DeviceExtensionSet driver_extensions =
+ instance.physical_device_driver_extensions[gpu_idx];
+
+ // We only support VK_KHR_swapchain if the GPU supports
+ // VK_ANDROID_native_buffer
+ VkExtensionProperties* available = static_cast<VkExtensionProperties*>(
+ alloca(kDeviceExtensionCount * sizeof(VkExtensionProperties)));
+ uint32_t num_extensions = 0;
+ if (driver_extensions[kANDROID_native_buffer]) {
+ available[num_extensions++] = VkExtensionProperties{
+ VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_SWAPCHAIN_SPEC_VERSION};
+ }
+
+ if (!properties || *properties_count > num_extensions)
+ *properties_count = num_extensions;
+ if (properties)
+ std::copy(available, available + *properties_count, properties);
+
+ return *properties_count < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;
}
// This is a no-op, the Top function returns the aggregate layer property
const VkDeviceCreateInfo* create_info,
const VkAllocationCallbacks* allocator,
VkDevice* device_out) {
- VkLayerDeviceCreateInfo* chain_info = const_cast<VkLayerDeviceCreateInfo*>(
- static_cast<const VkLayerDeviceCreateInfo*>(create_info->pNext));
- while (chain_info &&
- !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO &&
- chain_info->function == VK_LAYER_FUNCTION_DEVICE)) {
- chain_info = const_cast<VkLayerDeviceCreateInfo*>(
- static_cast<const VkLayerDeviceCreateInfo*>(chain_info->pNext));
- }
- ALOG_ASSERT(chain_info != nullptr, "Missing initialization chain info!");
-
Instance& instance = GetDispatchParent(gpu);
+
+ // FIXME(jessehall): We don't have good conventions or infrastructure yet to
+ // do better than just using the instance allocator and scope for
+ // everything. See b/26732122.
+ if (true /*!allocator*/)
+ allocator = instance.alloc;
+
+ void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Device),
+ alignof(Device),
+ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+ if (!mem)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ Device* device = new (mem) Device(&instance);
+
size_t gpu_idx = 0;
while (instance.physical_devices[gpu_idx] != gpu)
gpu_idx++;
- Device* device = static_cast<Device*>(chain_info->u.deviceInfo.device_info);
- PFN_vkGetInstanceProcAddr get_instance_proc_addr =
- chain_info->u.deviceInfo.pfnNextGetInstanceProcAddr;
VkDeviceCreateInfo driver_create_info = *create_info;
driver_create_info.pNext = StripCreateExtensions(create_info->pNext);
continue;
}
}
- bool supported = false;
- for (const auto& layer : device->active_layers) {
- if (layer.SupportsExtension(name))
- supported = true;
- }
- if (!supported) {
- ALOGE(
- "requested device extension '%s' not supported by loader, "
- "driver, or any active layers",
- name);
- return VK_ERROR_EXTENSION_NOT_PRESENT;
- }
}
driver_create_info.enabledExtensionCount = num_driver_extensions;
VkResult result = instance.drv.dispatch.CreateDevice(
gpu, &driver_create_info, allocator, &drv_device);
if (result != VK_SUCCESS) {
+ DestroyDevice(device, VK_NULL_HANDLE);
return VK_ERROR_INITIALIZATION_FAILED;
}
- hwvulkan_dispatch_t* drv_dispatch =
- reinterpret_cast<hwvulkan_dispatch_t*>(drv_device);
- if (drv_dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
- ALOGE("invalid VkDevice dispatch magic: 0x%" PRIxPTR,
- drv_dispatch->magic);
- PFN_vkDestroyDevice destroy_device =
- reinterpret_cast<PFN_vkDestroyDevice>(
- instance.drv.dispatch.GetDeviceProcAddr(drv_device,
- "vkDestroyDevice"));
- destroy_device(drv_device, allocator);
+ if (!driver::SetData(drv_device, device->base)) {
+ DestroyDevice(device, drv_device);
return VK_ERROR_INITIALIZATION_FAILED;
}
- // Set dispatch table for newly created Device
- // CreateDevice_Top will fill in the details
- drv_dispatch->vtbl = &device->dispatch;
device->get_device_proc_addr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(
instance.drv.dispatch.GetDeviceProcAddr(drv_device,
"vkGetDeviceProcAddr"));
const VkAllocationCallbacks* allocator) {
Instance& instance = GetDispatchParent(vkinstance);
- // These checks allow us to call DestroyInstance_Bottom from any error
- // path in CreateInstance_Bottom, before the driver instance is fully
- // initialized.
- if (instance.drv.instance != VK_NULL_HANDLE &&
- instance.drv.dispatch.DestroyInstance) {
- instance.drv.dispatch.DestroyInstance(instance.drv.instance, allocator);
- instance.drv.instance = VK_NULL_HANDLE;
+ VkAllocationCallbacks local_allocator;
+ if (!allocator) {
+ local_allocator = *instance.alloc;
+ allocator = &local_allocator;
}
+
+ DestroyInstance(&instance, allocator, vkinstance);
}
VkResult CreateSwapchainKHR_Disabled(VkDevice,
return GetDispatchParent(vkdevice).get_device_proc_addr(vkdevice, name);
}
-// -----------------------------------------------------------------------------
-// Loader top functions. These are called directly from the loader entry
-// points or from the application (via vkGetInstanceProcAddr) without going
-// through a dispatch table.
-
-VkResult EnumerateInstanceExtensionProperties_Top(
- const char* layer_name,
- uint32_t* properties_count,
- VkExtensionProperties* properties) {
- if (!EnsureInitialized())
- return VK_ERROR_INITIALIZATION_FAILED;
-
- const VkExtensionProperties* extensions = nullptr;
- uint32_t num_extensions = 0;
- if (layer_name) {
- GetInstanceLayerExtensions(layer_name, &extensions, &num_extensions);
- } else {
- VkExtensionProperties* available = static_cast<VkExtensionProperties*>(
- alloca(kInstanceExtensionCount * sizeof(VkExtensionProperties)));
- available[num_extensions++] = VkExtensionProperties{
- VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION};
- available[num_extensions++] =
- VkExtensionProperties{VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
- VK_KHR_ANDROID_SURFACE_SPEC_VERSION};
- if (g_driver_instance_extensions[kEXT_debug_report]) {
- available[num_extensions++] =
- VkExtensionProperties{VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
- VK_EXT_DEBUG_REPORT_SPEC_VERSION};
- }
- // TODO(jessehall): We need to also enumerate extensions supported by
- // implicitly-enabled layers. Currently we don't have that list of
- // layers until instance creation.
- extensions = available;
- }
-
- if (!properties || *properties_count > num_extensions)
- *properties_count = num_extensions;
- if (properties)
- std::copy(extensions, extensions + *properties_count, properties);
- return *properties_count < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;
-}
-
-VkResult EnumerateInstanceLayerProperties_Top(uint32_t* properties_count,
- VkLayerProperties* properties) {
- if (!EnsureInitialized())
- return VK_ERROR_INITIALIZATION_FAILED;
-
- uint32_t layer_count =
- EnumerateInstanceLayers(properties ? *properties_count : 0, properties);
- if (!properties || *properties_count > layer_count)
- *properties_count = layer_count;
- return *properties_count < layer_count ? VK_INCOMPLETE : VK_SUCCESS;
-}
-
-VKAPI_ATTR
-VkResult EnumerateDeviceExtensionProperties_Top(
- VkPhysicalDevice gpu,
- const char* layer_name,
- uint32_t* properties_count,
- VkExtensionProperties* properties) {
- const VkExtensionProperties* extensions = nullptr;
- uint32_t num_extensions = 0;
-
- ALOGV("EnumerateDeviceExtensionProperties_Top:");
- if (layer_name) {
- ALOGV(" layer %s", layer_name);
- GetDeviceLayerExtensions(layer_name, &extensions, &num_extensions);
- } else {
- ALOGV(" no layer");
- Instance& instance = GetDispatchParent(gpu);
- size_t gpu_idx = 0;
- while (instance.physical_devices_top[gpu_idx] != gpu)
- gpu_idx++;
- const DeviceExtensionSet driver_extensions =
- instance.physical_device_driver_extensions[gpu_idx];
-
- // We only support VK_KHR_swapchain if the GPU supports
- // VK_ANDROID_native_buffer
- VkExtensionProperties* available = static_cast<VkExtensionProperties*>(
- alloca(kDeviceExtensionCount * sizeof(VkExtensionProperties)));
- if (driver_extensions[kANDROID_native_buffer]) {
- available[num_extensions++] = VkExtensionProperties{
- VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_SWAPCHAIN_SPEC_VERSION};
- }
-
- // TODO(jessehall): We need to also enumerate extensions supported by
- // implicitly-enabled layers. Currently we don't have that list of
- // layers until instance creation.
- extensions = available;
- }
-
- ALOGV(" num: %d, extensions: %p", num_extensions, extensions);
- if (!properties || *properties_count > num_extensions)
- *properties_count = num_extensions;
- if (properties)
- std::copy(extensions, extensions + *properties_count, properties);
- return *properties_count < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;
-}
-
-VkResult CreateInstance_Top(const VkInstanceCreateInfo* create_info,
- const VkAllocationCallbacks* allocator,
- VkInstance* instance_out) {
- VkResult result;
-
- if (!EnsureInitialized())
- return VK_ERROR_INITIALIZATION_FAILED;
-
- if (!allocator)
- allocator = &kDefaultAllocCallbacks;
-
- VkInstanceCreateInfo local_create_info = *create_info;
- create_info = &local_create_info;
-
- void* instance_mem = allocator->pfnAllocation(
- allocator->pUserData, sizeof(Instance), alignof(Instance),
- VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
- if (!instance_mem)
- return VK_ERROR_OUT_OF_HOST_MEMORY;
- Instance* instance = new (instance_mem) Instance(allocator);
-
- result = ActivateAllLayers(create_info, instance, instance);
- if (result != VK_SUCCESS) {
- DestroyInstance(instance, allocator);
- return result;
- }
-
- uint32_t activated_layers = 0;
- VkLayerInstanceCreateInfo chain_info;
- VkLayerInstanceLink* layer_instance_link_info = nullptr;
- PFN_vkGetInstanceProcAddr next_gipa = GetInstanceProcAddr_Bottom;
- VkInstance local_instance = nullptr;
-
- if (instance->active_layers.size() > 0) {
- chain_info.u.pLayerInfo = nullptr;
- chain_info.pNext = create_info->pNext;
- chain_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
- chain_info.function = VK_LAYER_FUNCTION_LINK;
- local_create_info.pNext = &chain_info;
-
- layer_instance_link_info = static_cast<VkLayerInstanceLink*>(alloca(
- sizeof(VkLayerInstanceLink) * instance->active_layers.size()));
- if (!layer_instance_link_info) {
- ALOGE("Failed to alloc Instance objects for layers");
- DestroyInstance(instance, allocator);
- return VK_ERROR_OUT_OF_HOST_MEMORY;
- }
-
- /* Create instance chain of enabled layers */
- for (auto rit = instance->active_layers.rbegin();
- rit != instance->active_layers.rend(); ++rit) {
- LayerRef& layer = *rit;
- layer_instance_link_info[activated_layers].pNext =
- chain_info.u.pLayerInfo;
- layer_instance_link_info[activated_layers]
- .pfnNextGetInstanceProcAddr = next_gipa;
- chain_info.u.pLayerInfo =
- &layer_instance_link_info[activated_layers];
- next_gipa = layer.GetGetInstanceProcAddr();
-
- ALOGV("Insert instance layer %s (v%u)", layer.GetName(),
- layer.GetSpecVersion());
-
- activated_layers++;
- }
- }
-
- PFN_vkCreateInstance create_instance =
- reinterpret_cast<PFN_vkCreateInstance>(
- next_gipa(VK_NULL_HANDLE, "vkCreateInstance"));
- if (!create_instance) {
- DestroyInstance(instance, allocator);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- VkLayerInstanceCreateInfo instance_create_info;
-
- instance_create_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
- instance_create_info.function = VK_LAYER_FUNCTION_INSTANCE;
-
- instance_create_info.u.instanceInfo.instance_info = instance;
- instance_create_info.u.instanceInfo.pfnNextGetInstanceProcAddr = next_gipa;
-
- instance_create_info.pNext = local_create_info.pNext;
- local_create_info.pNext = &instance_create_info;
-
- // Force enable callback extension if required
- bool enable_callback = false;
- if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
- enable_callback =
- property_get_bool("debug.vulkan.enable_callback", false);
- if (enable_callback) {
- if (!AddExtensionToCreateInfo(local_create_info,
- "VK_EXT_debug_report", allocator)) {
- DestroyInstance(instance, allocator);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- }
- }
- bool allocatedLayerMem;
- if (!AddLayersToCreateInfo(local_create_info, instance, allocator,
- allocatedLayerMem)) {
- if (enable_callback) {
- FreeAllocatedExtensionCreateInfo(local_create_info, allocator);
- }
- DestroyInstance(instance, allocator);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
-
- result = create_instance(&local_create_info, allocator, &local_instance);
-
- if (allocatedLayerMem) {
- FreeAllocatedLayerCreateInfo(local_create_info, allocator);
- }
- if (enable_callback) {
- FreeAllocatedExtensionCreateInfo(local_create_info, allocator);
- }
-
- if (result != VK_SUCCESS) {
- DestroyInstance(instance, allocator);
- return result;
- }
-
- const InstanceDispatchTable& instance_dispatch =
- GetDispatchTable(local_instance);
- if (!LoadInstanceDispatchTable(
- local_instance, next_gipa,
- const_cast<InstanceDispatchTable&>(instance_dispatch))) {
- ALOGV("Failed to initialize instance dispatch table");
- PFN_vkDestroyInstance destroy_instance =
- reinterpret_cast<PFN_vkDestroyInstance>(
- next_gipa(local_instance, "vkDestroyInstance"));
- if (!destroy_instance) {
- ALOGD("Loader unable to find DestroyInstance");
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- destroy_instance(local_instance, allocator);
- DestroyInstance(instance, allocator);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
-
- // Capture the physical devices from the top of the
- // chain in case it has been wrapped by a layer.
- uint32_t num_physical_devices = 0;
- result = instance_dispatch.EnumeratePhysicalDevices(
- local_instance, &num_physical_devices, nullptr);
- if (result != VK_SUCCESS) {
- DestroyInstance(instance, allocator);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- num_physical_devices = std::min(num_physical_devices, kMaxPhysicalDevices);
- result = instance_dispatch.EnumeratePhysicalDevices(
- local_instance, &num_physical_devices,
- instance->physical_devices_top);
- if (result != VK_SUCCESS) {
- DestroyInstance(instance, allocator);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- *instance_out = local_instance;
-
- if (enable_callback) {
- const VkDebugReportCallbackCreateInfoEXT callback_create_info = {
- .sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,
- .flags =
- VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT,
- .pfnCallback = LogDebugMessageCallback,
- };
- PFN_vkCreateDebugReportCallbackEXT create_debug_report_callback =
- reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(
- GetInstanceProcAddr_Top(instance->handle,
- "vkCreateDebugReportCallbackEXT"));
- create_debug_report_callback(instance->handle, &callback_create_info,
- allocator, &instance->message);
- }
-
- return result;
-}
-
-PFN_vkVoidFunction GetInstanceProcAddr_Top(VkInstance vkinstance,
- const char* name) {
- // vkGetInstanceProcAddr(NULL_HANDLE, ..) only works for global commands
- if (!vkinstance)
- return GetLoaderGlobalProcAddr(name);
-
- const InstanceDispatchTable& dispatch = GetDispatchTable(vkinstance);
- PFN_vkVoidFunction pfn;
- // Always go through the loader-top function if there is one.
- if ((pfn = GetLoaderTopProcAddr(name)))
- return pfn;
- // Otherwise, look up the handler in the instance dispatch table
- if ((pfn = GetDispatchProcAddr(dispatch, name)))
- return pfn;
- // Anything not handled already must be a device-dispatched function
- // without a loader-top. We must return a function that will dispatch based
- // on the dispatchable object parameter -- which is exactly what the
- // exported functions do. So just return them here.
- return GetLoaderExportProcAddr(name);
+void DestroyDevice_Bottom(VkDevice vkdevice, const VkAllocationCallbacks*) {
+ DestroyDevice(&GetDispatchParent(vkdevice), vkdevice);
}
-void DestroyInstance_Top(VkInstance vkinstance,
- const VkAllocationCallbacks* allocator) {
- if (!vkinstance)
- return;
- if (!allocator)
- allocator = &kDefaultAllocCallbacks;
- GetDispatchTable(vkinstance).DestroyInstance(vkinstance, allocator);
- DestroyInstance(&(GetDispatchParent(vkinstance)), allocator);
-}
+void GetDeviceQueue_Bottom(VkDevice vkdevice,
+ uint32_t family,
+ uint32_t index,
+ VkQueue* queue_out) {
+ const auto& device = GetDispatchParent(vkdevice);
+ const auto& instance = *device.instance;
-VKAPI_ATTR
-VkResult EnumerateDeviceLayerProperties_Top(VkPhysicalDevice /*pdev*/,
- uint32_t* properties_count,
- VkLayerProperties* properties) {
- uint32_t layer_count =
- EnumerateDeviceLayers(properties ? *properties_count : 0, properties);
- if (!properties || *properties_count > layer_count)
- *properties_count = layer_count;
- return *properties_count < layer_count ? VK_INCOMPLETE : VK_SUCCESS;
+ instance.drv.dispatch.GetDeviceQueue(vkdevice, family, index, queue_out);
+ driver::SetData(*queue_out, device.base);
}
-VKAPI_ATTR
-VkResult CreateDevice_Top(VkPhysicalDevice gpu,
- const VkDeviceCreateInfo* create_info,
- const VkAllocationCallbacks* allocator,
- VkDevice* device_out) {
- Instance& instance = GetDispatchParent(gpu);
- VkResult result;
-
- // FIXME(jessehall): We don't have good conventions or infrastructure yet to
- // do better than just using the instance allocator and scope for
- // everything. See b/26732122.
- if (true /*!allocator*/)
- allocator = instance.alloc;
-
- void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Device),
- alignof(Device),
- VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
- if (!mem)
- return VK_ERROR_OUT_OF_HOST_MEMORY;
- Device* device = new (mem) Device(&instance);
-
- result = ActivateAllLayers(create_info, &instance, device);
- if (result != VK_SUCCESS) {
- DestroyDevice(device);
- return result;
- }
-
- uint32_t activated_layers = 0;
- VkLayerDeviceCreateInfo chain_info;
- VkLayerDeviceLink* layer_device_link_info = nullptr;
- PFN_vkGetInstanceProcAddr next_gipa = GetInstanceProcAddr_Bottom;
- PFN_vkGetDeviceProcAddr next_gdpa = GetDeviceProcAddr_Bottom;
- VkDeviceCreateInfo local_create_info = *create_info;
- VkDevice local_device = nullptr;
-
- if (device->active_layers.size() > 0) {
- chain_info.u.pLayerInfo = nullptr;
- chain_info.pNext = local_create_info.pNext;
- chain_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
- chain_info.function = VK_LAYER_FUNCTION_LINK;
- local_create_info.pNext = &chain_info;
-
- layer_device_link_info = static_cast<VkLayerDeviceLink*>(
- alloca(sizeof(VkLayerDeviceLink) * device->active_layers.size()));
- if (!layer_device_link_info) {
- ALOGE("Failed to alloc Device objects for layers");
- DestroyDevice(device);
- return VK_ERROR_OUT_OF_HOST_MEMORY;
- }
-
- /* Create device chain of enabled layers */
- for (auto rit = device->active_layers.rbegin();
- rit != device->active_layers.rend(); ++rit) {
- LayerRef& layer = *rit;
- layer_device_link_info[activated_layers].pNext =
- chain_info.u.pLayerInfo;
- layer_device_link_info[activated_layers].pfnNextGetDeviceProcAddr =
- next_gdpa;
- layer_device_link_info[activated_layers]
- .pfnNextGetInstanceProcAddr = next_gipa;
- chain_info.u.pLayerInfo = &layer_device_link_info[activated_layers];
-
- next_gipa = layer.GetGetInstanceProcAddr();
- next_gdpa = layer.GetGetDeviceProcAddr();
-
- ALOGV("Insert device layer %s (v%u)", layer.GetName(),
- layer.GetSpecVersion());
-
- activated_layers++;
- }
- }
-
- PFN_vkCreateDevice create_device = reinterpret_cast<PFN_vkCreateDevice>(
- next_gipa(instance.handle, "vkCreateDevice"));
- if (!create_device) {
- ALOGE("Unable to find vkCreateDevice for driver");
- DestroyDevice(device);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
-
- VkLayerDeviceCreateInfo device_create_info;
-
- device_create_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
- device_create_info.function = VK_LAYER_FUNCTION_DEVICE;
-
- device_create_info.u.deviceInfo.device_info = device;
- device_create_info.u.deviceInfo.pfnNextGetInstanceProcAddr = next_gipa;
-
- device_create_info.pNext = local_create_info.pNext;
- local_create_info.pNext = &device_create_info;
-
- bool allocatedLayerMem;
- if (!AddLayersToCreateInfo(local_create_info, device, allocator,
- allocatedLayerMem)) {
- DestroyDevice(device);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
-
- result = create_device(gpu, &local_create_info, allocator, &local_device);
-
- if (allocatedLayerMem) {
- FreeAllocatedLayerCreateInfo(local_create_info, allocator);
- }
-
- if (result != VK_SUCCESS) {
- DestroyDevice(device);
- return result;
- }
-
- // Set dispatch table for newly created Device
- hwvulkan_dispatch_t* vulkan_dispatch =
- reinterpret_cast<hwvulkan_dispatch_t*>(local_device);
- vulkan_dispatch->vtbl = &device->dispatch;
-
- const DeviceDispatchTable& device_dispatch = GetDispatchTable(local_device);
- if (!LoadDeviceDispatchTable(
- local_device, next_gdpa,
- const_cast<DeviceDispatchTable&>(device_dispatch))) {
- ALOGV("Failed to initialize device dispatch table");
- PFN_vkDestroyDevice destroy_device =
- reinterpret_cast<PFN_vkDestroyDevice>(
- next_gipa(instance.handle, "vkDestroyDevice"));
- ALOG_ASSERT(destroy_device != nullptr,
- "Loader unable to find DestroyDevice");
- destroy_device(local_device, allocator);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- *device_out = local_device;
-
- return VK_SUCCESS;
-}
-
-PFN_vkVoidFunction GetDeviceProcAddr_Top(VkDevice device, const char* name) {
- PFN_vkVoidFunction pfn;
- if (!device)
- return nullptr;
- if ((pfn = GetLoaderTopProcAddr(name)))
- return pfn;
- return GetDispatchProcAddr(GetDispatchTable(device), name);
-}
-
-void GetDeviceQueue_Top(VkDevice vkdevice,
- uint32_t family,
- uint32_t index,
- VkQueue* queue_out) {
- const auto& table = GetDispatchTable(vkdevice);
- table.GetDeviceQueue(vkdevice, family, index, queue_out);
- hwvulkan_dispatch_t* queue_dispatch =
- reinterpret_cast<hwvulkan_dispatch_t*>(*queue_out);
- if (queue_dispatch->magic != HWVULKAN_DISPATCH_MAGIC &&
- queue_dispatch->vtbl != &table)
- ALOGE("invalid VkQueue dispatch magic: 0x%" PRIxPTR,
- queue_dispatch->magic);
- queue_dispatch->vtbl = &table;
-}
-
-VkResult AllocateCommandBuffers_Top(
+VkResult AllocateCommandBuffers_Bottom(
VkDevice vkdevice,
const VkCommandBufferAllocateInfo* alloc_info,
VkCommandBuffer* cmdbufs) {
- const auto& table = GetDispatchTable(vkdevice);
- VkResult result =
- table.AllocateCommandBuffers(vkdevice, alloc_info, cmdbufs);
- if (result != VK_SUCCESS)
- return result;
- for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
- hwvulkan_dispatch_t* cmdbuf_dispatch =
- reinterpret_cast<hwvulkan_dispatch_t*>(cmdbufs[i]);
- ALOGE_IF(cmdbuf_dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
- "invalid VkCommandBuffer dispatch magic: 0x%" PRIxPTR,
- cmdbuf_dispatch->magic);
- cmdbuf_dispatch->vtbl = &table;
+ const auto& device = GetDispatchParent(vkdevice);
+ const auto& instance = *device.instance;
+
+ VkResult result = instance.drv.dispatch.AllocateCommandBuffers(
+ vkdevice, alloc_info, cmdbufs);
+ if (result == VK_SUCCESS) {
+ for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++)
+ driver::SetData(cmdbufs[i], device.base);
}
- return VK_SUCCESS;
-}
-void DestroyDevice_Top(VkDevice vkdevice,
- const VkAllocationCallbacks* /*allocator*/) {
- if (!vkdevice)
- return;
- Device& device = GetDispatchParent(vkdevice);
- device.dispatch.DestroyDevice(vkdevice, device.instance->alloc);
- DestroyDevice(&device);
+ return result;
}
// -----------------------------------------------------------------------------
}
VkInstance GetDriverInstance(VkInstance instance) {
- return GetDispatchParent(instance).drv.instance;
+ return instance;
}
const DriverDispatchTable& GetDriverDispatch(VkInstance instance) {
return GetDispatchParent(instance).debug_report_callbacks;
}
+namespace driver {
+
+bool Debuggable() {
+ return (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0) >= 0);
+}
+
+bool OpenHAL() {
+ if (!g_hwdevice)
+ LoadVulkanHAL();
+
+ return (g_hwdevice != nullptr);
+}
+
+const VkAllocationCallbacks& GetDefaultAllocator() {
+ return kDefaultAllocCallbacks;
+}
+
+PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName) {
+ return GetInstanceProcAddr_Bottom(instance, pName);
+}
+
+PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName) {
+ return GetDeviceProcAddr_Bottom(device, pName);
+}
+
+VkResult EnumerateInstanceExtensionProperties(
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties) {
+ (void)pLayerName;
+
+ VkExtensionProperties* available = static_cast<VkExtensionProperties*>(
+ alloca(kInstanceExtensionCount * sizeof(VkExtensionProperties)));
+ uint32_t num_extensions = 0;
+
+ available[num_extensions++] = VkExtensionProperties{
+ VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION};
+ available[num_extensions++] =
+ VkExtensionProperties{VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
+ VK_KHR_ANDROID_SURFACE_SPEC_VERSION};
+ if (g_driver_instance_extensions[kEXT_debug_report]) {
+ available[num_extensions++] =
+ VkExtensionProperties{VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
+ VK_EXT_DEBUG_REPORT_SPEC_VERSION};
+ }
+
+ if (!pProperties || *pPropertyCount > num_extensions)
+ *pPropertyCount = num_extensions;
+ if (pProperties)
+ std::copy(available, available + *pPropertyCount, pProperties);
+
+ return *pPropertyCount < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;
+}
+
+} // namespace driver
+
} // namespace vulkan
};
typedef std::bitset<kDeviceExtensionCount> DeviceExtensionSet;
-inline const InstanceDispatchTable& GetDispatchTable(VkInstance instance) {
- return **reinterpret_cast<InstanceDispatchTable**>(instance);
-}
-
-inline const InstanceDispatchTable& GetDispatchTable(
- VkPhysicalDevice physical_device) {
- return **reinterpret_cast<InstanceDispatchTable**>(physical_device);
-}
-
-inline const DeviceDispatchTable& GetDispatchTable(VkDevice device) {
- return **reinterpret_cast<DeviceDispatchTable**>(device);
-}
-
-inline const DeviceDispatchTable& GetDispatchTable(VkQueue queue) {
- return **reinterpret_cast<DeviceDispatchTable**>(queue);
-}
-
-inline const DeviceDispatchTable& GetDispatchTable(
- VkCommandBuffer command_buffer) {
- return **reinterpret_cast<DeviceDispatchTable**>(command_buffer);
-}
-
// -----------------------------------------------------------------------------
// dispatch_gen.cpp
-PFN_vkVoidFunction GetLoaderExportProcAddr(const char* name);
-PFN_vkVoidFunction GetLoaderGlobalProcAddr(const char* name);
-PFN_vkVoidFunction GetLoaderTopProcAddr(const char* name);
PFN_vkVoidFunction GetLoaderBottomProcAddr(const char* name);
-PFN_vkVoidFunction GetDispatchProcAddr(const InstanceDispatchTable& dispatch,
- const char* name);
-PFN_vkVoidFunction GetDispatchProcAddr(const DeviceDispatchTable& dispatch,
- const char* name);
-bool LoadInstanceDispatchTable(VkInstance instance,
- PFN_vkGetInstanceProcAddr get_proc_addr,
- InstanceDispatchTable& dispatch);
-bool LoadDeviceDispatchTable(VkDevice device,
- PFN_vkGetDeviceProcAddr get_proc_addr,
- DeviceDispatchTable& dispatch);
bool LoadDriverDispatchTable(VkInstance instance,
PFN_vkGetInstanceProcAddr get_proc_addr,
const InstanceExtensionSet& extensions,
// loader.cpp
// clang-format off
-VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties_Top(const char* layer_name, uint32_t* count, VkExtensionProperties* properties);
-VKAPI_ATTR VkResult EnumerateInstanceLayerProperties_Top(uint32_t* count, VkLayerProperties* properties);
-VKAPI_ATTR VkResult CreateInstance_Top(const VkInstanceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkInstance* instance_out);
-VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr_Top(VkInstance instance, const char* name);
-VKAPI_ATTR void DestroyInstance_Top(VkInstance instance, const VkAllocationCallbacks* allocator);
-VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr_Top(VkDevice drv_device, const char* name);
-VKAPI_ATTR void GetDeviceQueue_Top(VkDevice drv_device, uint32_t family, uint32_t index, VkQueue* out_queue);
-VKAPI_ATTR VkResult AllocateCommandBuffers_Top(VkDevice device, const VkCommandBufferAllocateInfo* alloc_info, VkCommandBuffer* cmdbufs);
-VKAPI_ATTR VkResult EnumerateDeviceLayerProperties_Top(VkPhysicalDevice pdev, uint32_t* properties_count, VkLayerProperties* properties);
-VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties_Top(VkPhysicalDevice pdev, const char * layer_name, uint32_t* properties_count, VkExtensionProperties* properties);
-VKAPI_ATTR VkResult CreateDevice_Top(VkPhysicalDevice pdev, const VkDeviceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkDevice* device_out);
-VKAPI_ATTR void DestroyDevice_Top(VkDevice drv_device, const VkAllocationCallbacks* allocator);
-
VKAPI_ATTR VkResult CreateInstance_Bottom(const VkInstanceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkInstance* vkinstance);
VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr_Bottom(VkInstance, const char* name);
VKAPI_ATTR VkResult EnumeratePhysicalDevices_Bottom(VkInstance vkinstance, uint32_t* pdev_count, VkPhysicalDevice* pdevs);
VKAPI_ATTR VkResult CreateDevice_Bottom(VkPhysicalDevice pdev, const VkDeviceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkDevice* device_out);
VKAPI_ATTR void DestroyInstance_Bottom(VkInstance vkinstance, const VkAllocationCallbacks* allocator);
VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr_Bottom(VkDevice vkdevice, const char* name);
+VKAPI_ATTR void DestroyDevice_Bottom(VkDevice device, const VkAllocationCallbacks* pAllocator);
+VKAPI_ATTR void GetDeviceQueue_Bottom(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+VKAPI_ATTR VkResult AllocateCommandBuffers_Bottom(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
// clang-format on
const VkAllocationCallbacks* GetAllocator(VkInstance instance);
OSDN Git Service
