Chia-I Wu | eb7db12 | 2016-03-24 09:11:06 +0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2016 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | // WARNING: This file is generated. See ../README.md for instructions. |
| 18 | |
| 19 | #include <string.h> |
| 20 | #include <algorithm> |
| 21 | #include <log/log.h> |
| 22 | |
| 23 | #include "driver.h" |
| 24 | #include "loader.h" |
| 25 | |
| 26 | namespace vulkan { |
| 27 | namespace driver { |
| 28 | |
| 29 | namespace { |
| 30 | |
| 31 | // clang-format off |
| 32 | |
| 33 | VKAPI_ATTR void disabledDestroySurfaceKHR(VkInstance, VkSurfaceKHR, const VkAllocationCallbacks*) { |
| 34 | ALOGE("VK_KHR_surface not enabled. vkDestroySurfaceKHR not executed."); |
| 35 | } |
| 36 | |
| 37 | VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice, uint32_t, VkSurfaceKHR, VkBool32*) { |
| 38 | ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfaceSupportKHR not executed."); |
| 39 | return VK_SUCCESS; |
| 40 | } |
| 41 | |
| 42 | VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice, VkSurfaceKHR, VkSurfaceCapabilitiesKHR*) { |
| 43 | ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfaceCapabilitiesKHR not executed."); |
| 44 | return VK_SUCCESS; |
| 45 | } |
| 46 | |
| 47 | VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice, VkSurfaceKHR, uint32_t*, VkSurfaceFormatKHR*) { |
| 48 | ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfaceFormatsKHR not executed."); |
| 49 | return VK_SUCCESS; |
| 50 | } |
| 51 | |
| 52 | VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice, VkSurfaceKHR, uint32_t*, VkPresentModeKHR*) { |
| 53 | ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfacePresentModesKHR not executed."); |
| 54 | return VK_SUCCESS; |
| 55 | } |
| 56 | |
| 57 | VKAPI_ATTR VkResult disabledCreateSwapchainKHR(VkDevice, const VkSwapchainCreateInfoKHR*, const VkAllocationCallbacks*, VkSwapchainKHR*) { |
| 58 | ALOGE("VK_KHR_swapchain not enabled. vkCreateSwapchainKHR not executed."); |
| 59 | return VK_SUCCESS; |
| 60 | } |
| 61 | |
| 62 | VKAPI_ATTR VkResult checkedCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { |
| 63 | return (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) ? CreateSwapchainKHR_Bottom(device, pCreateInfo, pAllocator, pSwapchain) : disabledCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); |
| 64 | } |
| 65 | |
| 66 | VKAPI_ATTR void disabledDestroySwapchainKHR(VkDevice, VkSwapchainKHR, const VkAllocationCallbacks*) { |
| 67 | ALOGE("VK_KHR_swapchain not enabled. vkDestroySwapchainKHR not executed."); |
| 68 | } |
| 69 | |
| 70 | VKAPI_ATTR void checkedDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { |
| 71 | (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) ? DestroySwapchainKHR_Bottom(device, swapchain, pAllocator) : disabledDestroySwapchainKHR(device, swapchain, pAllocator); |
| 72 | } |
| 73 | |
| 74 | VKAPI_ATTR VkResult disabledGetSwapchainImagesKHR(VkDevice, VkSwapchainKHR, uint32_t*, VkImage*) { |
| 75 | ALOGE("VK_KHR_swapchain not enabled. vkGetSwapchainImagesKHR not executed."); |
| 76 | return VK_SUCCESS; |
| 77 | } |
| 78 | |
| 79 | VKAPI_ATTR VkResult checkedGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { |
| 80 | return (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) ? GetSwapchainImagesKHR_Bottom(device, swapchain, pSwapchainImageCount, pSwapchainImages) : disabledGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); |
| 81 | } |
| 82 | |
| 83 | VKAPI_ATTR VkResult disabledAcquireNextImageKHR(VkDevice, VkSwapchainKHR, uint64_t, VkSemaphore, VkFence, uint32_t*) { |
| 84 | ALOGE("VK_KHR_swapchain not enabled. vkAcquireNextImageKHR not executed."); |
| 85 | return VK_SUCCESS; |
| 86 | } |
| 87 | |
| 88 | VKAPI_ATTR VkResult checkedAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { |
| 89 | return (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) ? AcquireNextImageKHR_Bottom(device, swapchain, timeout, semaphore, fence, pImageIndex) : disabledAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); |
| 90 | } |
| 91 | |
| 92 | VKAPI_ATTR VkResult disabledQueuePresentKHR(VkQueue, const VkPresentInfoKHR*) { |
| 93 | ALOGE("VK_KHR_swapchain not enabled. vkQueuePresentKHR not executed."); |
| 94 | return VK_SUCCESS; |
| 95 | } |
| 96 | |
| 97 | VKAPI_ATTR VkResult checkedQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { |
| 98 | return (GetData(queue).hook_extensions[ProcHook::KHR_swapchain]) ? QueuePresentKHR_Bottom(queue, pPresentInfo) : disabledQueuePresentKHR(queue, pPresentInfo); |
| 99 | } |
| 100 | |
| 101 | VKAPI_ATTR VkResult disabledCreateAndroidSurfaceKHR(VkInstance, const VkAndroidSurfaceCreateInfoKHR*, const VkAllocationCallbacks*, VkSurfaceKHR*) { |
| 102 | ALOGE("VK_KHR_android_surface not enabled. vkCreateAndroidSurfaceKHR not executed."); |
| 103 | return VK_SUCCESS; |
| 104 | } |
| 105 | |
| 106 | VKAPI_ATTR VkResult disabledCreateDebugReportCallbackEXT(VkInstance, const VkDebugReportCallbackCreateInfoEXT*, const VkAllocationCallbacks*, VkDebugReportCallbackEXT*) { |
| 107 | ALOGE("VK_EXT_debug_report not enabled. vkCreateDebugReportCallbackEXT not executed."); |
| 108 | return VK_SUCCESS; |
| 109 | } |
| 110 | |
| 111 | VKAPI_ATTR void disabledDestroyDebugReportCallbackEXT(VkInstance, VkDebugReportCallbackEXT, const VkAllocationCallbacks*) { |
| 112 | ALOGE("VK_EXT_debug_report not enabled. vkDestroyDebugReportCallbackEXT not executed."); |
| 113 | } |
| 114 | |
| 115 | VKAPI_ATTR void disabledDebugReportMessageEXT(VkInstance, VkDebugReportFlagsEXT, VkDebugReportObjectTypeEXT, uint64_t, size_t, int32_t, const char*, const char*) { |
| 116 | ALOGE("VK_EXT_debug_report not enabled. vkDebugReportMessageEXT not executed."); |
| 117 | } |
| 118 | |
| 119 | // clang-format on |
| 120 | |
| 121 | const ProcHook g_proc_hooks[] = { |
| 122 | // clang-format off |
| 123 | { |
| 124 | "vkAcquireImageANDROID", |
| 125 | ProcHook::DEVICE, |
| 126 | ProcHook::ANDROID_native_buffer, |
| 127 | nullptr, |
| 128 | nullptr, |
| 129 | nullptr, |
| 130 | }, |
| 131 | { |
| 132 | "vkAcquireNextImageKHR", |
| 133 | ProcHook::DEVICE, |
| 134 | ProcHook::KHR_swapchain, |
| 135 | reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR_Bottom), |
| 136 | reinterpret_cast<PFN_vkVoidFunction>(disabledAcquireNextImageKHR), |
| 137 | reinterpret_cast<PFN_vkVoidFunction>(checkedAcquireNextImageKHR), |
| 138 | }, |
| 139 | { |
| 140 | "vkAllocateCommandBuffers", |
| 141 | ProcHook::DEVICE, |
| 142 | ProcHook::EXTENSION_CORE, |
Chia-I Wu | 6a58a8a | 2016-03-24 16:29:51 +0800 | [diff] [blame^] | 143 | reinterpret_cast<PFN_vkVoidFunction>(AllocateCommandBuffers), |
Chia-I Wu | eb7db12 | 2016-03-24 09:11:06 +0800 | [diff] [blame] | 144 | nullptr, |
| 145 | nullptr, |
| 146 | }, |
| 147 | { |
| 148 | "vkCreateAndroidSurfaceKHR", |
| 149 | ProcHook::INSTANCE, |
| 150 | ProcHook::KHR_android_surface, |
| 151 | reinterpret_cast<PFN_vkVoidFunction>(CreateAndroidSurfaceKHR_Bottom), |
| 152 | reinterpret_cast<PFN_vkVoidFunction>(disabledCreateAndroidSurfaceKHR), |
| 153 | nullptr, |
| 154 | }, |
| 155 | { |
| 156 | "vkCreateDebugReportCallbackEXT", |
| 157 | ProcHook::INSTANCE, |
| 158 | ProcHook::EXT_debug_report, |
| 159 | reinterpret_cast<PFN_vkVoidFunction>(CreateDebugReportCallbackEXT_Bottom), |
| 160 | reinterpret_cast<PFN_vkVoidFunction>(disabledCreateDebugReportCallbackEXT), |
| 161 | nullptr, |
| 162 | }, |
| 163 | { |
| 164 | "vkCreateDevice", |
| 165 | ProcHook::INSTANCE, |
| 166 | ProcHook::EXTENSION_CORE, |
| 167 | reinterpret_cast<PFN_vkVoidFunction>(CreateDevice_Bottom), |
| 168 | nullptr, |
| 169 | nullptr, |
| 170 | }, |
| 171 | { |
| 172 | "vkCreateInstance", |
| 173 | ProcHook::GLOBAL, |
| 174 | ProcHook::EXTENSION_CORE, |
| 175 | reinterpret_cast<PFN_vkVoidFunction>(CreateInstance_Bottom), |
| 176 | nullptr, |
| 177 | nullptr, |
| 178 | }, |
| 179 | { |
| 180 | "vkCreateSwapchainKHR", |
| 181 | ProcHook::DEVICE, |
| 182 | ProcHook::KHR_swapchain, |
| 183 | reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR_Bottom), |
| 184 | reinterpret_cast<PFN_vkVoidFunction>(disabledCreateSwapchainKHR), |
| 185 | reinterpret_cast<PFN_vkVoidFunction>(checkedCreateSwapchainKHR), |
| 186 | }, |
| 187 | { |
| 188 | "vkDebugReportMessageEXT", |
| 189 | ProcHook::INSTANCE, |
| 190 | ProcHook::EXT_debug_report, |
| 191 | reinterpret_cast<PFN_vkVoidFunction>(DebugReportMessageEXT_Bottom), |
| 192 | reinterpret_cast<PFN_vkVoidFunction>(disabledDebugReportMessageEXT), |
| 193 | nullptr, |
| 194 | }, |
| 195 | { |
| 196 | "vkDestroyDebugReportCallbackEXT", |
| 197 | ProcHook::INSTANCE, |
| 198 | ProcHook::EXT_debug_report, |
| 199 | reinterpret_cast<PFN_vkVoidFunction>(DestroyDebugReportCallbackEXT_Bottom), |
| 200 | reinterpret_cast<PFN_vkVoidFunction>(disabledDestroyDebugReportCallbackEXT), |
| 201 | nullptr, |
| 202 | }, |
| 203 | { |
| 204 | "vkDestroyDevice", |
| 205 | ProcHook::DEVICE, |
| 206 | ProcHook::EXTENSION_CORE, |
| 207 | reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice_Bottom), |
| 208 | nullptr, |
| 209 | nullptr, |
| 210 | }, |
| 211 | { |
| 212 | "vkDestroyInstance", |
| 213 | ProcHook::INSTANCE, |
| 214 | ProcHook::EXTENSION_CORE, |
| 215 | reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance_Bottom), |
| 216 | nullptr, |
| 217 | nullptr, |
| 218 | }, |
| 219 | { |
| 220 | "vkDestroySurfaceKHR", |
| 221 | ProcHook::INSTANCE, |
| 222 | ProcHook::KHR_surface, |
| 223 | reinterpret_cast<PFN_vkVoidFunction>(DestroySurfaceKHR_Bottom), |
| 224 | reinterpret_cast<PFN_vkVoidFunction>(disabledDestroySurfaceKHR), |
| 225 | nullptr, |
| 226 | }, |
| 227 | { |
| 228 | "vkDestroySwapchainKHR", |
| 229 | ProcHook::DEVICE, |
| 230 | ProcHook::KHR_swapchain, |
| 231 | reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR_Bottom), |
| 232 | reinterpret_cast<PFN_vkVoidFunction>(disabledDestroySwapchainKHR), |
| 233 | reinterpret_cast<PFN_vkVoidFunction>(checkedDestroySwapchainKHR), |
| 234 | }, |
| 235 | { |
| 236 | "vkEnumerateDeviceExtensionProperties", |
| 237 | ProcHook::INSTANCE, |
| 238 | ProcHook::EXTENSION_CORE, |
| 239 | reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties_Bottom), |
| 240 | nullptr, |
| 241 | nullptr, |
| 242 | }, |
| 243 | { |
| 244 | "vkEnumerateInstanceExtensionProperties", |
| 245 | ProcHook::GLOBAL, |
| 246 | ProcHook::EXTENSION_CORE, |
| 247 | reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties), |
| 248 | nullptr, |
| 249 | nullptr, |
| 250 | }, |
| 251 | { |
| 252 | "vkEnumeratePhysicalDevices", |
| 253 | ProcHook::INSTANCE, |
| 254 | ProcHook::EXTENSION_CORE, |
| 255 | reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDevices_Bottom), |
| 256 | nullptr, |
| 257 | nullptr, |
| 258 | }, |
| 259 | { |
| 260 | "vkGetDeviceProcAddr", |
| 261 | ProcHook::DEVICE, |
| 262 | ProcHook::EXTENSION_CORE, |
| 263 | reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr), |
| 264 | nullptr, |
| 265 | nullptr, |
| 266 | }, |
| 267 | { |
| 268 | "vkGetDeviceQueue", |
| 269 | ProcHook::DEVICE, |
| 270 | ProcHook::EXTENSION_CORE, |
Chia-I Wu | ba0be41 | 2016-03-24 16:24:40 +0800 | [diff] [blame] | 271 | reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue), |
Chia-I Wu | eb7db12 | 2016-03-24 09:11:06 +0800 | [diff] [blame] | 272 | nullptr, |
| 273 | nullptr, |
| 274 | }, |
| 275 | { |
| 276 | "vkGetInstanceProcAddr", |
| 277 | ProcHook::INSTANCE, |
| 278 | ProcHook::EXTENSION_CORE, |
| 279 | reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr), |
| 280 | nullptr, |
| 281 | nullptr, |
| 282 | }, |
| 283 | { |
| 284 | "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", |
| 285 | ProcHook::INSTANCE, |
| 286 | ProcHook::KHR_surface, |
| 287 | reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilitiesKHR_Bottom), |
| 288 | reinterpret_cast<PFN_vkVoidFunction>(disabledGetPhysicalDeviceSurfaceCapabilitiesKHR), |
| 289 | nullptr, |
| 290 | }, |
| 291 | { |
| 292 | "vkGetPhysicalDeviceSurfaceFormatsKHR", |
| 293 | ProcHook::INSTANCE, |
| 294 | ProcHook::KHR_surface, |
| 295 | reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormatsKHR_Bottom), |
| 296 | reinterpret_cast<PFN_vkVoidFunction>(disabledGetPhysicalDeviceSurfaceFormatsKHR), |
| 297 | nullptr, |
| 298 | }, |
| 299 | { |
| 300 | "vkGetPhysicalDeviceSurfacePresentModesKHR", |
| 301 | ProcHook::INSTANCE, |
| 302 | ProcHook::KHR_surface, |
| 303 | reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfacePresentModesKHR_Bottom), |
| 304 | reinterpret_cast<PFN_vkVoidFunction>(disabledGetPhysicalDeviceSurfacePresentModesKHR), |
| 305 | nullptr, |
| 306 | }, |
| 307 | { |
| 308 | "vkGetPhysicalDeviceSurfaceSupportKHR", |
| 309 | ProcHook::INSTANCE, |
| 310 | ProcHook::KHR_surface, |
| 311 | reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceSupportKHR_Bottom), |
| 312 | reinterpret_cast<PFN_vkVoidFunction>(disabledGetPhysicalDeviceSurfaceSupportKHR), |
| 313 | nullptr, |
| 314 | }, |
| 315 | { |
| 316 | "vkGetSwapchainGrallocUsageANDROID", |
| 317 | ProcHook::DEVICE, |
| 318 | ProcHook::ANDROID_native_buffer, |
| 319 | nullptr, |
| 320 | nullptr, |
| 321 | nullptr, |
| 322 | }, |
| 323 | { |
| 324 | "vkGetSwapchainImagesKHR", |
| 325 | ProcHook::DEVICE, |
| 326 | ProcHook::KHR_swapchain, |
| 327 | reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR_Bottom), |
| 328 | reinterpret_cast<PFN_vkVoidFunction>(disabledGetSwapchainImagesKHR), |
| 329 | reinterpret_cast<PFN_vkVoidFunction>(checkedGetSwapchainImagesKHR), |
| 330 | }, |
| 331 | { |
| 332 | "vkQueuePresentKHR", |
| 333 | ProcHook::DEVICE, |
| 334 | ProcHook::KHR_swapchain, |
| 335 | reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR_Bottom), |
| 336 | reinterpret_cast<PFN_vkVoidFunction>(disabledQueuePresentKHR), |
| 337 | reinterpret_cast<PFN_vkVoidFunction>(checkedQueuePresentKHR), |
| 338 | }, |
| 339 | { |
| 340 | "vkQueueSignalReleaseImageANDROID", |
| 341 | ProcHook::DEVICE, |
| 342 | ProcHook::ANDROID_native_buffer, |
| 343 | nullptr, |
| 344 | nullptr, |
| 345 | nullptr, |
| 346 | }, |
| 347 | // clang-format on |
| 348 | }; |
| 349 | |
| 350 | } // anonymous |
| 351 | |
| 352 | const ProcHook* GetProcHook(const char* name) { |
| 353 | const auto& begin = g_proc_hooks; |
| 354 | const auto& end = |
| 355 | g_proc_hooks + sizeof(g_proc_hooks) / sizeof(g_proc_hooks[0]); |
| 356 | const auto hook = std::lower_bound( |
| 357 | begin, end, name, |
| 358 | [](const ProcHook& e, const char* n) { return strcmp(e.name, n) < 0; }); |
| 359 | return (hook < end && strcmp(hook->name, name) == 0) ? hook : nullptr; |
| 360 | } |
| 361 | |
| 362 | ProcHook::Extension GetProcHookExtension(const char* name) { |
| 363 | // clang-format off |
| 364 | if (strcmp(name, "VK_ANDROID_native_buffer") == 0) return ProcHook::ANDROID_native_buffer; |
| 365 | if (strcmp(name, "VK_EXT_debug_report") == 0) return ProcHook::EXT_debug_report; |
| 366 | if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface; |
| 367 | if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface; |
| 368 | if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain; |
| 369 | // clang-format on |
| 370 | return ProcHook::EXTENSION_UNKNOWN; |
| 371 | } |
| 372 | |
Chia-I Wu | cc5e276 | 2016-03-24 13:01:16 +0800 | [diff] [blame] | 373 | #define UNLIKELY(expr) __builtin_expect((expr), 0) |
| 374 | |
| 375 | #define INIT_PROC(obj, proc) \ |
| 376 | do { \ |
| 377 | data.driver.proc = \ |
| 378 | reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \ |
| 379 | if (UNLIKELY(!data.driver.proc)) { \ |
| 380 | ALOGE("missing " #obj " proc: vk" #proc); \ |
| 381 | success = false; \ |
| 382 | } \ |
| 383 | } while (0) |
| 384 | |
| 385 | #define INIT_PROC_EXT(ext, obj, proc) \ |
| 386 | do { \ |
| 387 | if (data.hal_extensions[ProcHook::ext]) \ |
| 388 | INIT_PROC(obj, proc); \ |
| 389 | } while (0) |
| 390 | |
| 391 | bool InitDriverTable(VkInstance instance, PFN_vkGetInstanceProcAddr get_proc) { |
| 392 | auto& data = GetData(instance); |
| 393 | bool success = true; |
| 394 | |
| 395 | // clang-format off |
| 396 | INIT_PROC(instance, DestroyInstance); |
| 397 | INIT_PROC(instance, EnumeratePhysicalDevices); |
| 398 | INIT_PROC(instance, GetInstanceProcAddr); |
| 399 | INIT_PROC(instance, CreateDevice); |
| 400 | INIT_PROC(instance, EnumerateDeviceExtensionProperties); |
| 401 | INIT_PROC_EXT(EXT_debug_report, instance, CreateDebugReportCallbackEXT); |
| 402 | INIT_PROC_EXT(EXT_debug_report, instance, DestroyDebugReportCallbackEXT); |
| 403 | INIT_PROC_EXT(EXT_debug_report, instance, DebugReportMessageEXT); |
| 404 | // clang-format on |
| 405 | |
| 406 | return success; |
| 407 | } |
| 408 | |
| 409 | bool InitDriverTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc) { |
| 410 | auto& data = GetData(dev); |
| 411 | bool success = true; |
| 412 | |
| 413 | // clang-format off |
| 414 | INIT_PROC(dev, GetDeviceProcAddr); |
| 415 | INIT_PROC(dev, DestroyDevice); |
| 416 | INIT_PROC(dev, GetDeviceQueue); |
| 417 | INIT_PROC(dev, CreateImage); |
| 418 | INIT_PROC(dev, DestroyImage); |
| 419 | INIT_PROC(dev, AllocateCommandBuffers); |
| 420 | INIT_PROC_EXT(ANDROID_native_buffer, dev, GetSwapchainGrallocUsageANDROID); |
| 421 | INIT_PROC_EXT(ANDROID_native_buffer, dev, AcquireImageANDROID); |
| 422 | INIT_PROC_EXT(ANDROID_native_buffer, dev, QueueSignalReleaseImageANDROID); |
| 423 | // clang-format on |
| 424 | |
| 425 | return success; |
| 426 | } |
| 427 | |
Chia-I Wu | eb7db12 | 2016-03-24 09:11:06 +0800 | [diff] [blame] | 428 | } // namespace driver |
| 429 | } // namespace vulkan |
| 430 | |
| 431 | // clang-format on |