├── .gitmodules ├── .vscode └── tasks.json ├── LICENSE ├── README.md ├── vkel.c ├── vkel.h ├── vkel_gen.bat └── vkel_gen.py /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "Vulkan-Docs"] 2 | path = Vulkan-Docs 3 | url = https://github.com/KhronosGroup/Vulkan-Docs.git 4 | -------------------------------------------------------------------------------- /.vscode/tasks.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "0.1.0", 3 | "showOutput": "always", 4 | 5 | "windows": { 6 | "command": "python", 7 | "showOutput": "always" 8 | }, 9 | 10 | // "args": [ "${workspaceRoot}/vkel_gen.py" ] 11 | "args": [ "${workspaceRoot}/vkel_gen.py", "-f" ] 12 | // "args": [ "${workspaceRoot}/vkel_gen.py", "-k" ] 13 | // "args": [ "${workspaceRoot}/vkel_gen.py", "-f", "-k" ] 14 | } -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Simple Vulkan Extension Loader 2 | 3 | Copyright (c) 2016 Christian Vallentin 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 18 | 2. Altered source versions must be plainly marked as such, and must not 19 | be misrepresented as being the original software. 20 | 21 | 3. This notice may not be removed or altered from any source 22 | distribution. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # vkel - Simple Vulkan Extension Loader [![Build Status](https://drone.io/github.com/MrVallentin/vkel/status.png)](https://drone.io/github.com/MrVallentin/vkel/latest) 2 | 3 | *Simple Dynamic Cross-Platform Vulkan Extension Loader* 4 | 5 | ![License](https://img.shields.io/badge/license-MIT-blue.svg) 6 | ![Release](https://img.shields.io/badge/release-v2.0.11-blue.svg) 7 | 8 | 9 | ## Introduction 10 | 11 | [vkel][vkel] is a simple and easy way of dynamically loading 12 | Vulkan and its function pointers. 13 | [vkel][vkel] can also be used to check which (instance or device) 14 | extensions and layers are available. 15 | 16 | *Also yes, the idea of [vkel][vkel] is indeed 17 | based on [GLEW](https://github.com/nigels-com/glew) and [gl3w](https://github.com/skaslev/gl3w).* 18 | 19 | **Notice:** ~~Your driver might not support the newest released patch, so instead of using 20 | `VK_API_VERSION` use something like `VK_MAKE_VERSION(1, 0, 3)`.~~ In Vulkan 1.0.6 the 21 | `VK_API_VERSION` macro was deprecated and removed, in favor of using `VK_MAKE_VERSION(1, 0, 6)`. 22 | 23 | 24 | #### Vulkan Documentation 25 | 26 | - [Khronos Vulkan Registry](https://www.khronos.org/registry/vulkan/) 27 | 28 | 29 | - [Vulkan 1.0 API References](https://www.khronos.org/registry/vulkan/specs/1.0/apispec.html) [[PDF](https://www.khronos.org/registry/vulkan/specs/1.0/apispec.pdf)] 30 | - [Vulkan 1.0.X Specification](https://www.khronos.org/registry/vulkan/specs/1.0/xhtml/vkspec.html) [[PDF](https://www.khronos.org/registry/vulkan/specs/1.0/pdf/vkspec.pdf)] 31 | - [Vulkan 1.0.X + WSI Extension Specification](https://www.khronos.org/registry/vulkan/specs/1.0-wsi_extensions/xhtml/vkspec.html) [[PDF](https://www.khronos.org/registry/vulkan/specs/1.0-wsi_extensions/pdf/vkspec.pdf)] 32 | 33 | 34 | - [Vulkan 1.0 Quick Reference [PDF]](https://www.khronos.org/registry/vulkan/specs/1.0/refguide/Vulkan-1.0-web.pdf) 35 | 36 | 37 | - [The Khronos Vulkan API Registry for Vulkan [PDF]](https://www.khronos.org/registry/vulkan/specs/1.0/readme.pdf) 38 | - [Vulkan Style Guide](https://www.khronos.org/registry/vulkan/specs/1.0/styleguide.html) 39 | 40 | 41 | ## Setup 42 | 43 | [vkel][vkel] doesn't (any more) require the vulkan headers. 44 | So simply download [vkel.h][vkel.h] and 45 | [vkel.c][vkel.c] and you're done! 46 | *Do note that this takes into account, that the Vulkan library and driver exists on the system.* 47 | 48 | ### Unix-like OS 49 | 50 | On Unix-like OS' you might have to build using `-fPIC` (Position Independent Code). 51 | 52 | Example: `gcc -Wall -g -fPIC -shared -o libvkel.so vkel.c` 53 | 54 | *Before the building problem on UNIX was encountered, someone responded that he/she 55 | was using `gcc -std=c99 -fPIC -shared -o libvkel.so vkel.c` when building.* 56 | 57 | ## Generating 58 | 59 | Overall the only thing needed is [vkel_gen.py][vkel_gen.py]. 60 | When executing the script will temporarily download `vulkan.h` and `vk_platform.h`. Though if they already 61 | exist within the same folder as [vkel_gen.py][vkel_gen.py], 62 | then it will fallback to using them. Be aware that when new versions of the Vulkan headers are available, 63 | this can create problems. 64 | 65 | *There's also two flags you can use when executing the script:* 66 | 67 | - `-f`: force, always download `vulkan.h` and `vk_platform.h` 68 | - `-k`: keep, save `vulkan.h` and `vk_platform.h` 69 | 70 | *Note: `vkel_gen.py` is developed and tested using Python 3.5.1.* 71 | 72 | ## Example: Functionality 73 | 74 | Vulkan does not have a context unlike OpenGL. You create a Vulkan instance, and compared 75 | to OpenGL the Vulkan instance is created via the Vulkan API itself. 76 | *In other words `vkelInit()` can be called as the first thing, without needing anything else beforehand!* 77 | 78 | Though along the way function pointers are needed according to the created `VkInstance` and `VkDevice`, 79 | for that simply use `vkelInstanceInit()` and `vkelDeviceInit()` to reload function pointers and re-check 80 | support for extensions and layers. This is all done relative to the given instance or device. 81 | 82 | ```c 83 | #include // needed for fprintf() 84 | 85 | #include "vkel.h" 86 | 87 | int main(int argc, char **argv) 88 | { 89 | // vkelInit() returns VK_TRUE on success or VK_FALSE on failing 90 | // to load the Vulkan library (meaning that the library is most 91 | // likely missing). 92 | if (!vkelInit()) 93 | { 94 | fprintf(stderr, "Failed to initialize Vulkan\n"); 95 | return -1; 96 | } 97 | 98 | 99 | VkInstance instance; 100 | // Do all the stuff to create a VkInstance 101 | 102 | if (!vkelInstanceInit(instance)) 103 | { 104 | fprintf(stderr, "Failed to initialize Vulkan with VkInstance\n"); 105 | return -1; 106 | } 107 | 108 | 109 | VkDevice device; 110 | // Do all the stuff to create a VkDevice 111 | 112 | if (!vkelDeviceInit(device)) 113 | { 114 | fprintf(stderr, "Failed to initialize Vulkan with VkDevice\n"); 115 | return -1; 116 | } 117 | 118 | 119 | // Static checking is checked on vkelInit() where dynamic checking 120 | // always are checked directly against Vulkan (making the dynamic 121 | // version slower). 122 | 123 | // Statically check if the extension is supported 124 | if (VKEL_KHR_android_surface) 125 | { 126 | // The extension is supported 127 | } 128 | 129 | // Statically check if the extension is supported 130 | if (VKEL_NV_glsl_shader) 131 | { 132 | // The extension is supported 133 | } 134 | 135 | 136 | // Dynamically check if the extension is supported 137 | if (vkelIsInstanceExtensionSupported(NULL, "VK_KHR_android_surface")) 138 | { 139 | // The extension is supported 140 | } 141 | 142 | 143 | // Check if the function is supported 144 | if (vkCreateAndroidSurfaceKHR) 145 | { 146 | // The function is indeed supported 147 | } 148 | 149 | 150 | // All functions found in vulkan.h are automatically loaded making vkelGetProcAddr() 151 | // unneeded unless functions are added which aren't added to vulkan.h 152 | // or when (if ever) using a modified Vulkan library. 153 | 154 | // Manually load function 155 | PFN_vkQueuePresentKHR pfnQueuePresentKHR = (PFN_vkQueuePresentKHR) vkelGetProcAddr("vkQueuePresentKHR"); 156 | PFN_vkQueuePresentKHR pfnQueuePresentKHR = (PFN_vkQueuePresentKHR) vkelGetInstanceProcAddr(instance, "vkQueuePresentKHR"); 157 | PFN_vkQueuePresentKHR pfnQueuePresentKHR = (PFN_vkQueuePresentKHR) vkelGetDeviceProcAddr(device, "vkQueuePresentKHR"); 158 | 159 | 160 | // Release the Vulkan library again (the OS will also do this automatically of course). 161 | vkelUninit(); 162 | 163 | 164 | return 0; 165 | } 166 | ``` 167 | 168 | ## Example: List Supported Extensions 169 | 170 | [vkel][vkel] can also be used to list all 171 | supported extensions and layers using: 172 | 173 | - `vkelGetInstanceExtensionNames` 174 | - `vkelGetInstanceLayerNames` 175 | - `vkelGetDeviceExtensionNames` 176 | - `vkelGetDeviceLayerNames` 177 | 178 | Individual extensions and layers can be checked using: 179 | 180 | - `vkelIsInstanceLayerSupported` 181 | - `vkelIsInstanceExtensionSupported` 182 | - `vkelIsDeviceLayerSupported` 183 | - `vkelIsDeviceExtensionSupported` 184 | 185 | ```c 186 | #include // needed for getchar(), printf() and fprintf() 187 | #include // needed for calloc() and free() 188 | 189 | #include "vkel.h" 190 | 191 | int main(int argc, char **argv) 192 | { 193 | if (!vkelInit()) 194 | { 195 | fprintf(stderr, "Failed to initialize Vulkan\n"); 196 | return -1; 197 | } 198 | 199 | 200 | uint32_t extensionNameCount = 0; 201 | char **extensionNames = vkelGetInstanceExtensionNames(NULL, &extensionNameCount); 202 | 203 | printf("Count: %d\n", extensionNameCount); 204 | 205 | for (uint32_t extensionNameIndex = 0; extensionNameIndex < extensionNameCount; extensionNameIndex++) 206 | { 207 | printf("Extension %d: %s\n", (extensionNameIndex + 1), extensionNames[extensionNameIndex]); 208 | } 209 | 210 | printf("\n"); 211 | 212 | vkelDeleteInstanceExtensionNames(extensionNameCount, extensionNames); 213 | extensionNames = NULL; 214 | 215 | 216 | // Pause, so we get to see something before it exits 217 | getchar(); 218 | 219 | 220 | // Release the Vulkan library again (the OS will also do this automatically of course). 221 | vkelUninit(); 222 | 223 | 224 | return 0; 225 | } 226 | ``` 227 | 228 | ## API Reference 229 | 230 | 231 | ### Initialize 232 | 233 | `VkBool32 vkelInit(void)` 234 | > Initialize and load Vulkan along with the function pointers. Returns `VK_TRUE` when vkel was 235 | > initialized successfully and `VK_FALSE` if the Vulkan library couldn't be loaded (most likely 236 | > meaning that the library is missing). 237 | 238 | `VkBool32 vkelInstanceInit(VkInstance instance)` 239 | > Reload function pointers according to the given `VkInstance`. This also re-checks 240 | > support for extensions and layers. 241 | 242 | `VkBool32 vkelDeviceInit(VkPhysicalDevice physicalDevice, VkDevice device)` 243 | > Reload function pointers according to the given `VkDevice`. This also re-checks 244 | > support for extensions and layers, using the given `VkPhysicalDevice`. 245 | 246 | `void vkelUninit(void)` 247 | > Free the Vulkan library (the OS will do this automatically if `vkelUninit()` isn't called). 248 | 249 | ### Function Pointers 250 | 251 | `PFN_vkVoidFunction vkelGetProcAddr(const char *name)` 252 | > Get a function pointer from the loaded Vulkan library. 253 | 254 | `PFN_vkVoidFunction vkelGetInstanceProcAddr(VkInstance instance, const char *pName)` 255 | > Shortcut for calling `vkGetInstanceProcAddr()`, but if it returns NULL, then call `vkelGetProcAddr()`. 256 | 257 | `PFN_vkVoidFunction vkelGetDeviceProcAddr(VkDevice device, const char *pName)` 258 | > Shortcut for calling `vkGetDeviceProcAddr()`, but if it returns NULL, then call `vkelGetInstanceProcAddr()`. 259 | 260 | 261 | ### Check Supported Extensions/Layers 262 | 263 | - `VkBool32 vkelIsInstanceLayerSupported(const char *pLayerName)` 264 | - `VkBool32 vkelIsDeviceLayerSupported(VkPhysicalDevice physicalDevice, const char *pLayerName)` 265 | 266 | > Check if instance/device layer is supported. 267 | 268 | - `VkBool32 vkelIsInstanceExtensionSupported(const char *pLayerName, const char *pExtensionName)` 269 | - `VkBool32 vkelIsDeviceExtensionSupported(VkPhysicalDevice physicalDevice, const char *pLayerName, const char *pExtensionName)` 270 | 271 | > Check if instance/device extension is supported. 272 | 273 | *Remember that they can be checking using the extension name itself. With the 274 | minor change of having the prefix `VKEL_` instead of `VK_`. Example, `VK_KHR_win32_surface` would 275 | be `VKEL_KHR_win32_surface`.* 276 | 277 | 278 | ### Listing Supported Extensions/Layers 279 | 280 | *Check the example above.* 281 | 282 | - `char** vkelGetInstanceExtensionNames(const char *pLayerName, uint32_t *extensionNameCount)` 283 | - `char** vkelGetDeviceExtensionNames(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *extensionNameCount)` 284 | 285 | > Get an array of all the supported instance/device extension names. 286 | 287 | - `char** vkelGetInstanceLayerNames(uint32_t *layerNameCount)` 288 | - `char** vkelGetDeviceLayerNames(VkPhysicalDevice physicalDevice, uint32_t *layerNameCount)` 289 | 290 | > Get an array of all the supported instance/device layer names. 291 | 292 | - `void vkelDeleteInstanceExtensionNames(uint32_t extensionNameCount, char **extensionNames)` 293 | - `void vkelDeleteInstanceLayerNames(uint32_t layerNameCount, char **layerNames)` 294 | - `void vkelDeleteDeviceExtensionNames(uint32_t extensionNameCount, char **extensionNames)` 295 | - `void vkelDeleteDeviceLayerNames(uint32_t layerNameCount, char **layerNames)` 296 | 297 | > The return `char**` can be manually deleted, but the above function exist for simplifying 298 | > the process. The above functions are also just `#define`'s of `vkelDeleteNames()` 299 | 300 | 301 | ## Reporting Bugs & Requests 302 | 303 | Feel free to use the [issue tracker](https://github.com/MrVallentin/vkel/issues). 304 | Please always include the name and version of the OS where the bug occurs. 305 | 306 | *I don't have the means to test this on all the different OS'. So any confirmation would be much obliged.* 307 | 308 | If you have a solution, then feel free to fork it as well and the changes will be included. 309 | 310 | 311 | ## Dependencies 312 | 313 | - Vulkan - *If you're using this in the young days of Vulkan, then make sure that you have the Vulkan driver installed, if any problems occur.* 314 | - Windows (header) - needed for library loading on Windows 315 | - dlfcn (header) - needed for library loading on non-Windows OS' 316 | - Standard C Libraries (stdio, stdlib, string, assert) - needed for NULL, malloc() calloc(), free(), memset(), assert() 317 | 318 | 319 | ## What's New? / Changelog 320 | 321 | - May 05, 2016 322 | - Fixed [issue #2](https://github.com/MrVallentin/vkel/issues/2) 323 | - May 02, 2016 324 | - Fixed "for loop initial declarations are only allowed in C99 mode". 325 | - Feb 26, 2016 326 | - Rewrote vkel_gen.py, now it parses and directly adds vulkan.h and vk_platform.h into vkel.h, 327 | along with moving the appropriate copyrights to the top of vkel.h. 328 | - Fixed/added better differentiation for instance and device related calls. 329 | - Removed the need for having the vukan.h and vk_platform.h headers. 330 | - Feb 24, 2016 331 | - Created a Python script for automatically generating all the extensions and their functions. (Developed and tested using Python 3.5.1) 332 | - Added cross-platform support, for loading libraries and getting the function addresses. 333 | - Fixed so platform specific functions defaults to NULL 334 | - Added missing include for dlfcn (used on non-Window OS') 335 | - Feb 23, 2016 336 | - Implemented the basic version supporting a few (manually written) dynamically loaded functions. 337 | 338 | 339 | ## License 340 | 341 | ``` 342 | Copyright (c) 2016 Christian Vallentin 343 | 344 | This software is provided 'as-is', without any express or implied 345 | warranty. In no event will the authors be held liable for any damages 346 | arising from the use of this software. 347 | 348 | Permission is granted to anyone to use this software for any purpose, 349 | including commercial applications, and to alter it and redistribute it 350 | freely, subject to the following restrictions: 351 | 352 | 1. The origin of this software must not be misrepresented; you must not 353 | claim that you wrote the original software. If you use this software 354 | in a product, an acknowledgment in the product documentation would be 355 | appreciated but is not required. 356 | 357 | 2. Altered source versions must be plainly marked as such, and must not 358 | be misrepresented as being the original software. 359 | 360 | 3. This notice may not be removed or altered from any source 361 | distribution. 362 | ``` 363 | 364 | 365 | ### Additional Copyright 366 | 367 | Vulkan™ and the Vulkan logo are trademarks of the Khronos Group Inc. 368 | 369 | ![Vulkan Logo](http://advvulkan.com/Vulkan_500px_Mar15.png) 370 | 371 | 372 | ## Specification Updates 373 | 374 | - [Vulkan 1.0.24 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/2dd2b3579b64905edafdef1018ba1b39a8474e7a) 375 | - [Vulkan 1.0.23 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/7f7686d7f2b7c6d780354ca544386476a04c17c4) 376 | - [Vulkan 1.0.22 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/1ca0ea1ef0ed61ee2e2e818f9616a30e9fc70483) 377 | - [Vulkan 1.0.21 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/f4c4113d070c0c9b55b4482055be054dd6466c96) 378 | - [Vulkan 1.0.20 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/e2d981c029105664380e05e61cacc1cab34b1083) 379 | - [Vulkan 1.0.19 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/e5b16130fe5f5c0a8ffd801aa9ea706ef5b63dc8) 380 | - [Vulkan 1.0.18 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/eb9997129d954d52d8772c7f4a19a0bccedc8faa) 381 | - [Vulkan 1.0.17 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/31018cf088c921ab90ec69dee033875807e8faec) 382 | - [Vulkan 1.0.16 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/5de77cf663c84cc2edfa355c49319dca0a869eb2) 383 | - [Vulkan 1.0.15 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/36ce3ba5c1454e3649d3ba60791b0c7009670d25) 384 | - [Vulkan 1.0.14 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/b3d48022bb60ddf67a6699b4c5aa64d52bb1cd4a) 385 | - [Vulkan 1.0.13 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/2656f459333b3a1dc63619a9ebd83490eea22e93) 386 | - [Vulkan 1.0.12 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/75bbb5f4d52321eed41337cc463aa036748a1352) 387 | - [Vulkan 1.0.11 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/ce3204c7dd53a0116ce3a91fd12919d606c306f5) 388 | - [Vulkan 1.0.10 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/3b32b240f6a71aba8e8b746aaab8bba45883de77) 389 | - [Vulkan 1.0.9 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/5d10fc3089ba0ec6a4c7d757a4b18a9ef215d2fb) 390 | - [Vulkan 1.0.8 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/ce3204c7dd53a0116ce3a91fd12919d606c306f5) 391 | - [Vulkan 1.0.7 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/8c3c9b4c85f2539b67148c2de9e2573154c92786) 392 | - [Vulkan 1.0.6 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/1f875738fd9bd0aca5d36bf36794b4b2903e74a9) 393 | - [Vulkan 1.0.5 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/7380aee56b53e9ea3647186ec477202f7f17e28c) 394 | - [Vulkan 1.0.4 Specification Update](https://github.com/KhronosGroup/Vulkan-Docs/commit/5a4c5e5925c65c6e6677c1fb21571684b4b0a77b) 395 | 396 | 397 | [vkel]: https://github.com/MrVallentin/vkel 398 | [vkel.h]: https://github.com/MrVallentin/vkel/blob/master/vkel.h 399 | [vkel.c]: https://github.com/MrVallentin/vkel/blob/master/vkel.c 400 | [vkel_gen.py]: https://github.com/MrVallentin/vkel/blob/master/vkel_gen.py 401 | -------------------------------------------------------------------------------- /vkel.c: -------------------------------------------------------------------------------- 1 | //======================================================================== 2 | // Name 3 | // Vulkan (Cross-Platform) Extension Loader 4 | // 5 | // Repository 6 | // https://github.com/MrVallentin/vkel 7 | // 8 | // Overview 9 | // This is a simple, dynamic and tiny cross-platform Vulkan 10 | // extension loader. 11 | // 12 | // Dependencies 13 | // Vulkan (library) 14 | // Windows (header) - needed for library loading on Windows 15 | // dlfcn (header) - needed for library loading on non-Windows OS' 16 | // Standard C Libraries (stdio, stdlib, string, assert) - needed for NULL, malloc() 17 | // calloc(), free(), memset(), assert() 18 | // 19 | // Notice 20 | // Copyright (c) 2016 Christian Vallentin 21 | // 22 | // Developers & Contributors 23 | // Christian Vallentin 24 | // 25 | // Version History 26 | // Last Modified Date: May 16, 2016 27 | // Revision: 14 28 | // Version: 2.0.11 29 | // 30 | // Revision History 31 | // Revision 12, 2016/05/02 32 | // - Fixed "for loop initial declarations are only 33 | // allowed in C99 mode". 34 | // 35 | // Revision 3, 2016/02/26 36 | // - Rewrote vkel_gen.py, now it parses and directly 37 | // adds vulkan.h and vk_platform.h into vkel.h, 38 | // along with moving the appropriate copyrights 39 | // to the top of vkel.h. 40 | // - Fixed/added better differentiation for instance 41 | // and device related calls. 42 | // - Removed the need for having the vukan.h and 43 | // vk_platform.h headers. 44 | // 45 | // Revision 2, 2016/02/24 46 | // - Created a Python script for automatically generating 47 | // all the extensions and their functions. (Tested with 48 | // Python 3.5.1) 49 | // - Added cross-platform support, for loading libraries 50 | // and getting the function addresses. 51 | // - Fixed so platform specific functions defaults to NULL 52 | // - Added missing include for dlfcn (used on non-Window OS') 53 | // 54 | // Revision 1, 2016/02/23 55 | // - Implemented the basic version supporting a few (manually 56 | // written) dynamically loaded functions. 57 | // 58 | //------------------------------------------------------------------------ 59 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 60 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 61 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 62 | // IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 63 | // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 64 | // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 65 | // OTHER DEALINGS IN THE SOFTWARE. 66 | // 67 | // Permission is granted to anyone to use this software for any purpose, 68 | // including commercial applications, and to alter it and redistribute it 69 | // freely, subject to the following restrictions: 70 | // 71 | // 1. The origin of this software must not be misrepresented; you must not 72 | // claim that you wrote the original software. If you use this software 73 | // in a product, an acknowledgment in the product documentation would 74 | // be appreciated but is not required. 75 | // 76 | // 2. Altered source versions must be plainly marked as such, and must not 77 | // be misrepresented as being the original software. 78 | // 79 | // 3. This notice may not be removed or altered from any source 80 | // distribution. 81 | //======================================================================== 82 | 83 | /* 84 | ** Copyright (c) 2015-2016 The Khronos Group Inc. 85 | ** 86 | ** Licensed under the Apache License, Version 2.0 (the "License"); 87 | ** you may not use this file except in compliance with the License. 88 | ** You may obtain a copy of the License at 89 | ** 90 | ** http://www.apache.org/licenses/LICENSE-2.0 91 | ** 92 | ** Unless required by applicable law or agreed to in writing, software 93 | ** distributed under the License is distributed on an "AS IS" BASIS, 94 | ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 95 | ** See the License for the specific language governing permissions and 96 | ** limitations under the License. 97 | */ 98 | 99 | #include "vkel.h" 100 | 101 | #ifdef __cplusplus 102 | extern "C" { 103 | #endif /* __cplusplus */ 104 | 105 | 106 | #include /* NULL, printf() */ 107 | #include /* malloc(), calloc(), free() */ 108 | #include /* memset() */ 109 | #include /* assert() */ 110 | 111 | 112 | #ifdef VK_USE_PLATFORM_WIN32_KHR 113 | 114 | #ifndef VC_EXTRALEAN 115 | # define VC_EXTRALEAN 116 | #endif 117 | 118 | #ifndef WIN32_LEAN_AND_MEAN 119 | # define WIN32_LEAN_AND_MEAN 120 | #endif 121 | 122 | // STOP THAT, BAD WINDOWS! 123 | #ifndef NOMINMAX 124 | # define NOMINMAX 125 | #endif 126 | 127 | #include 128 | #else 129 | 130 | #include 131 | 132 | #endif 133 | 134 | 135 | #ifdef VK_USE_PLATFORM_WIN32_KHR 136 | # define vkelPlatformOpenLibrary(name) LoadLibraryA(name) 137 | # define vkelPlatformCloseLibrary(handle) FreeLibrary((HMODULE) handle) 138 | # define vkelPlatformGetProcAddr(handle, name) GetProcAddress((HMODULE) handle, name) 139 | // #elif defined(__APPLE__) || defined(__linux__) || defined(__ANDROID__) || defined(__unix__ ) 140 | #else 141 | #define vkelPlatformOpenLibrary(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL) 142 | #define vkelPlatformCloseLibrary(handle) dlclose(handle) 143 | #define vkelPlatformGetProcAddr(handle, name) dlsym(handle, name) 144 | // #else 145 | // # error VKEL Unsupported Platform 146 | #endif 147 | 148 | static void *vkelVkLibHandle; 149 | 150 | 151 | // Instance and device extension names 152 | VkBool32 VKEL_AMD_gcn_shader; 153 | VkBool32 VKEL_AMD_rasterization_order; 154 | VkBool32 VKEL_AMD_shader_explicit_vertex_parameter; 155 | VkBool32 VKEL_AMD_shader_trinary_minmax; 156 | VkBool32 VKEL_EXT_debug_marker; 157 | VkBool32 VKEL_EXT_debug_report; 158 | VkBool32 VKEL_IMG_filter_cubic; 159 | VkBool32 VKEL_IMG_format_pvrtc; 160 | VkBool32 VKEL_KHR_android_surface; 161 | VkBool32 VKEL_KHR_display; 162 | VkBool32 VKEL_KHR_display_swapchain; 163 | VkBool32 VKEL_KHR_mir_surface; 164 | VkBool32 VKEL_KHR_sampler_mirror_clamp_to_edge; 165 | VkBool32 VKEL_KHR_surface; 166 | VkBool32 VKEL_KHR_swapchain; 167 | VkBool32 VKEL_KHR_wayland_surface; 168 | VkBool32 VKEL_KHR_win32_surface; 169 | VkBool32 VKEL_KHR_xcb_surface; 170 | VkBool32 VKEL_KHR_xlib_surface; 171 | VkBool32 VKEL_NV_dedicated_allocation; 172 | VkBool32 VKEL_NV_glsl_shader; 173 | 174 | // Instance and device layer names 175 | VkBool32 VKEL_LAYER_GOOGLE_unique_objects; 176 | VkBool32 VKEL_LAYER_LUNARG_api_dump; 177 | VkBool32 VKEL_LAYER_LUNARG_device_limits; 178 | VkBool32 VKEL_LAYER_LUNARG_draw_state; 179 | VkBool32 VKEL_LAYER_LUNARG_image; 180 | VkBool32 VKEL_LAYER_LUNARG_mem_tracker; 181 | VkBool32 VKEL_LAYER_LUNARG_object_tracker; 182 | VkBool32 VKEL_LAYER_LUNARG_param_checker; 183 | VkBool32 VKEL_LAYER_LUNARG_screenshot; 184 | VkBool32 VKEL_LAYER_LUNARG_swapchain; 185 | VkBool32 VKEL_LAYER_LUNARG_threading; 186 | VkBool32 VKEL_LAYER_LUNARG_vktrace; 187 | 188 | 189 | // Functions 190 | PFN_vkAcquireNextImageKHR __vkAcquireNextImageKHR; 191 | PFN_vkAllocateCommandBuffers __vkAllocateCommandBuffers; 192 | PFN_vkAllocateDescriptorSets __vkAllocateDescriptorSets; 193 | PFN_vkAllocateMemory __vkAllocateMemory; 194 | PFN_vkAllocationFunction __vkAllocationFunction; 195 | PFN_vkBeginCommandBuffer __vkBeginCommandBuffer; 196 | PFN_vkBindBufferMemory __vkBindBufferMemory; 197 | PFN_vkBindImageMemory __vkBindImageMemory; 198 | PFN_vkCmdBeginQuery __vkCmdBeginQuery; 199 | PFN_vkCmdBeginRenderPass __vkCmdBeginRenderPass; 200 | PFN_vkCmdBindDescriptorSets __vkCmdBindDescriptorSets; 201 | PFN_vkCmdBindIndexBuffer __vkCmdBindIndexBuffer; 202 | PFN_vkCmdBindPipeline __vkCmdBindPipeline; 203 | PFN_vkCmdBindVertexBuffers __vkCmdBindVertexBuffers; 204 | PFN_vkCmdBlitImage __vkCmdBlitImage; 205 | PFN_vkCmdClearAttachments __vkCmdClearAttachments; 206 | PFN_vkCmdClearColorImage __vkCmdClearColorImage; 207 | PFN_vkCmdClearDepthStencilImage __vkCmdClearDepthStencilImage; 208 | PFN_vkCmdCopyBuffer __vkCmdCopyBuffer; 209 | PFN_vkCmdCopyBufferToImage __vkCmdCopyBufferToImage; 210 | PFN_vkCmdCopyImage __vkCmdCopyImage; 211 | PFN_vkCmdCopyImageToBuffer __vkCmdCopyImageToBuffer; 212 | PFN_vkCmdCopyQueryPoolResults __vkCmdCopyQueryPoolResults; 213 | PFN_vkCmdDebugMarkerBeginEXT __vkCmdDebugMarkerBeginEXT; 214 | PFN_vkCmdDebugMarkerEndEXT __vkCmdDebugMarkerEndEXT; 215 | PFN_vkCmdDebugMarkerInsertEXT __vkCmdDebugMarkerInsertEXT; 216 | PFN_vkCmdDispatch __vkCmdDispatch; 217 | PFN_vkCmdDispatchIndirect __vkCmdDispatchIndirect; 218 | PFN_vkCmdDraw __vkCmdDraw; 219 | PFN_vkCmdDrawIndexed __vkCmdDrawIndexed; 220 | PFN_vkCmdDrawIndexedIndirect __vkCmdDrawIndexedIndirect; 221 | PFN_vkCmdDrawIndirect __vkCmdDrawIndirect; 222 | PFN_vkCmdEndQuery __vkCmdEndQuery; 223 | PFN_vkCmdEndRenderPass __vkCmdEndRenderPass; 224 | PFN_vkCmdExecuteCommands __vkCmdExecuteCommands; 225 | PFN_vkCmdFillBuffer __vkCmdFillBuffer; 226 | PFN_vkCmdNextSubpass __vkCmdNextSubpass; 227 | PFN_vkCmdPipelineBarrier __vkCmdPipelineBarrier; 228 | PFN_vkCmdPushConstants __vkCmdPushConstants; 229 | PFN_vkCmdResetEvent __vkCmdResetEvent; 230 | PFN_vkCmdResetQueryPool __vkCmdResetQueryPool; 231 | PFN_vkCmdResolveImage __vkCmdResolveImage; 232 | PFN_vkCmdSetBlendConstants __vkCmdSetBlendConstants; 233 | PFN_vkCmdSetDepthBias __vkCmdSetDepthBias; 234 | PFN_vkCmdSetDepthBounds __vkCmdSetDepthBounds; 235 | PFN_vkCmdSetEvent __vkCmdSetEvent; 236 | PFN_vkCmdSetLineWidth __vkCmdSetLineWidth; 237 | PFN_vkCmdSetScissor __vkCmdSetScissor; 238 | PFN_vkCmdSetStencilCompareMask __vkCmdSetStencilCompareMask; 239 | PFN_vkCmdSetStencilReference __vkCmdSetStencilReference; 240 | PFN_vkCmdSetStencilWriteMask __vkCmdSetStencilWriteMask; 241 | PFN_vkCmdSetViewport __vkCmdSetViewport; 242 | PFN_vkCmdUpdateBuffer __vkCmdUpdateBuffer; 243 | PFN_vkCmdWaitEvents __vkCmdWaitEvents; 244 | PFN_vkCmdWriteTimestamp __vkCmdWriteTimestamp; 245 | PFN_vkCreateBuffer __vkCreateBuffer; 246 | PFN_vkCreateBufferView __vkCreateBufferView; 247 | PFN_vkCreateCommandPool __vkCreateCommandPool; 248 | PFN_vkCreateComputePipelines __vkCreateComputePipelines; 249 | PFN_vkCreateDebugReportCallbackEXT __vkCreateDebugReportCallbackEXT; 250 | PFN_vkCreateDescriptorPool __vkCreateDescriptorPool; 251 | PFN_vkCreateDescriptorSetLayout __vkCreateDescriptorSetLayout; 252 | PFN_vkCreateDevice __vkCreateDevice; 253 | PFN_vkCreateDisplayModeKHR __vkCreateDisplayModeKHR; 254 | PFN_vkCreateDisplayPlaneSurfaceKHR __vkCreateDisplayPlaneSurfaceKHR; 255 | PFN_vkCreateEvent __vkCreateEvent; 256 | PFN_vkCreateFence __vkCreateFence; 257 | PFN_vkCreateFramebuffer __vkCreateFramebuffer; 258 | PFN_vkCreateGraphicsPipelines __vkCreateGraphicsPipelines; 259 | PFN_vkCreateImage __vkCreateImage; 260 | PFN_vkCreateImageView __vkCreateImageView; 261 | PFN_vkCreateInstance __vkCreateInstance; 262 | PFN_vkCreatePipelineCache __vkCreatePipelineCache; 263 | PFN_vkCreatePipelineLayout __vkCreatePipelineLayout; 264 | PFN_vkCreateQueryPool __vkCreateQueryPool; 265 | PFN_vkCreateRenderPass __vkCreateRenderPass; 266 | PFN_vkCreateSampler __vkCreateSampler; 267 | PFN_vkCreateSemaphore __vkCreateSemaphore; 268 | PFN_vkCreateShaderModule __vkCreateShaderModule; 269 | PFN_vkCreateSharedSwapchainsKHR __vkCreateSharedSwapchainsKHR; 270 | PFN_vkCreateSwapchainKHR __vkCreateSwapchainKHR; 271 | PFN_vkDebugMarkerSetObjectNameEXT __vkDebugMarkerSetObjectNameEXT; 272 | PFN_vkDebugMarkerSetObjectTagEXT __vkDebugMarkerSetObjectTagEXT; 273 | PFN_vkDebugReportCallbackEXT __vkDebugReportCallbackEXT; 274 | PFN_vkDebugReportMessageEXT __vkDebugReportMessageEXT; 275 | PFN_vkDestroyBuffer __vkDestroyBuffer; 276 | PFN_vkDestroyBufferView __vkDestroyBufferView; 277 | PFN_vkDestroyCommandPool __vkDestroyCommandPool; 278 | PFN_vkDestroyDebugReportCallbackEXT __vkDestroyDebugReportCallbackEXT; 279 | PFN_vkDestroyDescriptorPool __vkDestroyDescriptorPool; 280 | PFN_vkDestroyDescriptorSetLayout __vkDestroyDescriptorSetLayout; 281 | PFN_vkDestroyDevice __vkDestroyDevice; 282 | PFN_vkDestroyEvent __vkDestroyEvent; 283 | PFN_vkDestroyFence __vkDestroyFence; 284 | PFN_vkDestroyFramebuffer __vkDestroyFramebuffer; 285 | PFN_vkDestroyImage __vkDestroyImage; 286 | PFN_vkDestroyImageView __vkDestroyImageView; 287 | PFN_vkDestroyInstance __vkDestroyInstance; 288 | PFN_vkDestroyPipeline __vkDestroyPipeline; 289 | PFN_vkDestroyPipelineCache __vkDestroyPipelineCache; 290 | PFN_vkDestroyPipelineLayout __vkDestroyPipelineLayout; 291 | PFN_vkDestroyQueryPool __vkDestroyQueryPool; 292 | PFN_vkDestroyRenderPass __vkDestroyRenderPass; 293 | PFN_vkDestroySampler __vkDestroySampler; 294 | PFN_vkDestroySemaphore __vkDestroySemaphore; 295 | PFN_vkDestroyShaderModule __vkDestroyShaderModule; 296 | PFN_vkDestroySurfaceKHR __vkDestroySurfaceKHR; 297 | PFN_vkDestroySwapchainKHR __vkDestroySwapchainKHR; 298 | PFN_vkDeviceWaitIdle __vkDeviceWaitIdle; 299 | PFN_vkEndCommandBuffer __vkEndCommandBuffer; 300 | PFN_vkEnumerateDeviceExtensionProperties __vkEnumerateDeviceExtensionProperties; 301 | PFN_vkEnumerateDeviceLayerProperties __vkEnumerateDeviceLayerProperties; 302 | PFN_vkEnumerateInstanceExtensionProperties __vkEnumerateInstanceExtensionProperties; 303 | PFN_vkEnumerateInstanceLayerProperties __vkEnumerateInstanceLayerProperties; 304 | PFN_vkEnumeratePhysicalDevices __vkEnumeratePhysicalDevices; 305 | PFN_vkFlushMappedMemoryRanges __vkFlushMappedMemoryRanges; 306 | PFN_vkFreeCommandBuffers __vkFreeCommandBuffers; 307 | PFN_vkFreeDescriptorSets __vkFreeDescriptorSets; 308 | PFN_vkFreeFunction __vkFreeFunction; 309 | PFN_vkFreeMemory __vkFreeMemory; 310 | PFN_vkGetBufferMemoryRequirements __vkGetBufferMemoryRequirements; 311 | PFN_vkGetDeviceMemoryCommitment __vkGetDeviceMemoryCommitment; 312 | PFN_vkGetDeviceProcAddr __vkGetDeviceProcAddr; 313 | PFN_vkGetDeviceQueue __vkGetDeviceQueue; 314 | PFN_vkGetDisplayModePropertiesKHR __vkGetDisplayModePropertiesKHR; 315 | PFN_vkGetDisplayPlaneCapabilitiesKHR __vkGetDisplayPlaneCapabilitiesKHR; 316 | PFN_vkGetDisplayPlaneSupportedDisplaysKHR __vkGetDisplayPlaneSupportedDisplaysKHR; 317 | PFN_vkGetEventStatus __vkGetEventStatus; 318 | PFN_vkGetFenceStatus __vkGetFenceStatus; 319 | PFN_vkGetImageMemoryRequirements __vkGetImageMemoryRequirements; 320 | PFN_vkGetImageSparseMemoryRequirements __vkGetImageSparseMemoryRequirements; 321 | PFN_vkGetImageSubresourceLayout __vkGetImageSubresourceLayout; 322 | PFN_vkGetInstanceProcAddr __vkGetInstanceProcAddr; 323 | PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR __vkGetPhysicalDeviceDisplayPlanePropertiesKHR; 324 | PFN_vkGetPhysicalDeviceDisplayPropertiesKHR __vkGetPhysicalDeviceDisplayPropertiesKHR; 325 | PFN_vkGetPhysicalDeviceFeatures __vkGetPhysicalDeviceFeatures; 326 | PFN_vkGetPhysicalDeviceFormatProperties __vkGetPhysicalDeviceFormatProperties; 327 | PFN_vkGetPhysicalDeviceImageFormatProperties __vkGetPhysicalDeviceImageFormatProperties; 328 | PFN_vkGetPhysicalDeviceMemoryProperties __vkGetPhysicalDeviceMemoryProperties; 329 | PFN_vkGetPhysicalDeviceProperties __vkGetPhysicalDeviceProperties; 330 | PFN_vkGetPhysicalDeviceQueueFamilyProperties __vkGetPhysicalDeviceQueueFamilyProperties; 331 | PFN_vkGetPhysicalDeviceSparseImageFormatProperties __vkGetPhysicalDeviceSparseImageFormatProperties; 332 | PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR __vkGetPhysicalDeviceSurfaceCapabilitiesKHR; 333 | PFN_vkGetPhysicalDeviceSurfaceFormatsKHR __vkGetPhysicalDeviceSurfaceFormatsKHR; 334 | PFN_vkGetPhysicalDeviceSurfacePresentModesKHR __vkGetPhysicalDeviceSurfacePresentModesKHR; 335 | PFN_vkGetPhysicalDeviceSurfaceSupportKHR __vkGetPhysicalDeviceSurfaceSupportKHR; 336 | PFN_vkGetPipelineCacheData __vkGetPipelineCacheData; 337 | PFN_vkGetQueryPoolResults __vkGetQueryPoolResults; 338 | PFN_vkGetRenderAreaGranularity __vkGetRenderAreaGranularity; 339 | PFN_vkGetSwapchainImagesKHR __vkGetSwapchainImagesKHR; 340 | PFN_vkInternalAllocationNotification __vkInternalAllocationNotification; 341 | PFN_vkInternalFreeNotification __vkInternalFreeNotification; 342 | PFN_vkInvalidateMappedMemoryRanges __vkInvalidateMappedMemoryRanges; 343 | PFN_vkMapMemory __vkMapMemory; 344 | PFN_vkMergePipelineCaches __vkMergePipelineCaches; 345 | PFN_vkQueueBindSparse __vkQueueBindSparse; 346 | PFN_vkQueuePresentKHR __vkQueuePresentKHR; 347 | PFN_vkQueueSubmit __vkQueueSubmit; 348 | PFN_vkQueueWaitIdle __vkQueueWaitIdle; 349 | PFN_vkReallocationFunction __vkReallocationFunction; 350 | PFN_vkResetCommandBuffer __vkResetCommandBuffer; 351 | PFN_vkResetCommandPool __vkResetCommandPool; 352 | PFN_vkResetDescriptorPool __vkResetDescriptorPool; 353 | PFN_vkResetEvent __vkResetEvent; 354 | PFN_vkResetFences __vkResetFences; 355 | PFN_vkSetEvent __vkSetEvent; 356 | PFN_vkUnmapMemory __vkUnmapMemory; 357 | PFN_vkUpdateDescriptorSets __vkUpdateDescriptorSets; 358 | PFN_vkVoidFunction __vkVoidFunction; 359 | PFN_vkWaitForFences __vkWaitForFences; 360 | 361 | #ifdef VK_USE_PLATFORM_ANDROID_KHR 362 | PFN_vkCreateAndroidSurfaceKHR __vkCreateAndroidSurfaceKHR; 363 | #endif /* VK_USE_PLATFORM_ANDROID_KHR */ 364 | 365 | #ifdef VK_USE_PLATFORM_MIR_KHR 366 | PFN_vkCreateMirSurfaceKHR __vkCreateMirSurfaceKHR; 367 | PFN_vkGetPhysicalDeviceMirPresentationSupportKHR __vkGetPhysicalDeviceMirPresentationSupportKHR; 368 | #endif /* VK_USE_PLATFORM_MIR_KHR */ 369 | 370 | #ifdef VK_USE_PLATFORM_WAYLAND_KHR 371 | PFN_vkCreateWaylandSurfaceKHR __vkCreateWaylandSurfaceKHR; 372 | PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR __vkGetPhysicalDeviceWaylandPresentationSupportKHR; 373 | #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ 374 | 375 | #ifdef VK_USE_PLATFORM_WIN32_KHR 376 | PFN_vkCreateWin32SurfaceKHR __vkCreateWin32SurfaceKHR; 377 | PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR __vkGetPhysicalDeviceWin32PresentationSupportKHR; 378 | #endif /* VK_USE_PLATFORM_WIN32_KHR */ 379 | 380 | #ifdef VK_USE_PLATFORM_XCB_KHR 381 | PFN_vkCreateXcbSurfaceKHR __vkCreateXcbSurfaceKHR; 382 | PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR __vkGetPhysicalDeviceXcbPresentationSupportKHR; 383 | #endif /* VK_USE_PLATFORM_XCB_KHR */ 384 | 385 | #ifdef VK_USE_PLATFORM_XLIB_KHR 386 | PFN_vkCreateXlibSurfaceKHR __vkCreateXlibSurfaceKHR; 387 | PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR __vkGetPhysicalDeviceXlibPresentationSupportKHR; 388 | #endif /* VK_USE_PLATFORM_XLIB_KHR */ 389 | 390 | 391 | PFN_vkVoidFunction vkelGetProcAddr(const char *name) 392 | { 393 | return (PFN_vkVoidFunction) vkelPlatformGetProcAddr(vkelVkLibHandle, name); 394 | } 395 | 396 | PFN_vkVoidFunction vkelGetInstanceProcAddr(VkInstance instance, const char *pName) 397 | { 398 | PFN_vkVoidFunction proc = (PFN_vkVoidFunction) vkGetInstanceProcAddr(instance, pName); 399 | 400 | if (!proc) 401 | proc = (PFN_vkVoidFunction) vkelGetProcAddr(pName); 402 | 403 | return proc; 404 | } 405 | 406 | PFN_vkVoidFunction vkelGetDeviceProcAddr(VkDevice device, const char *pName) 407 | { 408 | PFN_vkVoidFunction proc = (PFN_vkVoidFunction) vkGetDeviceProcAddr(device, pName); 409 | 410 | if (!proc) 411 | proc = (PFN_vkVoidFunction) vkelGetInstanceProcAddr(NULL, pName); 412 | 413 | return proc; 414 | } 415 | 416 | 417 | static int vkel_strcmp(const char *str1, const char *str2) 418 | { 419 | while (*str1 && (*str1 == *str2)) 420 | { 421 | str1++, str2++; 422 | } 423 | 424 | return *(const unsigned char*) str1 - *(const unsigned char*) str2; 425 | } 426 | 427 | static void vkel_strpy(char *dest, char *src) 428 | { 429 | while (*dest++ = *src++); 430 | } 431 | 432 | 433 | void vkelDeleteNames(uint32_t nameCount, char **names) 434 | { 435 | // assert(names); 436 | if (!names) 437 | return; 438 | 439 | uint32_t nameIndex = 0; 440 | for (nameIndex = 0; nameIndex < nameCount; nameIndex++) 441 | { 442 | // assert(names[nameIndex]); 443 | if (!names[nameIndex]) 444 | continue; 445 | 446 | free(names[nameIndex]); 447 | } 448 | 449 | free(names); 450 | } 451 | 452 | 453 | char** vkelGetInstanceExtensionNames(const char *pLayerName, uint32_t *extensionNameCount) 454 | { 455 | assert(extensionNameCount); 456 | 457 | 458 | VkResult err; 459 | 460 | 461 | uint32_t extPropertyCount; 462 | err = vkEnumerateInstanceExtensionProperties(pLayerName, &extPropertyCount, NULL); 463 | assert(!err); 464 | 465 | (*extensionNameCount) = extPropertyCount; 466 | 467 | if (extPropertyCount < 1) 468 | return NULL; 469 | 470 | 471 | char **extensionNames = (char**) calloc(extPropertyCount, sizeof(char*)); 472 | 473 | uint32_t extensionNameIndex = 0; 474 | for (extensionNameIndex = 0; extensionNameIndex < extPropertyCount; extensionNameIndex++) 475 | { 476 | extensionNames[extensionNameIndex] = (char*)calloc(VK_MAX_EXTENSION_NAME_SIZE, sizeof(char)); 477 | } 478 | 479 | 480 | VkExtensionProperties *extProperties = (VkExtensionProperties*) calloc(extPropertyCount, sizeof(VkExtensionProperties)); 481 | assert(extProperties); 482 | 483 | 484 | err = vkEnumerateInstanceExtensionProperties(pLayerName, &extPropertyCount, extProperties); 485 | assert(!err); 486 | 487 | uint32_t extPropertyIndex = 0; 488 | for (extPropertyIndex = 0; extPropertyIndex < extPropertyCount; extPropertyIndex++) 489 | { 490 | VkExtensionProperties extProperty = extProperties[extPropertyIndex]; 491 | 492 | vkel_strpy(extensionNames[extPropertyIndex], extProperty.extensionName); 493 | } 494 | 495 | 496 | free(extProperties); 497 | 498 | 499 | return extensionNames; 500 | } 501 | 502 | char** vkelGetInstanceLayerNames(uint32_t *layerNameCount) 503 | { 504 | assert(layerNameCount); 505 | 506 | 507 | VkResult err; 508 | 509 | 510 | uint32_t layerPropertyCount; 511 | err = vkEnumerateInstanceLayerProperties(&layerPropertyCount, NULL); 512 | assert(!err); 513 | 514 | (*layerNameCount) = layerPropertyCount; 515 | 516 | if (layerPropertyCount < 1) 517 | return NULL; 518 | 519 | 520 | char **layerNames = (char**) calloc(layerPropertyCount, sizeof(char*)); 521 | 522 | uint32_t layerNameIndex = 0; 523 | for (layerNameIndex = 0; layerNameIndex < layerPropertyCount; layerNameIndex++) 524 | { 525 | layerNames[layerNameIndex] = (char*) calloc(VK_MAX_EXTENSION_NAME_SIZE, sizeof(char)); 526 | } 527 | 528 | 529 | VkLayerProperties *layerProperties = (VkLayerProperties*) calloc(layerPropertyCount, sizeof(VkLayerProperties)); 530 | assert(layerProperties); 531 | 532 | err = vkEnumerateInstanceLayerProperties(&layerPropertyCount, layerProperties); 533 | assert(!err); 534 | 535 | uint32_t layerPropertyIndex = 0; 536 | for (layerPropertyIndex = 0; layerPropertyIndex < layerPropertyCount; layerPropertyIndex++) 537 | { 538 | VkLayerProperties layerProperty = layerProperties[layerPropertyIndex]; 539 | 540 | vkel_strpy(layerNames[layerPropertyIndex], layerProperty.layerName); 541 | } 542 | 543 | 544 | free(layerProperties); 545 | 546 | 547 | return layerNames; 548 | } 549 | 550 | 551 | char** vkelGetDeviceExtensionNames(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *extensionNameCount) 552 | { 553 | assert(extensionNameCount); 554 | 555 | 556 | VkResult err; 557 | 558 | 559 | uint32_t extPropertyCount; 560 | err = vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, &extPropertyCount, NULL); 561 | assert(!err); 562 | 563 | (*extensionNameCount) = extPropertyCount; 564 | 565 | if (extPropertyCount < 1) 566 | return NULL; 567 | 568 | 569 | char **extensionNames = (char**) calloc(extPropertyCount, sizeof(char*)); 570 | 571 | uint32_t extensionNameIndex = 0; 572 | for (extensionNameIndex = 0; extensionNameIndex < extPropertyCount; extensionNameIndex++) 573 | { 574 | extensionNames[extensionNameIndex] = (char*) calloc(VK_MAX_EXTENSION_NAME_SIZE, sizeof(char)); 575 | } 576 | 577 | 578 | VkExtensionProperties *extProperties = (VkExtensionProperties*) calloc(extPropertyCount, sizeof(VkExtensionProperties)); 579 | assert(extProperties); 580 | 581 | 582 | err = vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, &extPropertyCount, extProperties); 583 | assert(!err); 584 | 585 | uint32_t extPropertyIndex = 0; 586 | for (extPropertyIndex = 0; extPropertyIndex < extPropertyCount; extPropertyIndex++) 587 | { 588 | VkExtensionProperties extProperty = extProperties[extPropertyIndex]; 589 | 590 | vkel_strpy(extensionNames[extPropertyIndex], extProperty.extensionName); 591 | } 592 | 593 | 594 | free(extProperties); 595 | 596 | 597 | return extensionNames; 598 | } 599 | 600 | char** vkelGetDeviceLayerNames(VkPhysicalDevice physicalDevice, uint32_t *layerNameCount) 601 | { 602 | assert(layerNameCount); 603 | 604 | 605 | VkResult err; 606 | 607 | 608 | uint32_t layerPropertyCount; 609 | err = vkEnumerateDeviceLayerProperties(physicalDevice, &layerPropertyCount, NULL); 610 | assert(!err); 611 | 612 | (*layerNameCount) = layerPropertyCount; 613 | 614 | if (layerPropertyCount < 1) 615 | return NULL; 616 | 617 | 618 | char **layerNames = (char**) calloc(layerPropertyCount, sizeof(char*)); 619 | 620 | uint32_t layerNameIndex = 0; 621 | for (layerNameIndex = 0; layerNameIndex < layerPropertyCount; layerNameIndex++) 622 | { 623 | layerNames[layerNameIndex] = (char*) calloc(VK_MAX_EXTENSION_NAME_SIZE, sizeof(char)); 624 | } 625 | 626 | 627 | VkLayerProperties *layerProperties = (VkLayerProperties*) calloc(layerPropertyCount, sizeof(VkLayerProperties)); 628 | assert(layerProperties); 629 | 630 | err = vkEnumerateDeviceLayerProperties(physicalDevice, &layerPropertyCount, layerProperties); 631 | assert(!err); 632 | 633 | uint32_t layerPropertyIndex = 0; 634 | for (layerPropertyIndex = 0; layerPropertyIndex < layerPropertyCount; layerPropertyIndex++) 635 | { 636 | VkLayerProperties layerProperty = layerProperties[layerPropertyIndex]; 637 | 638 | vkel_strpy(layerNames[layerPropertyIndex], layerProperty.layerName); 639 | } 640 | 641 | 642 | free(layerProperties); 643 | 644 | 645 | return layerNames; 646 | } 647 | 648 | 649 | VkBool32 vkelIsInstanceLayerSupported(const char *pLayerName) 650 | { 651 | uint32_t layerNameCount = 0; 652 | char **layerNames = vkelGetInstanceLayerNames(&layerNameCount); 653 | 654 | uint32_t layerNameIndex = 0; 655 | for (layerNameIndex = 0; layerNameIndex < layerNameCount; layerNameIndex++) 656 | { 657 | if (vkel_strcmp(layerNames[layerNameIndex], pLayerName)) 658 | { 659 | vkelDeleteInstanceLayerNames(layerNameCount, layerNames); 660 | 661 | return VK_TRUE; 662 | } 663 | } 664 | 665 | vkelDeleteInstanceLayerNames(layerNameCount, layerNames); 666 | 667 | return VK_FALSE; 668 | } 669 | 670 | VkBool32 vkelIsInstanceExtensionSupported(const char *pLayerName, const char *pExtensionName) 671 | { 672 | uint32_t extensionNameCount = 0; 673 | char **extensionNames = vkelGetInstanceExtensionNames(pLayerName, &extensionNameCount); 674 | 675 | uint32_t extensionNameIndex = 0; 676 | for (extensionNameIndex = 0; extensionNameIndex < extensionNameCount; extensionNameIndex++) 677 | { 678 | if (vkel_strcmp(extensionNames[extensionNameIndex], pExtensionName)) 679 | { 680 | vkelDeleteInstanceExtensionNames(extensionNameCount, extensionNames); 681 | 682 | return VK_TRUE; 683 | } 684 | } 685 | 686 | vkelDeleteInstanceExtensionNames(extensionNameCount, extensionNames); 687 | 688 | return VK_FALSE; 689 | } 690 | 691 | 692 | VkBool32 vkelIsDeviceLayerSupported(VkPhysicalDevice physicalDevice, const char *pLayerName) 693 | { 694 | uint32_t layerNameCount = 0; 695 | char **layerNames = vkelGetDeviceLayerNames(physicalDevice, &layerNameCount); 696 | 697 | uint32_t layerNameIndex = 0; 698 | for (layerNameIndex = 0; layerNameIndex < layerNameCount; layerNameIndex++) 699 | { 700 | if (vkel_strcmp(layerNames[layerNameIndex], pLayerName)) 701 | { 702 | vkelDeleteDeviceLayerNames(layerNameCount, layerNames); 703 | 704 | return VK_TRUE; 705 | } 706 | } 707 | 708 | vkelDeleteDeviceLayerNames(layerNameCount, layerNames); 709 | 710 | return VK_FALSE; 711 | } 712 | 713 | VkBool32 vkelIsDeviceExtensionSupported(VkPhysicalDevice physicalDevice, const char *pLayerName, const char *pExtensionName) 714 | { 715 | uint32_t extensionNameCount = 0; 716 | char **extensionNames = vkelGetDeviceExtensionNames(physicalDevice, pLayerName, &extensionNameCount); 717 | 718 | uint32_t extensionNameIndex = 0; 719 | for (extensionNameIndex = 0; extensionNameIndex < extensionNameCount; extensionNameIndex++) 720 | { 721 | if (vkel_strcmp(extensionNames[extensionNameIndex], pExtensionName)) 722 | { 723 | vkelDeleteDeviceExtensionNames(extensionNameCount, extensionNames); 724 | 725 | return VK_TRUE; 726 | } 727 | } 728 | 729 | vkelDeleteDeviceExtensionNames(extensionNameCount, extensionNames); 730 | 731 | return VK_FALSE; 732 | } 733 | 734 | 735 | VkBool32 vkelInit(void) 736 | { 737 | vkelUninit(); 738 | 739 | #ifdef VK_USE_PLATFORM_WIN32_KHR 740 | const char *name = "vulkan-1.dll"; 741 | #else 742 | const char *name = "libvulkan.so.1"; 743 | #endif 744 | 745 | vkelVkLibHandle = vkelPlatformOpenLibrary(name); 746 | 747 | if (!vkelVkLibHandle) 748 | return VK_FALSE; 749 | 750 | 751 | __vkAcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) vkelGetProcAddr("vkAcquireNextImageKHR"); 752 | __vkAllocateCommandBuffers = (PFN_vkAllocateCommandBuffers) vkelGetProcAddr("vkAllocateCommandBuffers"); 753 | __vkAllocateDescriptorSets = (PFN_vkAllocateDescriptorSets) vkelGetProcAddr("vkAllocateDescriptorSets"); 754 | __vkAllocateMemory = (PFN_vkAllocateMemory) vkelGetProcAddr("vkAllocateMemory"); 755 | __vkAllocationFunction = (PFN_vkAllocationFunction) vkelGetProcAddr("vkAllocationFunction"); 756 | __vkBeginCommandBuffer = (PFN_vkBeginCommandBuffer) vkelGetProcAddr("vkBeginCommandBuffer"); 757 | __vkBindBufferMemory = (PFN_vkBindBufferMemory) vkelGetProcAddr("vkBindBufferMemory"); 758 | __vkBindImageMemory = (PFN_vkBindImageMemory) vkelGetProcAddr("vkBindImageMemory"); 759 | __vkCmdBeginQuery = (PFN_vkCmdBeginQuery) vkelGetProcAddr("vkCmdBeginQuery"); 760 | __vkCmdBeginRenderPass = (PFN_vkCmdBeginRenderPass) vkelGetProcAddr("vkCmdBeginRenderPass"); 761 | __vkCmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) vkelGetProcAddr("vkCmdBindDescriptorSets"); 762 | __vkCmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer) vkelGetProcAddr("vkCmdBindIndexBuffer"); 763 | __vkCmdBindPipeline = (PFN_vkCmdBindPipeline) vkelGetProcAddr("vkCmdBindPipeline"); 764 | __vkCmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers) vkelGetProcAddr("vkCmdBindVertexBuffers"); 765 | __vkCmdBlitImage = (PFN_vkCmdBlitImage) vkelGetProcAddr("vkCmdBlitImage"); 766 | __vkCmdClearAttachments = (PFN_vkCmdClearAttachments) vkelGetProcAddr("vkCmdClearAttachments"); 767 | __vkCmdClearColorImage = (PFN_vkCmdClearColorImage) vkelGetProcAddr("vkCmdClearColorImage"); 768 | __vkCmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage) vkelGetProcAddr("vkCmdClearDepthStencilImage"); 769 | __vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer) vkelGetProcAddr("vkCmdCopyBuffer"); 770 | __vkCmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage) vkelGetProcAddr("vkCmdCopyBufferToImage"); 771 | __vkCmdCopyImage = (PFN_vkCmdCopyImage) vkelGetProcAddr("vkCmdCopyImage"); 772 | __vkCmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer) vkelGetProcAddr("vkCmdCopyImageToBuffer"); 773 | __vkCmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults) vkelGetProcAddr("vkCmdCopyQueryPoolResults"); 774 | __vkCmdDebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT) vkelGetProcAddr("vkCmdDebugMarkerBeginEXT"); 775 | __vkCmdDebugMarkerEndEXT = (PFN_vkCmdDebugMarkerEndEXT) vkelGetProcAddr("vkCmdDebugMarkerEndEXT"); 776 | __vkCmdDebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT) vkelGetProcAddr("vkCmdDebugMarkerInsertEXT"); 777 | __vkCmdDispatch = (PFN_vkCmdDispatch) vkelGetProcAddr("vkCmdDispatch"); 778 | __vkCmdDispatchIndirect = (PFN_vkCmdDispatchIndirect) vkelGetProcAddr("vkCmdDispatchIndirect"); 779 | __vkCmdDraw = (PFN_vkCmdDraw) vkelGetProcAddr("vkCmdDraw"); 780 | __vkCmdDrawIndexed = (PFN_vkCmdDrawIndexed) vkelGetProcAddr("vkCmdDrawIndexed"); 781 | __vkCmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect) vkelGetProcAddr("vkCmdDrawIndexedIndirect"); 782 | __vkCmdDrawIndirect = (PFN_vkCmdDrawIndirect) vkelGetProcAddr("vkCmdDrawIndirect"); 783 | __vkCmdEndQuery = (PFN_vkCmdEndQuery) vkelGetProcAddr("vkCmdEndQuery"); 784 | __vkCmdEndRenderPass = (PFN_vkCmdEndRenderPass) vkelGetProcAddr("vkCmdEndRenderPass"); 785 | __vkCmdExecuteCommands = (PFN_vkCmdExecuteCommands) vkelGetProcAddr("vkCmdExecuteCommands"); 786 | __vkCmdFillBuffer = (PFN_vkCmdFillBuffer) vkelGetProcAddr("vkCmdFillBuffer"); 787 | __vkCmdNextSubpass = (PFN_vkCmdNextSubpass) vkelGetProcAddr("vkCmdNextSubpass"); 788 | __vkCmdPipelineBarrier = (PFN_vkCmdPipelineBarrier) vkelGetProcAddr("vkCmdPipelineBarrier"); 789 | __vkCmdPushConstants = (PFN_vkCmdPushConstants) vkelGetProcAddr("vkCmdPushConstants"); 790 | __vkCmdResetEvent = (PFN_vkCmdResetEvent) vkelGetProcAddr("vkCmdResetEvent"); 791 | __vkCmdResetQueryPool = (PFN_vkCmdResetQueryPool) vkelGetProcAddr("vkCmdResetQueryPool"); 792 | __vkCmdResolveImage = (PFN_vkCmdResolveImage) vkelGetProcAddr("vkCmdResolveImage"); 793 | __vkCmdSetBlendConstants = (PFN_vkCmdSetBlendConstants) vkelGetProcAddr("vkCmdSetBlendConstants"); 794 | __vkCmdSetDepthBias = (PFN_vkCmdSetDepthBias) vkelGetProcAddr("vkCmdSetDepthBias"); 795 | __vkCmdSetDepthBounds = (PFN_vkCmdSetDepthBounds) vkelGetProcAddr("vkCmdSetDepthBounds"); 796 | __vkCmdSetEvent = (PFN_vkCmdSetEvent) vkelGetProcAddr("vkCmdSetEvent"); 797 | __vkCmdSetLineWidth = (PFN_vkCmdSetLineWidth) vkelGetProcAddr("vkCmdSetLineWidth"); 798 | __vkCmdSetScissor = (PFN_vkCmdSetScissor) vkelGetProcAddr("vkCmdSetScissor"); 799 | __vkCmdSetStencilCompareMask = (PFN_vkCmdSetStencilCompareMask) vkelGetProcAddr("vkCmdSetStencilCompareMask"); 800 | __vkCmdSetStencilReference = (PFN_vkCmdSetStencilReference) vkelGetProcAddr("vkCmdSetStencilReference"); 801 | __vkCmdSetStencilWriteMask = (PFN_vkCmdSetStencilWriteMask) vkelGetProcAddr("vkCmdSetStencilWriteMask"); 802 | __vkCmdSetViewport = (PFN_vkCmdSetViewport) vkelGetProcAddr("vkCmdSetViewport"); 803 | __vkCmdUpdateBuffer = (PFN_vkCmdUpdateBuffer) vkelGetProcAddr("vkCmdUpdateBuffer"); 804 | __vkCmdWaitEvents = (PFN_vkCmdWaitEvents) vkelGetProcAddr("vkCmdWaitEvents"); 805 | __vkCmdWriteTimestamp = (PFN_vkCmdWriteTimestamp) vkelGetProcAddr("vkCmdWriteTimestamp"); 806 | __vkCreateBuffer = (PFN_vkCreateBuffer) vkelGetProcAddr("vkCreateBuffer"); 807 | __vkCreateBufferView = (PFN_vkCreateBufferView) vkelGetProcAddr("vkCreateBufferView"); 808 | __vkCreateCommandPool = (PFN_vkCreateCommandPool) vkelGetProcAddr("vkCreateCommandPool"); 809 | __vkCreateComputePipelines = (PFN_vkCreateComputePipelines) vkelGetProcAddr("vkCreateComputePipelines"); 810 | __vkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT) vkelGetProcAddr("vkCreateDebugReportCallbackEXT"); 811 | __vkCreateDescriptorPool = (PFN_vkCreateDescriptorPool) vkelGetProcAddr("vkCreateDescriptorPool"); 812 | __vkCreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout) vkelGetProcAddr("vkCreateDescriptorSetLayout"); 813 | __vkCreateDevice = (PFN_vkCreateDevice) vkelGetProcAddr("vkCreateDevice"); 814 | __vkCreateDisplayModeKHR = (PFN_vkCreateDisplayModeKHR) vkelGetProcAddr("vkCreateDisplayModeKHR"); 815 | __vkCreateDisplayPlaneSurfaceKHR = (PFN_vkCreateDisplayPlaneSurfaceKHR) vkelGetProcAddr("vkCreateDisplayPlaneSurfaceKHR"); 816 | __vkCreateEvent = (PFN_vkCreateEvent) vkelGetProcAddr("vkCreateEvent"); 817 | __vkCreateFence = (PFN_vkCreateFence) vkelGetProcAddr("vkCreateFence"); 818 | __vkCreateFramebuffer = (PFN_vkCreateFramebuffer) vkelGetProcAddr("vkCreateFramebuffer"); 819 | __vkCreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines) vkelGetProcAddr("vkCreateGraphicsPipelines"); 820 | __vkCreateImage = (PFN_vkCreateImage) vkelGetProcAddr("vkCreateImage"); 821 | __vkCreateImageView = (PFN_vkCreateImageView) vkelGetProcAddr("vkCreateImageView"); 822 | __vkCreateInstance = (PFN_vkCreateInstance) vkelGetProcAddr("vkCreateInstance"); 823 | __vkCreatePipelineCache = (PFN_vkCreatePipelineCache) vkelGetProcAddr("vkCreatePipelineCache"); 824 | __vkCreatePipelineLayout = (PFN_vkCreatePipelineLayout) vkelGetProcAddr("vkCreatePipelineLayout"); 825 | __vkCreateQueryPool = (PFN_vkCreateQueryPool) vkelGetProcAddr("vkCreateQueryPool"); 826 | __vkCreateRenderPass = (PFN_vkCreateRenderPass) vkelGetProcAddr("vkCreateRenderPass"); 827 | __vkCreateSampler = (PFN_vkCreateSampler) vkelGetProcAddr("vkCreateSampler"); 828 | __vkCreateSemaphore = (PFN_vkCreateSemaphore) vkelGetProcAddr("vkCreateSemaphore"); 829 | __vkCreateShaderModule = (PFN_vkCreateShaderModule) vkelGetProcAddr("vkCreateShaderModule"); 830 | __vkCreateSharedSwapchainsKHR = (PFN_vkCreateSharedSwapchainsKHR) vkelGetProcAddr("vkCreateSharedSwapchainsKHR"); 831 | __vkCreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) vkelGetProcAddr("vkCreateSwapchainKHR"); 832 | __vkDebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT) vkelGetProcAddr("vkDebugMarkerSetObjectNameEXT"); 833 | __vkDebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT) vkelGetProcAddr("vkDebugMarkerSetObjectTagEXT"); 834 | __vkDebugReportCallbackEXT = (PFN_vkDebugReportCallbackEXT) vkelGetProcAddr("vkDebugReportCallbackEXT"); 835 | __vkDebugReportMessageEXT = (PFN_vkDebugReportMessageEXT) vkelGetProcAddr("vkDebugReportMessageEXT"); 836 | __vkDestroyBuffer = (PFN_vkDestroyBuffer) vkelGetProcAddr("vkDestroyBuffer"); 837 | __vkDestroyBufferView = (PFN_vkDestroyBufferView) vkelGetProcAddr("vkDestroyBufferView"); 838 | __vkDestroyCommandPool = (PFN_vkDestroyCommandPool) vkelGetProcAddr("vkDestroyCommandPool"); 839 | __vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT) vkelGetProcAddr("vkDestroyDebugReportCallbackEXT"); 840 | __vkDestroyDescriptorPool = (PFN_vkDestroyDescriptorPool) vkelGetProcAddr("vkDestroyDescriptorPool"); 841 | __vkDestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout) vkelGetProcAddr("vkDestroyDescriptorSetLayout"); 842 | __vkDestroyDevice = (PFN_vkDestroyDevice) vkelGetProcAddr("vkDestroyDevice"); 843 | __vkDestroyEvent = (PFN_vkDestroyEvent) vkelGetProcAddr("vkDestroyEvent"); 844 | __vkDestroyFence = (PFN_vkDestroyFence) vkelGetProcAddr("vkDestroyFence"); 845 | __vkDestroyFramebuffer = (PFN_vkDestroyFramebuffer) vkelGetProcAddr("vkDestroyFramebuffer"); 846 | __vkDestroyImage = (PFN_vkDestroyImage) vkelGetProcAddr("vkDestroyImage"); 847 | __vkDestroyImageView = (PFN_vkDestroyImageView) vkelGetProcAddr("vkDestroyImageView"); 848 | __vkDestroyInstance = (PFN_vkDestroyInstance) vkelGetProcAddr("vkDestroyInstance"); 849 | __vkDestroyPipeline = (PFN_vkDestroyPipeline) vkelGetProcAddr("vkDestroyPipeline"); 850 | __vkDestroyPipelineCache = (PFN_vkDestroyPipelineCache) vkelGetProcAddr("vkDestroyPipelineCache"); 851 | __vkDestroyPipelineLayout = (PFN_vkDestroyPipelineLayout) vkelGetProcAddr("vkDestroyPipelineLayout"); 852 | __vkDestroyQueryPool = (PFN_vkDestroyQueryPool) vkelGetProcAddr("vkDestroyQueryPool"); 853 | __vkDestroyRenderPass = (PFN_vkDestroyRenderPass) vkelGetProcAddr("vkDestroyRenderPass"); 854 | __vkDestroySampler = (PFN_vkDestroySampler) vkelGetProcAddr("vkDestroySampler"); 855 | __vkDestroySemaphore = (PFN_vkDestroySemaphore) vkelGetProcAddr("vkDestroySemaphore"); 856 | __vkDestroyShaderModule = (PFN_vkDestroyShaderModule) vkelGetProcAddr("vkDestroyShaderModule"); 857 | __vkDestroySurfaceKHR = (PFN_vkDestroySurfaceKHR) vkelGetProcAddr("vkDestroySurfaceKHR"); 858 | __vkDestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) vkelGetProcAddr("vkDestroySwapchainKHR"); 859 | __vkDeviceWaitIdle = (PFN_vkDeviceWaitIdle) vkelGetProcAddr("vkDeviceWaitIdle"); 860 | __vkEndCommandBuffer = (PFN_vkEndCommandBuffer) vkelGetProcAddr("vkEndCommandBuffer"); 861 | __vkEnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties) vkelGetProcAddr("vkEnumerateDeviceExtensionProperties"); 862 | __vkEnumerateDeviceLayerProperties = (PFN_vkEnumerateDeviceLayerProperties) vkelGetProcAddr("vkEnumerateDeviceLayerProperties"); 863 | __vkEnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties) vkelGetProcAddr("vkEnumerateInstanceExtensionProperties"); 864 | __vkEnumerateInstanceLayerProperties = (PFN_vkEnumerateInstanceLayerProperties) vkelGetProcAddr("vkEnumerateInstanceLayerProperties"); 865 | __vkEnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices) vkelGetProcAddr("vkEnumeratePhysicalDevices"); 866 | __vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges) vkelGetProcAddr("vkFlushMappedMemoryRanges"); 867 | __vkFreeCommandBuffers = (PFN_vkFreeCommandBuffers) vkelGetProcAddr("vkFreeCommandBuffers"); 868 | __vkFreeDescriptorSets = (PFN_vkFreeDescriptorSets) vkelGetProcAddr("vkFreeDescriptorSets"); 869 | __vkFreeFunction = (PFN_vkFreeFunction) vkelGetProcAddr("vkFreeFunction"); 870 | __vkFreeMemory = (PFN_vkFreeMemory) vkelGetProcAddr("vkFreeMemory"); 871 | __vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements) vkelGetProcAddr("vkGetBufferMemoryRequirements"); 872 | __vkGetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment) vkelGetProcAddr("vkGetDeviceMemoryCommitment"); 873 | __vkGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr) vkelGetProcAddr("vkGetDeviceProcAddr"); 874 | __vkGetDeviceQueue = (PFN_vkGetDeviceQueue) vkelGetProcAddr("vkGetDeviceQueue"); 875 | __vkGetDisplayModePropertiesKHR = (PFN_vkGetDisplayModePropertiesKHR) vkelGetProcAddr("vkGetDisplayModePropertiesKHR"); 876 | __vkGetDisplayPlaneCapabilitiesKHR = (PFN_vkGetDisplayPlaneCapabilitiesKHR) vkelGetProcAddr("vkGetDisplayPlaneCapabilitiesKHR"); 877 | __vkGetDisplayPlaneSupportedDisplaysKHR = (PFN_vkGetDisplayPlaneSupportedDisplaysKHR) vkelGetProcAddr("vkGetDisplayPlaneSupportedDisplaysKHR"); 878 | __vkGetEventStatus = (PFN_vkGetEventStatus) vkelGetProcAddr("vkGetEventStatus"); 879 | __vkGetFenceStatus = (PFN_vkGetFenceStatus) vkelGetProcAddr("vkGetFenceStatus"); 880 | __vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements) vkelGetProcAddr("vkGetImageMemoryRequirements"); 881 | __vkGetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements) vkelGetProcAddr("vkGetImageSparseMemoryRequirements"); 882 | __vkGetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout) vkelGetProcAddr("vkGetImageSubresourceLayout"); 883 | __vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr) vkelGetProcAddr("vkGetInstanceProcAddr"); 884 | __vkGetPhysicalDeviceDisplayPlanePropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR) vkelGetProcAddr("vkGetPhysicalDeviceDisplayPlanePropertiesKHR"); 885 | __vkGetPhysicalDeviceDisplayPropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPropertiesKHR) vkelGetProcAddr("vkGetPhysicalDeviceDisplayPropertiesKHR"); 886 | __vkGetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures) vkelGetProcAddr("vkGetPhysicalDeviceFeatures"); 887 | __vkGetPhysicalDeviceFormatProperties = (PFN_vkGetPhysicalDeviceFormatProperties) vkelGetProcAddr("vkGetPhysicalDeviceFormatProperties"); 888 | __vkGetPhysicalDeviceImageFormatProperties = (PFN_vkGetPhysicalDeviceImageFormatProperties) vkelGetProcAddr("vkGetPhysicalDeviceImageFormatProperties"); 889 | __vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties) vkelGetProcAddr("vkGetPhysicalDeviceMemoryProperties"); 890 | __vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties) vkelGetProcAddr("vkGetPhysicalDeviceProperties"); 891 | __vkGetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties) vkelGetProcAddr("vkGetPhysicalDeviceQueueFamilyProperties"); 892 | __vkGetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties) vkelGetProcAddr("vkGetPhysicalDeviceSparseImageFormatProperties"); 893 | __vkGetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) vkelGetProcAddr("vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); 894 | __vkGetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) vkelGetProcAddr("vkGetPhysicalDeviceSurfaceFormatsKHR"); 895 | __vkGetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) vkelGetProcAddr("vkGetPhysicalDeviceSurfacePresentModesKHR"); 896 | __vkGetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) vkelGetProcAddr("vkGetPhysicalDeviceSurfaceSupportKHR"); 897 | __vkGetPipelineCacheData = (PFN_vkGetPipelineCacheData) vkelGetProcAddr("vkGetPipelineCacheData"); 898 | __vkGetQueryPoolResults = (PFN_vkGetQueryPoolResults) vkelGetProcAddr("vkGetQueryPoolResults"); 899 | __vkGetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity) vkelGetProcAddr("vkGetRenderAreaGranularity"); 900 | __vkGetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) vkelGetProcAddr("vkGetSwapchainImagesKHR"); 901 | __vkInternalAllocationNotification = (PFN_vkInternalAllocationNotification) vkelGetProcAddr("vkInternalAllocationNotification"); 902 | __vkInternalFreeNotification = (PFN_vkInternalFreeNotification) vkelGetProcAddr("vkInternalFreeNotification"); 903 | __vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges) vkelGetProcAddr("vkInvalidateMappedMemoryRanges"); 904 | __vkMapMemory = (PFN_vkMapMemory) vkelGetProcAddr("vkMapMemory"); 905 | __vkMergePipelineCaches = (PFN_vkMergePipelineCaches) vkelGetProcAddr("vkMergePipelineCaches"); 906 | __vkQueueBindSparse = (PFN_vkQueueBindSparse) vkelGetProcAddr("vkQueueBindSparse"); 907 | __vkQueuePresentKHR = (PFN_vkQueuePresentKHR) vkelGetProcAddr("vkQueuePresentKHR"); 908 | __vkQueueSubmit = (PFN_vkQueueSubmit) vkelGetProcAddr("vkQueueSubmit"); 909 | __vkQueueWaitIdle = (PFN_vkQueueWaitIdle) vkelGetProcAddr("vkQueueWaitIdle"); 910 | __vkReallocationFunction = (PFN_vkReallocationFunction) vkelGetProcAddr("vkReallocationFunction"); 911 | __vkResetCommandBuffer = (PFN_vkResetCommandBuffer) vkelGetProcAddr("vkResetCommandBuffer"); 912 | __vkResetCommandPool = (PFN_vkResetCommandPool) vkelGetProcAddr("vkResetCommandPool"); 913 | __vkResetDescriptorPool = (PFN_vkResetDescriptorPool) vkelGetProcAddr("vkResetDescriptorPool"); 914 | __vkResetEvent = (PFN_vkResetEvent) vkelGetProcAddr("vkResetEvent"); 915 | __vkResetFences = (PFN_vkResetFences) vkelGetProcAddr("vkResetFences"); 916 | __vkSetEvent = (PFN_vkSetEvent) vkelGetProcAddr("vkSetEvent"); 917 | __vkUnmapMemory = (PFN_vkUnmapMemory) vkelGetProcAddr("vkUnmapMemory"); 918 | __vkUpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) vkelGetProcAddr("vkUpdateDescriptorSets"); 919 | __vkVoidFunction = (PFN_vkVoidFunction) vkelGetProcAddr("vkVoidFunction"); 920 | __vkWaitForFences = (PFN_vkWaitForFences) vkelGetProcAddr("vkWaitForFences"); 921 | 922 | #ifdef VK_USE_PLATFORM_ANDROID_KHR 923 | __vkCreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR) vkelGetProcAddr("vkCreateAndroidSurfaceKHR"); 924 | #endif /* VK_USE_PLATFORM_ANDROID_KHR */ 925 | 926 | #ifdef VK_USE_PLATFORM_MIR_KHR 927 | __vkCreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR) vkelGetProcAddr("vkCreateMirSurfaceKHR"); 928 | __vkGetPhysicalDeviceMirPresentationSupportKHR = (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR) vkelGetProcAddr("vkGetPhysicalDeviceMirPresentationSupportKHR"); 929 | #endif /* VK_USE_PLATFORM_MIR_KHR */ 930 | 931 | #ifdef VK_USE_PLATFORM_WAYLAND_KHR 932 | __vkCreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR) vkelGetProcAddr("vkCreateWaylandSurfaceKHR"); 933 | __vkGetPhysicalDeviceWaylandPresentationSupportKHR = (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR) vkelGetProcAddr("vkGetPhysicalDeviceWaylandPresentationSupportKHR"); 934 | #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ 935 | 936 | #ifdef VK_USE_PLATFORM_WIN32_KHR 937 | __vkCreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR) vkelGetProcAddr("vkCreateWin32SurfaceKHR"); 938 | __vkGetPhysicalDeviceWin32PresentationSupportKHR = (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR) vkelGetProcAddr("vkGetPhysicalDeviceWin32PresentationSupportKHR"); 939 | #endif /* VK_USE_PLATFORM_WIN32_KHR */ 940 | 941 | #ifdef VK_USE_PLATFORM_XCB_KHR 942 | __vkCreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR) vkelGetProcAddr("vkCreateXcbSurfaceKHR"); 943 | __vkGetPhysicalDeviceXcbPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR) vkelGetProcAddr("vkGetPhysicalDeviceXcbPresentationSupportKHR"); 944 | #endif /* VK_USE_PLATFORM_XCB_KHR */ 945 | 946 | #ifdef VK_USE_PLATFORM_XLIB_KHR 947 | __vkCreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR) vkelGetProcAddr("vkCreateXlibSurfaceKHR"); 948 | __vkGetPhysicalDeviceXlibPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR) vkelGetProcAddr("vkGetPhysicalDeviceXlibPresentationSupportKHR"); 949 | #endif /* VK_USE_PLATFORM_XLIB_KHR */ 950 | 951 | 952 | // Instance and device extension names 953 | VKEL_AMD_gcn_shader = vkelIsInstanceExtensionSupported(NULL, "VK_AMD_gcn_shader"); 954 | VKEL_AMD_rasterization_order = vkelIsInstanceExtensionSupported(NULL, "VK_AMD_rasterization_order"); 955 | VKEL_AMD_shader_explicit_vertex_parameter = vkelIsInstanceExtensionSupported(NULL, "VK_AMD_shader_explicit_vertex_parameter"); 956 | VKEL_AMD_shader_trinary_minmax = vkelIsInstanceExtensionSupported(NULL, "VK_AMD_shader_trinary_minmax"); 957 | VKEL_EXT_debug_marker = vkelIsInstanceExtensionSupported(NULL, "VK_EXT_debug_marker"); 958 | VKEL_EXT_debug_report = vkelIsInstanceExtensionSupported(NULL, "VK_EXT_debug_report"); 959 | VKEL_IMG_filter_cubic = vkelIsInstanceExtensionSupported(NULL, "VK_IMG_filter_cubic"); 960 | VKEL_IMG_format_pvrtc = vkelIsInstanceExtensionSupported(NULL, "VK_IMG_format_pvrtc"); 961 | VKEL_KHR_android_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_android_surface"); 962 | VKEL_KHR_display = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_display"); 963 | VKEL_KHR_display_swapchain = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_display_swapchain"); 964 | VKEL_KHR_mir_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_mir_surface"); 965 | VKEL_KHR_sampler_mirror_clamp_to_edge = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_sampler_mirror_clamp_to_edge"); 966 | VKEL_KHR_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_surface"); 967 | VKEL_KHR_swapchain = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_swapchain"); 968 | VKEL_KHR_wayland_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_wayland_surface"); 969 | VKEL_KHR_win32_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_win32_surface"); 970 | VKEL_KHR_xcb_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_xcb_surface"); 971 | VKEL_KHR_xlib_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_xlib_surface"); 972 | VKEL_NV_dedicated_allocation = vkelIsInstanceExtensionSupported(NULL, "VK_NV_dedicated_allocation"); 973 | VKEL_NV_glsl_shader = vkelIsInstanceExtensionSupported(NULL, "VK_NV_glsl_shader"); 974 | 975 | // Instance and device layer names 976 | VKEL_LAYER_GOOGLE_unique_objects = vkelIsInstanceLayerSupported("VK_LAYER_GOOGLE_unique_objects"); 977 | VKEL_LAYER_LUNARG_api_dump = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_api_dump"); 978 | VKEL_LAYER_LUNARG_device_limits = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_device_limits"); 979 | VKEL_LAYER_LUNARG_draw_state = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_draw_state"); 980 | VKEL_LAYER_LUNARG_image = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_image"); 981 | VKEL_LAYER_LUNARG_mem_tracker = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_mem_tracker"); 982 | VKEL_LAYER_LUNARG_object_tracker = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_object_tracker"); 983 | VKEL_LAYER_LUNARG_param_checker = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_param_checker"); 984 | VKEL_LAYER_LUNARG_screenshot = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_screenshot"); 985 | VKEL_LAYER_LUNARG_swapchain = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_swapchain"); 986 | VKEL_LAYER_LUNARG_threading = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_threading"); 987 | VKEL_LAYER_LUNARG_vktrace = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_vktrace"); 988 | 989 | 990 | return VK_TRUE; 991 | } 992 | 993 | VkBool32 vkelInstanceInit(VkInstance instance) 994 | { 995 | if (!vkelVkLibHandle && !vkelInit()) 996 | return VK_FALSE; 997 | 998 | 999 | __vkAcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) vkelGetInstanceProcAddr(instance, "vkAcquireNextImageKHR"); 1000 | __vkAllocateCommandBuffers = (PFN_vkAllocateCommandBuffers) vkelGetInstanceProcAddr(instance, "vkAllocateCommandBuffers"); 1001 | __vkAllocateDescriptorSets = (PFN_vkAllocateDescriptorSets) vkelGetInstanceProcAddr(instance, "vkAllocateDescriptorSets"); 1002 | __vkAllocateMemory = (PFN_vkAllocateMemory) vkelGetInstanceProcAddr(instance, "vkAllocateMemory"); 1003 | __vkAllocationFunction = (PFN_vkAllocationFunction) vkelGetInstanceProcAddr(instance, "vkAllocationFunction"); 1004 | __vkBeginCommandBuffer = (PFN_vkBeginCommandBuffer) vkelGetInstanceProcAddr(instance, "vkBeginCommandBuffer"); 1005 | __vkBindBufferMemory = (PFN_vkBindBufferMemory) vkelGetInstanceProcAddr(instance, "vkBindBufferMemory"); 1006 | __vkBindImageMemory = (PFN_vkBindImageMemory) vkelGetInstanceProcAddr(instance, "vkBindImageMemory"); 1007 | __vkCmdBeginQuery = (PFN_vkCmdBeginQuery) vkelGetInstanceProcAddr(instance, "vkCmdBeginQuery"); 1008 | __vkCmdBeginRenderPass = (PFN_vkCmdBeginRenderPass) vkelGetInstanceProcAddr(instance, "vkCmdBeginRenderPass"); 1009 | __vkCmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) vkelGetInstanceProcAddr(instance, "vkCmdBindDescriptorSets"); 1010 | __vkCmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer) vkelGetInstanceProcAddr(instance, "vkCmdBindIndexBuffer"); 1011 | __vkCmdBindPipeline = (PFN_vkCmdBindPipeline) vkelGetInstanceProcAddr(instance, "vkCmdBindPipeline"); 1012 | __vkCmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers) vkelGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers"); 1013 | __vkCmdBlitImage = (PFN_vkCmdBlitImage) vkelGetInstanceProcAddr(instance, "vkCmdBlitImage"); 1014 | __vkCmdClearAttachments = (PFN_vkCmdClearAttachments) vkelGetInstanceProcAddr(instance, "vkCmdClearAttachments"); 1015 | __vkCmdClearColorImage = (PFN_vkCmdClearColorImage) vkelGetInstanceProcAddr(instance, "vkCmdClearColorImage"); 1016 | __vkCmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage) vkelGetInstanceProcAddr(instance, "vkCmdClearDepthStencilImage"); 1017 | __vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer) vkelGetInstanceProcAddr(instance, "vkCmdCopyBuffer"); 1018 | __vkCmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage) vkelGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage"); 1019 | __vkCmdCopyImage = (PFN_vkCmdCopyImage) vkelGetInstanceProcAddr(instance, "vkCmdCopyImage"); 1020 | __vkCmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer) vkelGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer"); 1021 | __vkCmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults) vkelGetInstanceProcAddr(instance, "vkCmdCopyQueryPoolResults"); 1022 | __vkCmdDebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT) vkelGetInstanceProcAddr(instance, "vkCmdDebugMarkerBeginEXT"); 1023 | __vkCmdDebugMarkerEndEXT = (PFN_vkCmdDebugMarkerEndEXT) vkelGetInstanceProcAddr(instance, "vkCmdDebugMarkerEndEXT"); 1024 | __vkCmdDebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT) vkelGetInstanceProcAddr(instance, "vkCmdDebugMarkerInsertEXT"); 1025 | __vkCmdDispatch = (PFN_vkCmdDispatch) vkelGetInstanceProcAddr(instance, "vkCmdDispatch"); 1026 | __vkCmdDispatchIndirect = (PFN_vkCmdDispatchIndirect) vkelGetInstanceProcAddr(instance, "vkCmdDispatchIndirect"); 1027 | __vkCmdDraw = (PFN_vkCmdDraw) vkelGetInstanceProcAddr(instance, "vkCmdDraw"); 1028 | __vkCmdDrawIndexed = (PFN_vkCmdDrawIndexed) vkelGetInstanceProcAddr(instance, "vkCmdDrawIndexed"); 1029 | __vkCmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect) vkelGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirect"); 1030 | __vkCmdDrawIndirect = (PFN_vkCmdDrawIndirect) vkelGetInstanceProcAddr(instance, "vkCmdDrawIndirect"); 1031 | __vkCmdEndQuery = (PFN_vkCmdEndQuery) vkelGetInstanceProcAddr(instance, "vkCmdEndQuery"); 1032 | __vkCmdEndRenderPass = (PFN_vkCmdEndRenderPass) vkelGetInstanceProcAddr(instance, "vkCmdEndRenderPass"); 1033 | __vkCmdExecuteCommands = (PFN_vkCmdExecuteCommands) vkelGetInstanceProcAddr(instance, "vkCmdExecuteCommands"); 1034 | __vkCmdFillBuffer = (PFN_vkCmdFillBuffer) vkelGetInstanceProcAddr(instance, "vkCmdFillBuffer"); 1035 | __vkCmdNextSubpass = (PFN_vkCmdNextSubpass) vkelGetInstanceProcAddr(instance, "vkCmdNextSubpass"); 1036 | __vkCmdPipelineBarrier = (PFN_vkCmdPipelineBarrier) vkelGetInstanceProcAddr(instance, "vkCmdPipelineBarrier"); 1037 | __vkCmdPushConstants = (PFN_vkCmdPushConstants) vkelGetInstanceProcAddr(instance, "vkCmdPushConstants"); 1038 | __vkCmdResetEvent = (PFN_vkCmdResetEvent) vkelGetInstanceProcAddr(instance, "vkCmdResetEvent"); 1039 | __vkCmdResetQueryPool = (PFN_vkCmdResetQueryPool) vkelGetInstanceProcAddr(instance, "vkCmdResetQueryPool"); 1040 | __vkCmdResolveImage = (PFN_vkCmdResolveImage) vkelGetInstanceProcAddr(instance, "vkCmdResolveImage"); 1041 | __vkCmdSetBlendConstants = (PFN_vkCmdSetBlendConstants) vkelGetInstanceProcAddr(instance, "vkCmdSetBlendConstants"); 1042 | __vkCmdSetDepthBias = (PFN_vkCmdSetDepthBias) vkelGetInstanceProcAddr(instance, "vkCmdSetDepthBias"); 1043 | __vkCmdSetDepthBounds = (PFN_vkCmdSetDepthBounds) vkelGetInstanceProcAddr(instance, "vkCmdSetDepthBounds"); 1044 | __vkCmdSetEvent = (PFN_vkCmdSetEvent) vkelGetInstanceProcAddr(instance, "vkCmdSetEvent"); 1045 | __vkCmdSetLineWidth = (PFN_vkCmdSetLineWidth) vkelGetInstanceProcAddr(instance, "vkCmdSetLineWidth"); 1046 | __vkCmdSetScissor = (PFN_vkCmdSetScissor) vkelGetInstanceProcAddr(instance, "vkCmdSetScissor"); 1047 | __vkCmdSetStencilCompareMask = (PFN_vkCmdSetStencilCompareMask) vkelGetInstanceProcAddr(instance, "vkCmdSetStencilCompareMask"); 1048 | __vkCmdSetStencilReference = (PFN_vkCmdSetStencilReference) vkelGetInstanceProcAddr(instance, "vkCmdSetStencilReference"); 1049 | __vkCmdSetStencilWriteMask = (PFN_vkCmdSetStencilWriteMask) vkelGetInstanceProcAddr(instance, "vkCmdSetStencilWriteMask"); 1050 | __vkCmdSetViewport = (PFN_vkCmdSetViewport) vkelGetInstanceProcAddr(instance, "vkCmdSetViewport"); 1051 | __vkCmdUpdateBuffer = (PFN_vkCmdUpdateBuffer) vkelGetInstanceProcAddr(instance, "vkCmdUpdateBuffer"); 1052 | __vkCmdWaitEvents = (PFN_vkCmdWaitEvents) vkelGetInstanceProcAddr(instance, "vkCmdWaitEvents"); 1053 | __vkCmdWriteTimestamp = (PFN_vkCmdWriteTimestamp) vkelGetInstanceProcAddr(instance, "vkCmdWriteTimestamp"); 1054 | __vkCreateBuffer = (PFN_vkCreateBuffer) vkelGetInstanceProcAddr(instance, "vkCreateBuffer"); 1055 | __vkCreateBufferView = (PFN_vkCreateBufferView) vkelGetInstanceProcAddr(instance, "vkCreateBufferView"); 1056 | __vkCreateCommandPool = (PFN_vkCreateCommandPool) vkelGetInstanceProcAddr(instance, "vkCreateCommandPool"); 1057 | __vkCreateComputePipelines = (PFN_vkCreateComputePipelines) vkelGetInstanceProcAddr(instance, "vkCreateComputePipelines"); 1058 | __vkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT) vkelGetInstanceProcAddr(instance, "vkCreateDebugReportCallbackEXT"); 1059 | __vkCreateDescriptorPool = (PFN_vkCreateDescriptorPool) vkelGetInstanceProcAddr(instance, "vkCreateDescriptorPool"); 1060 | __vkCreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout) vkelGetInstanceProcAddr(instance, "vkCreateDescriptorSetLayout"); 1061 | __vkCreateDevice = (PFN_vkCreateDevice) vkelGetInstanceProcAddr(instance, "vkCreateDevice"); 1062 | __vkCreateDisplayModeKHR = (PFN_vkCreateDisplayModeKHR) vkelGetInstanceProcAddr(instance, "vkCreateDisplayModeKHR"); 1063 | __vkCreateDisplayPlaneSurfaceKHR = (PFN_vkCreateDisplayPlaneSurfaceKHR) vkelGetInstanceProcAddr(instance, "vkCreateDisplayPlaneSurfaceKHR"); 1064 | __vkCreateEvent = (PFN_vkCreateEvent) vkelGetInstanceProcAddr(instance, "vkCreateEvent"); 1065 | __vkCreateFence = (PFN_vkCreateFence) vkelGetInstanceProcAddr(instance, "vkCreateFence"); 1066 | __vkCreateFramebuffer = (PFN_vkCreateFramebuffer) vkelGetInstanceProcAddr(instance, "vkCreateFramebuffer"); 1067 | __vkCreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines) vkelGetInstanceProcAddr(instance, "vkCreateGraphicsPipelines"); 1068 | __vkCreateImage = (PFN_vkCreateImage) vkelGetInstanceProcAddr(instance, "vkCreateImage"); 1069 | __vkCreateImageView = (PFN_vkCreateImageView) vkelGetInstanceProcAddr(instance, "vkCreateImageView"); 1070 | __vkCreateInstance = (PFN_vkCreateInstance) vkelGetInstanceProcAddr(instance, "vkCreateInstance"); 1071 | __vkCreatePipelineCache = (PFN_vkCreatePipelineCache) vkelGetInstanceProcAddr(instance, "vkCreatePipelineCache"); 1072 | __vkCreatePipelineLayout = (PFN_vkCreatePipelineLayout) vkelGetInstanceProcAddr(instance, "vkCreatePipelineLayout"); 1073 | __vkCreateQueryPool = (PFN_vkCreateQueryPool) vkelGetInstanceProcAddr(instance, "vkCreateQueryPool"); 1074 | __vkCreateRenderPass = (PFN_vkCreateRenderPass) vkelGetInstanceProcAddr(instance, "vkCreateRenderPass"); 1075 | __vkCreateSampler = (PFN_vkCreateSampler) vkelGetInstanceProcAddr(instance, "vkCreateSampler"); 1076 | __vkCreateSemaphore = (PFN_vkCreateSemaphore) vkelGetInstanceProcAddr(instance, "vkCreateSemaphore"); 1077 | __vkCreateShaderModule = (PFN_vkCreateShaderModule) vkelGetInstanceProcAddr(instance, "vkCreateShaderModule"); 1078 | __vkCreateSharedSwapchainsKHR = (PFN_vkCreateSharedSwapchainsKHR) vkelGetInstanceProcAddr(instance, "vkCreateSharedSwapchainsKHR"); 1079 | __vkCreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) vkelGetInstanceProcAddr(instance, "vkCreateSwapchainKHR"); 1080 | __vkDebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT) vkelGetInstanceProcAddr(instance, "vkDebugMarkerSetObjectNameEXT"); 1081 | __vkDebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT) vkelGetInstanceProcAddr(instance, "vkDebugMarkerSetObjectTagEXT"); 1082 | __vkDebugReportCallbackEXT = (PFN_vkDebugReportCallbackEXT) vkelGetInstanceProcAddr(instance, "vkDebugReportCallbackEXT"); 1083 | __vkDebugReportMessageEXT = (PFN_vkDebugReportMessageEXT) vkelGetInstanceProcAddr(instance, "vkDebugReportMessageEXT"); 1084 | __vkDestroyBuffer = (PFN_vkDestroyBuffer) vkelGetInstanceProcAddr(instance, "vkDestroyBuffer"); 1085 | __vkDestroyBufferView = (PFN_vkDestroyBufferView) vkelGetInstanceProcAddr(instance, "vkDestroyBufferView"); 1086 | __vkDestroyCommandPool = (PFN_vkDestroyCommandPool) vkelGetInstanceProcAddr(instance, "vkDestroyCommandPool"); 1087 | __vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT) vkelGetInstanceProcAddr(instance, "vkDestroyDebugReportCallbackEXT"); 1088 | __vkDestroyDescriptorPool = (PFN_vkDestroyDescriptorPool) vkelGetInstanceProcAddr(instance, "vkDestroyDescriptorPool"); 1089 | __vkDestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout) vkelGetInstanceProcAddr(instance, "vkDestroyDescriptorSetLayout"); 1090 | __vkDestroyDevice = (PFN_vkDestroyDevice) vkelGetInstanceProcAddr(instance, "vkDestroyDevice"); 1091 | __vkDestroyEvent = (PFN_vkDestroyEvent) vkelGetInstanceProcAddr(instance, "vkDestroyEvent"); 1092 | __vkDestroyFence = (PFN_vkDestroyFence) vkelGetInstanceProcAddr(instance, "vkDestroyFence"); 1093 | __vkDestroyFramebuffer = (PFN_vkDestroyFramebuffer) vkelGetInstanceProcAddr(instance, "vkDestroyFramebuffer"); 1094 | __vkDestroyImage = (PFN_vkDestroyImage) vkelGetInstanceProcAddr(instance, "vkDestroyImage"); 1095 | __vkDestroyImageView = (PFN_vkDestroyImageView) vkelGetInstanceProcAddr(instance, "vkDestroyImageView"); 1096 | __vkDestroyInstance = (PFN_vkDestroyInstance) vkelGetInstanceProcAddr(instance, "vkDestroyInstance"); 1097 | __vkDestroyPipeline = (PFN_vkDestroyPipeline) vkelGetInstanceProcAddr(instance, "vkDestroyPipeline"); 1098 | __vkDestroyPipelineCache = (PFN_vkDestroyPipelineCache) vkelGetInstanceProcAddr(instance, "vkDestroyPipelineCache"); 1099 | __vkDestroyPipelineLayout = (PFN_vkDestroyPipelineLayout) vkelGetInstanceProcAddr(instance, "vkDestroyPipelineLayout"); 1100 | __vkDestroyQueryPool = (PFN_vkDestroyQueryPool) vkelGetInstanceProcAddr(instance, "vkDestroyQueryPool"); 1101 | __vkDestroyRenderPass = (PFN_vkDestroyRenderPass) vkelGetInstanceProcAddr(instance, "vkDestroyRenderPass"); 1102 | __vkDestroySampler = (PFN_vkDestroySampler) vkelGetInstanceProcAddr(instance, "vkDestroySampler"); 1103 | __vkDestroySemaphore = (PFN_vkDestroySemaphore) vkelGetInstanceProcAddr(instance, "vkDestroySemaphore"); 1104 | __vkDestroyShaderModule = (PFN_vkDestroyShaderModule) vkelGetInstanceProcAddr(instance, "vkDestroyShaderModule"); 1105 | __vkDestroySurfaceKHR = (PFN_vkDestroySurfaceKHR) vkelGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"); 1106 | __vkDestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) vkelGetInstanceProcAddr(instance, "vkDestroySwapchainKHR"); 1107 | __vkDeviceWaitIdle = (PFN_vkDeviceWaitIdle) vkelGetInstanceProcAddr(instance, "vkDeviceWaitIdle"); 1108 | __vkEndCommandBuffer = (PFN_vkEndCommandBuffer) vkelGetInstanceProcAddr(instance, "vkEndCommandBuffer"); 1109 | __vkEnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties) vkelGetInstanceProcAddr(instance, "vkEnumerateDeviceExtensionProperties"); 1110 | __vkEnumerateDeviceLayerProperties = (PFN_vkEnumerateDeviceLayerProperties) vkelGetInstanceProcAddr(instance, "vkEnumerateDeviceLayerProperties"); 1111 | __vkEnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties) vkelGetInstanceProcAddr(instance, "vkEnumerateInstanceExtensionProperties"); 1112 | __vkEnumerateInstanceLayerProperties = (PFN_vkEnumerateInstanceLayerProperties) vkelGetInstanceProcAddr(instance, "vkEnumerateInstanceLayerProperties"); 1113 | __vkEnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices) vkelGetInstanceProcAddr(instance, "vkEnumeratePhysicalDevices"); 1114 | __vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges) vkelGetInstanceProcAddr(instance, "vkFlushMappedMemoryRanges"); 1115 | __vkFreeCommandBuffers = (PFN_vkFreeCommandBuffers) vkelGetInstanceProcAddr(instance, "vkFreeCommandBuffers"); 1116 | __vkFreeDescriptorSets = (PFN_vkFreeDescriptorSets) vkelGetInstanceProcAddr(instance, "vkFreeDescriptorSets"); 1117 | __vkFreeFunction = (PFN_vkFreeFunction) vkelGetInstanceProcAddr(instance, "vkFreeFunction"); 1118 | __vkFreeMemory = (PFN_vkFreeMemory) vkelGetInstanceProcAddr(instance, "vkFreeMemory"); 1119 | __vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements) vkelGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements"); 1120 | __vkGetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment) vkelGetInstanceProcAddr(instance, "vkGetDeviceMemoryCommitment"); 1121 | __vkGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr) vkelGetInstanceProcAddr(instance, "vkGetDeviceProcAddr"); 1122 | __vkGetDeviceQueue = (PFN_vkGetDeviceQueue) vkelGetInstanceProcAddr(instance, "vkGetDeviceQueue"); 1123 | __vkGetDisplayModePropertiesKHR = (PFN_vkGetDisplayModePropertiesKHR) vkelGetInstanceProcAddr(instance, "vkGetDisplayModePropertiesKHR"); 1124 | __vkGetDisplayPlaneCapabilitiesKHR = (PFN_vkGetDisplayPlaneCapabilitiesKHR) vkelGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilitiesKHR"); 1125 | __vkGetDisplayPlaneSupportedDisplaysKHR = (PFN_vkGetDisplayPlaneSupportedDisplaysKHR) vkelGetInstanceProcAddr(instance, "vkGetDisplayPlaneSupportedDisplaysKHR"); 1126 | __vkGetEventStatus = (PFN_vkGetEventStatus) vkelGetInstanceProcAddr(instance, "vkGetEventStatus"); 1127 | __vkGetFenceStatus = (PFN_vkGetFenceStatus) vkelGetInstanceProcAddr(instance, "vkGetFenceStatus"); 1128 | __vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements) vkelGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements"); 1129 | __vkGetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements) vkelGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements"); 1130 | __vkGetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout) vkelGetInstanceProcAddr(instance, "vkGetImageSubresourceLayout"); 1131 | __vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr) vkelGetInstanceProcAddr(instance, "vkGetInstanceProcAddr"); 1132 | __vkGetPhysicalDeviceDisplayPlanePropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"); 1133 | __vkGetPhysicalDeviceDisplayPropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPropertiesKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR"); 1134 | __vkGetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures"); 1135 | __vkGetPhysicalDeviceFormatProperties = (PFN_vkGetPhysicalDeviceFormatProperties) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties"); 1136 | __vkGetPhysicalDeviceImageFormatProperties = (PFN_vkGetPhysicalDeviceImageFormatProperties) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties"); 1137 | __vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties"); 1138 | __vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties"); 1139 | __vkGetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties"); 1140 | __vkGetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"); 1141 | __vkGetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); 1142 | __vkGetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"); 1143 | __vkGetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"); 1144 | __vkGetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"); 1145 | __vkGetPipelineCacheData = (PFN_vkGetPipelineCacheData) vkelGetInstanceProcAddr(instance, "vkGetPipelineCacheData"); 1146 | __vkGetQueryPoolResults = (PFN_vkGetQueryPoolResults) vkelGetInstanceProcAddr(instance, "vkGetQueryPoolResults"); 1147 | __vkGetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity) vkelGetInstanceProcAddr(instance, "vkGetRenderAreaGranularity"); 1148 | __vkGetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) vkelGetInstanceProcAddr(instance, "vkGetSwapchainImagesKHR"); 1149 | __vkInternalAllocationNotification = (PFN_vkInternalAllocationNotification) vkelGetInstanceProcAddr(instance, "vkInternalAllocationNotification"); 1150 | __vkInternalFreeNotification = (PFN_vkInternalFreeNotification) vkelGetInstanceProcAddr(instance, "vkInternalFreeNotification"); 1151 | __vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges) vkelGetInstanceProcAddr(instance, "vkInvalidateMappedMemoryRanges"); 1152 | __vkMapMemory = (PFN_vkMapMemory) vkelGetInstanceProcAddr(instance, "vkMapMemory"); 1153 | __vkMergePipelineCaches = (PFN_vkMergePipelineCaches) vkelGetInstanceProcAddr(instance, "vkMergePipelineCaches"); 1154 | __vkQueueBindSparse = (PFN_vkQueueBindSparse) vkelGetInstanceProcAddr(instance, "vkQueueBindSparse"); 1155 | __vkQueuePresentKHR = (PFN_vkQueuePresentKHR) vkelGetInstanceProcAddr(instance, "vkQueuePresentKHR"); 1156 | __vkQueueSubmit = (PFN_vkQueueSubmit) vkelGetInstanceProcAddr(instance, "vkQueueSubmit"); 1157 | __vkQueueWaitIdle = (PFN_vkQueueWaitIdle) vkelGetInstanceProcAddr(instance, "vkQueueWaitIdle"); 1158 | __vkReallocationFunction = (PFN_vkReallocationFunction) vkelGetInstanceProcAddr(instance, "vkReallocationFunction"); 1159 | __vkResetCommandBuffer = (PFN_vkResetCommandBuffer) vkelGetInstanceProcAddr(instance, "vkResetCommandBuffer"); 1160 | __vkResetCommandPool = (PFN_vkResetCommandPool) vkelGetInstanceProcAddr(instance, "vkResetCommandPool"); 1161 | __vkResetDescriptorPool = (PFN_vkResetDescriptorPool) vkelGetInstanceProcAddr(instance, "vkResetDescriptorPool"); 1162 | __vkResetEvent = (PFN_vkResetEvent) vkelGetInstanceProcAddr(instance, "vkResetEvent"); 1163 | __vkResetFences = (PFN_vkResetFences) vkelGetInstanceProcAddr(instance, "vkResetFences"); 1164 | __vkSetEvent = (PFN_vkSetEvent) vkelGetInstanceProcAddr(instance, "vkSetEvent"); 1165 | __vkUnmapMemory = (PFN_vkUnmapMemory) vkelGetInstanceProcAddr(instance, "vkUnmapMemory"); 1166 | __vkUpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) vkelGetInstanceProcAddr(instance, "vkUpdateDescriptorSets"); 1167 | __vkVoidFunction = (PFN_vkVoidFunction) vkelGetInstanceProcAddr(instance, "vkVoidFunction"); 1168 | __vkWaitForFences = (PFN_vkWaitForFences) vkelGetInstanceProcAddr(instance, "vkWaitForFences"); 1169 | 1170 | #ifdef VK_USE_PLATFORM_ANDROID_KHR 1171 | __vkCreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR) vkelGetInstanceProcAddr(instance, "vkCreateAndroidSurfaceKHR"); 1172 | #endif /* VK_USE_PLATFORM_ANDROID_KHR */ 1173 | 1174 | #ifdef VK_USE_PLATFORM_MIR_KHR 1175 | __vkCreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR) vkelGetInstanceProcAddr(instance, "vkCreateMirSurfaceKHR"); 1176 | __vkGetPhysicalDeviceMirPresentationSupportKHR = (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMirPresentationSupportKHR"); 1177 | #endif /* VK_USE_PLATFORM_MIR_KHR */ 1178 | 1179 | #ifdef VK_USE_PLATFORM_WAYLAND_KHR 1180 | __vkCreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR) vkelGetInstanceProcAddr(instance, "vkCreateWaylandSurfaceKHR"); 1181 | __vkGetPhysicalDeviceWaylandPresentationSupportKHR = (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"); 1182 | #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ 1183 | 1184 | #ifdef VK_USE_PLATFORM_WIN32_KHR 1185 | __vkCreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR) vkelGetInstanceProcAddr(instance, "vkCreateWin32SurfaceKHR"); 1186 | __vkGetPhysicalDeviceWin32PresentationSupportKHR = (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR"); 1187 | #endif /* VK_USE_PLATFORM_WIN32_KHR */ 1188 | 1189 | #ifdef VK_USE_PLATFORM_XCB_KHR 1190 | __vkCreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR) vkelGetInstanceProcAddr(instance, "vkCreateXcbSurfaceKHR"); 1191 | __vkGetPhysicalDeviceXcbPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR"); 1192 | #endif /* VK_USE_PLATFORM_XCB_KHR */ 1193 | 1194 | #ifdef VK_USE_PLATFORM_XLIB_KHR 1195 | __vkCreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR) vkelGetInstanceProcAddr(instance, "vkCreateXlibSurfaceKHR"); 1196 | __vkGetPhysicalDeviceXlibPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR) vkelGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR"); 1197 | #endif /* VK_USE_PLATFORM_XLIB_KHR */ 1198 | 1199 | 1200 | // Instance and device extension names 1201 | VKEL_AMD_gcn_shader = vkelIsInstanceExtensionSupported(NULL, "VK_AMD_gcn_shader"); 1202 | VKEL_AMD_rasterization_order = vkelIsInstanceExtensionSupported(NULL, "VK_AMD_rasterization_order"); 1203 | VKEL_AMD_shader_explicit_vertex_parameter = vkelIsInstanceExtensionSupported(NULL, "VK_AMD_shader_explicit_vertex_parameter"); 1204 | VKEL_AMD_shader_trinary_minmax = vkelIsInstanceExtensionSupported(NULL, "VK_AMD_shader_trinary_minmax"); 1205 | VKEL_EXT_debug_marker = vkelIsInstanceExtensionSupported(NULL, "VK_EXT_debug_marker"); 1206 | VKEL_EXT_debug_report = vkelIsInstanceExtensionSupported(NULL, "VK_EXT_debug_report"); 1207 | VKEL_IMG_filter_cubic = vkelIsInstanceExtensionSupported(NULL, "VK_IMG_filter_cubic"); 1208 | VKEL_IMG_format_pvrtc = vkelIsInstanceExtensionSupported(NULL, "VK_IMG_format_pvrtc"); 1209 | VKEL_KHR_android_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_android_surface"); 1210 | VKEL_KHR_display = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_display"); 1211 | VKEL_KHR_display_swapchain = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_display_swapchain"); 1212 | VKEL_KHR_mir_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_mir_surface"); 1213 | VKEL_KHR_sampler_mirror_clamp_to_edge = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_sampler_mirror_clamp_to_edge"); 1214 | VKEL_KHR_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_surface"); 1215 | VKEL_KHR_swapchain = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_swapchain"); 1216 | VKEL_KHR_wayland_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_wayland_surface"); 1217 | VKEL_KHR_win32_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_win32_surface"); 1218 | VKEL_KHR_xcb_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_xcb_surface"); 1219 | VKEL_KHR_xlib_surface = vkelIsInstanceExtensionSupported(NULL, "VK_KHR_xlib_surface"); 1220 | VKEL_NV_dedicated_allocation = vkelIsInstanceExtensionSupported(NULL, "VK_NV_dedicated_allocation"); 1221 | VKEL_NV_glsl_shader = vkelIsInstanceExtensionSupported(NULL, "VK_NV_glsl_shader"); 1222 | 1223 | // Instance and device layer names 1224 | VKEL_LAYER_GOOGLE_unique_objects = vkelIsInstanceLayerSupported("VK_LAYER_GOOGLE_unique_objects"); 1225 | VKEL_LAYER_LUNARG_api_dump = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_api_dump"); 1226 | VKEL_LAYER_LUNARG_device_limits = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_device_limits"); 1227 | VKEL_LAYER_LUNARG_draw_state = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_draw_state"); 1228 | VKEL_LAYER_LUNARG_image = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_image"); 1229 | VKEL_LAYER_LUNARG_mem_tracker = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_mem_tracker"); 1230 | VKEL_LAYER_LUNARG_object_tracker = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_object_tracker"); 1231 | VKEL_LAYER_LUNARG_param_checker = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_param_checker"); 1232 | VKEL_LAYER_LUNARG_screenshot = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_screenshot"); 1233 | VKEL_LAYER_LUNARG_swapchain = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_swapchain"); 1234 | VKEL_LAYER_LUNARG_threading = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_threading"); 1235 | VKEL_LAYER_LUNARG_vktrace = vkelIsInstanceLayerSupported("VK_LAYER_LUNARG_vktrace"); 1236 | 1237 | 1238 | return VK_TRUE; 1239 | } 1240 | 1241 | VkBool32 vkelDeviceInit(VkPhysicalDevice physicalDevice, VkDevice device) 1242 | { 1243 | if (!vkelVkLibHandle && !vkelInit()) 1244 | return VK_FALSE; 1245 | 1246 | 1247 | __vkAcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) vkelGetDeviceProcAddr(device, "vkAcquireNextImageKHR"); 1248 | __vkAllocateCommandBuffers = (PFN_vkAllocateCommandBuffers) vkelGetDeviceProcAddr(device, "vkAllocateCommandBuffers"); 1249 | __vkAllocateDescriptorSets = (PFN_vkAllocateDescriptorSets) vkelGetDeviceProcAddr(device, "vkAllocateDescriptorSets"); 1250 | __vkAllocateMemory = (PFN_vkAllocateMemory) vkelGetDeviceProcAddr(device, "vkAllocateMemory"); 1251 | __vkAllocationFunction = (PFN_vkAllocationFunction) vkelGetDeviceProcAddr(device, "vkAllocationFunction"); 1252 | __vkBeginCommandBuffer = (PFN_vkBeginCommandBuffer) vkelGetDeviceProcAddr(device, "vkBeginCommandBuffer"); 1253 | __vkBindBufferMemory = (PFN_vkBindBufferMemory) vkelGetDeviceProcAddr(device, "vkBindBufferMemory"); 1254 | __vkBindImageMemory = (PFN_vkBindImageMemory) vkelGetDeviceProcAddr(device, "vkBindImageMemory"); 1255 | __vkCmdBeginQuery = (PFN_vkCmdBeginQuery) vkelGetDeviceProcAddr(device, "vkCmdBeginQuery"); 1256 | __vkCmdBeginRenderPass = (PFN_vkCmdBeginRenderPass) vkelGetDeviceProcAddr(device, "vkCmdBeginRenderPass"); 1257 | __vkCmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) vkelGetDeviceProcAddr(device, "vkCmdBindDescriptorSets"); 1258 | __vkCmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer) vkelGetDeviceProcAddr(device, "vkCmdBindIndexBuffer"); 1259 | __vkCmdBindPipeline = (PFN_vkCmdBindPipeline) vkelGetDeviceProcAddr(device, "vkCmdBindPipeline"); 1260 | __vkCmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers) vkelGetDeviceProcAddr(device, "vkCmdBindVertexBuffers"); 1261 | __vkCmdBlitImage = (PFN_vkCmdBlitImage) vkelGetDeviceProcAddr(device, "vkCmdBlitImage"); 1262 | __vkCmdClearAttachments = (PFN_vkCmdClearAttachments) vkelGetDeviceProcAddr(device, "vkCmdClearAttachments"); 1263 | __vkCmdClearColorImage = (PFN_vkCmdClearColorImage) vkelGetDeviceProcAddr(device, "vkCmdClearColorImage"); 1264 | __vkCmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage) vkelGetDeviceProcAddr(device, "vkCmdClearDepthStencilImage"); 1265 | __vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer) vkelGetDeviceProcAddr(device, "vkCmdCopyBuffer"); 1266 | __vkCmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage) vkelGetDeviceProcAddr(device, "vkCmdCopyBufferToImage"); 1267 | __vkCmdCopyImage = (PFN_vkCmdCopyImage) vkelGetDeviceProcAddr(device, "vkCmdCopyImage"); 1268 | __vkCmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer) vkelGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer"); 1269 | __vkCmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults) vkelGetDeviceProcAddr(device, "vkCmdCopyQueryPoolResults"); 1270 | __vkCmdDebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT) vkelGetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT"); 1271 | __vkCmdDebugMarkerEndEXT = (PFN_vkCmdDebugMarkerEndEXT) vkelGetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT"); 1272 | __vkCmdDebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT) vkelGetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT"); 1273 | __vkCmdDispatch = (PFN_vkCmdDispatch) vkelGetDeviceProcAddr(device, "vkCmdDispatch"); 1274 | __vkCmdDispatchIndirect = (PFN_vkCmdDispatchIndirect) vkelGetDeviceProcAddr(device, "vkCmdDispatchIndirect"); 1275 | __vkCmdDraw = (PFN_vkCmdDraw) vkelGetDeviceProcAddr(device, "vkCmdDraw"); 1276 | __vkCmdDrawIndexed = (PFN_vkCmdDrawIndexed) vkelGetDeviceProcAddr(device, "vkCmdDrawIndexed"); 1277 | __vkCmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect) vkelGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirect"); 1278 | __vkCmdDrawIndirect = (PFN_vkCmdDrawIndirect) vkelGetDeviceProcAddr(device, "vkCmdDrawIndirect"); 1279 | __vkCmdEndQuery = (PFN_vkCmdEndQuery) vkelGetDeviceProcAddr(device, "vkCmdEndQuery"); 1280 | __vkCmdEndRenderPass = (PFN_vkCmdEndRenderPass) vkelGetDeviceProcAddr(device, "vkCmdEndRenderPass"); 1281 | __vkCmdExecuteCommands = (PFN_vkCmdExecuteCommands) vkelGetDeviceProcAddr(device, "vkCmdExecuteCommands"); 1282 | __vkCmdFillBuffer = (PFN_vkCmdFillBuffer) vkelGetDeviceProcAddr(device, "vkCmdFillBuffer"); 1283 | __vkCmdNextSubpass = (PFN_vkCmdNextSubpass) vkelGetDeviceProcAddr(device, "vkCmdNextSubpass"); 1284 | __vkCmdPipelineBarrier = (PFN_vkCmdPipelineBarrier) vkelGetDeviceProcAddr(device, "vkCmdPipelineBarrier"); 1285 | __vkCmdPushConstants = (PFN_vkCmdPushConstants) vkelGetDeviceProcAddr(device, "vkCmdPushConstants"); 1286 | __vkCmdResetEvent = (PFN_vkCmdResetEvent) vkelGetDeviceProcAddr(device, "vkCmdResetEvent"); 1287 | __vkCmdResetQueryPool = (PFN_vkCmdResetQueryPool) vkelGetDeviceProcAddr(device, "vkCmdResetQueryPool"); 1288 | __vkCmdResolveImage = (PFN_vkCmdResolveImage) vkelGetDeviceProcAddr(device, "vkCmdResolveImage"); 1289 | __vkCmdSetBlendConstants = (PFN_vkCmdSetBlendConstants) vkelGetDeviceProcAddr(device, "vkCmdSetBlendConstants"); 1290 | __vkCmdSetDepthBias = (PFN_vkCmdSetDepthBias) vkelGetDeviceProcAddr(device, "vkCmdSetDepthBias"); 1291 | __vkCmdSetDepthBounds = (PFN_vkCmdSetDepthBounds) vkelGetDeviceProcAddr(device, "vkCmdSetDepthBounds"); 1292 | __vkCmdSetEvent = (PFN_vkCmdSetEvent) vkelGetDeviceProcAddr(device, "vkCmdSetEvent"); 1293 | __vkCmdSetLineWidth = (PFN_vkCmdSetLineWidth) vkelGetDeviceProcAddr(device, "vkCmdSetLineWidth"); 1294 | __vkCmdSetScissor = (PFN_vkCmdSetScissor) vkelGetDeviceProcAddr(device, "vkCmdSetScissor"); 1295 | __vkCmdSetStencilCompareMask = (PFN_vkCmdSetStencilCompareMask) vkelGetDeviceProcAddr(device, "vkCmdSetStencilCompareMask"); 1296 | __vkCmdSetStencilReference = (PFN_vkCmdSetStencilReference) vkelGetDeviceProcAddr(device, "vkCmdSetStencilReference"); 1297 | __vkCmdSetStencilWriteMask = (PFN_vkCmdSetStencilWriteMask) vkelGetDeviceProcAddr(device, "vkCmdSetStencilWriteMask"); 1298 | __vkCmdSetViewport = (PFN_vkCmdSetViewport) vkelGetDeviceProcAddr(device, "vkCmdSetViewport"); 1299 | __vkCmdUpdateBuffer = (PFN_vkCmdUpdateBuffer) vkelGetDeviceProcAddr(device, "vkCmdUpdateBuffer"); 1300 | __vkCmdWaitEvents = (PFN_vkCmdWaitEvents) vkelGetDeviceProcAddr(device, "vkCmdWaitEvents"); 1301 | __vkCmdWriteTimestamp = (PFN_vkCmdWriteTimestamp) vkelGetDeviceProcAddr(device, "vkCmdWriteTimestamp"); 1302 | __vkCreateBuffer = (PFN_vkCreateBuffer) vkelGetDeviceProcAddr(device, "vkCreateBuffer"); 1303 | __vkCreateBufferView = (PFN_vkCreateBufferView) vkelGetDeviceProcAddr(device, "vkCreateBufferView"); 1304 | __vkCreateCommandPool = (PFN_vkCreateCommandPool) vkelGetDeviceProcAddr(device, "vkCreateCommandPool"); 1305 | __vkCreateComputePipelines = (PFN_vkCreateComputePipelines) vkelGetDeviceProcAddr(device, "vkCreateComputePipelines"); 1306 | __vkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT) vkelGetDeviceProcAddr(device, "vkCreateDebugReportCallbackEXT"); 1307 | __vkCreateDescriptorPool = (PFN_vkCreateDescriptorPool) vkelGetDeviceProcAddr(device, "vkCreateDescriptorPool"); 1308 | __vkCreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout) vkelGetDeviceProcAddr(device, "vkCreateDescriptorSetLayout"); 1309 | __vkCreateDevice = (PFN_vkCreateDevice) vkelGetDeviceProcAddr(device, "vkCreateDevice"); 1310 | __vkCreateDisplayModeKHR = (PFN_vkCreateDisplayModeKHR) vkelGetDeviceProcAddr(device, "vkCreateDisplayModeKHR"); 1311 | __vkCreateDisplayPlaneSurfaceKHR = (PFN_vkCreateDisplayPlaneSurfaceKHR) vkelGetDeviceProcAddr(device, "vkCreateDisplayPlaneSurfaceKHR"); 1312 | __vkCreateEvent = (PFN_vkCreateEvent) vkelGetDeviceProcAddr(device, "vkCreateEvent"); 1313 | __vkCreateFence = (PFN_vkCreateFence) vkelGetDeviceProcAddr(device, "vkCreateFence"); 1314 | __vkCreateFramebuffer = (PFN_vkCreateFramebuffer) vkelGetDeviceProcAddr(device, "vkCreateFramebuffer"); 1315 | __vkCreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines) vkelGetDeviceProcAddr(device, "vkCreateGraphicsPipelines"); 1316 | __vkCreateImage = (PFN_vkCreateImage) vkelGetDeviceProcAddr(device, "vkCreateImage"); 1317 | __vkCreateImageView = (PFN_vkCreateImageView) vkelGetDeviceProcAddr(device, "vkCreateImageView"); 1318 | __vkCreateInstance = (PFN_vkCreateInstance) vkelGetDeviceProcAddr(device, "vkCreateInstance"); 1319 | __vkCreatePipelineCache = (PFN_vkCreatePipelineCache) vkelGetDeviceProcAddr(device, "vkCreatePipelineCache"); 1320 | __vkCreatePipelineLayout = (PFN_vkCreatePipelineLayout) vkelGetDeviceProcAddr(device, "vkCreatePipelineLayout"); 1321 | __vkCreateQueryPool = (PFN_vkCreateQueryPool) vkelGetDeviceProcAddr(device, "vkCreateQueryPool"); 1322 | __vkCreateRenderPass = (PFN_vkCreateRenderPass) vkelGetDeviceProcAddr(device, "vkCreateRenderPass"); 1323 | __vkCreateSampler = (PFN_vkCreateSampler) vkelGetDeviceProcAddr(device, "vkCreateSampler"); 1324 | __vkCreateSemaphore = (PFN_vkCreateSemaphore) vkelGetDeviceProcAddr(device, "vkCreateSemaphore"); 1325 | __vkCreateShaderModule = (PFN_vkCreateShaderModule) vkelGetDeviceProcAddr(device, "vkCreateShaderModule"); 1326 | __vkCreateSharedSwapchainsKHR = (PFN_vkCreateSharedSwapchainsKHR) vkelGetDeviceProcAddr(device, "vkCreateSharedSwapchainsKHR"); 1327 | __vkCreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) vkelGetDeviceProcAddr(device, "vkCreateSwapchainKHR"); 1328 | __vkDebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT) vkelGetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT"); 1329 | __vkDebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT) vkelGetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT"); 1330 | __vkDebugReportCallbackEXT = (PFN_vkDebugReportCallbackEXT) vkelGetDeviceProcAddr(device, "vkDebugReportCallbackEXT"); 1331 | __vkDebugReportMessageEXT = (PFN_vkDebugReportMessageEXT) vkelGetDeviceProcAddr(device, "vkDebugReportMessageEXT"); 1332 | __vkDestroyBuffer = (PFN_vkDestroyBuffer) vkelGetDeviceProcAddr(device, "vkDestroyBuffer"); 1333 | __vkDestroyBufferView = (PFN_vkDestroyBufferView) vkelGetDeviceProcAddr(device, "vkDestroyBufferView"); 1334 | __vkDestroyCommandPool = (PFN_vkDestroyCommandPool) vkelGetDeviceProcAddr(device, "vkDestroyCommandPool"); 1335 | __vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT) vkelGetDeviceProcAddr(device, "vkDestroyDebugReportCallbackEXT"); 1336 | __vkDestroyDescriptorPool = (PFN_vkDestroyDescriptorPool) vkelGetDeviceProcAddr(device, "vkDestroyDescriptorPool"); 1337 | __vkDestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout) vkelGetDeviceProcAddr(device, "vkDestroyDescriptorSetLayout"); 1338 | __vkDestroyDevice = (PFN_vkDestroyDevice) vkelGetDeviceProcAddr(device, "vkDestroyDevice"); 1339 | __vkDestroyEvent = (PFN_vkDestroyEvent) vkelGetDeviceProcAddr(device, "vkDestroyEvent"); 1340 | __vkDestroyFence = (PFN_vkDestroyFence) vkelGetDeviceProcAddr(device, "vkDestroyFence"); 1341 | __vkDestroyFramebuffer = (PFN_vkDestroyFramebuffer) vkelGetDeviceProcAddr(device, "vkDestroyFramebuffer"); 1342 | __vkDestroyImage = (PFN_vkDestroyImage) vkelGetDeviceProcAddr(device, "vkDestroyImage"); 1343 | __vkDestroyImageView = (PFN_vkDestroyImageView) vkelGetDeviceProcAddr(device, "vkDestroyImageView"); 1344 | __vkDestroyInstance = (PFN_vkDestroyInstance) vkelGetDeviceProcAddr(device, "vkDestroyInstance"); 1345 | __vkDestroyPipeline = (PFN_vkDestroyPipeline) vkelGetDeviceProcAddr(device, "vkDestroyPipeline"); 1346 | __vkDestroyPipelineCache = (PFN_vkDestroyPipelineCache) vkelGetDeviceProcAddr(device, "vkDestroyPipelineCache"); 1347 | __vkDestroyPipelineLayout = (PFN_vkDestroyPipelineLayout) vkelGetDeviceProcAddr(device, "vkDestroyPipelineLayout"); 1348 | __vkDestroyQueryPool = (PFN_vkDestroyQueryPool) vkelGetDeviceProcAddr(device, "vkDestroyQueryPool"); 1349 | __vkDestroyRenderPass = (PFN_vkDestroyRenderPass) vkelGetDeviceProcAddr(device, "vkDestroyRenderPass"); 1350 | __vkDestroySampler = (PFN_vkDestroySampler) vkelGetDeviceProcAddr(device, "vkDestroySampler"); 1351 | __vkDestroySemaphore = (PFN_vkDestroySemaphore) vkelGetDeviceProcAddr(device, "vkDestroySemaphore"); 1352 | __vkDestroyShaderModule = (PFN_vkDestroyShaderModule) vkelGetDeviceProcAddr(device, "vkDestroyShaderModule"); 1353 | __vkDestroySurfaceKHR = (PFN_vkDestroySurfaceKHR) vkelGetDeviceProcAddr(device, "vkDestroySurfaceKHR"); 1354 | __vkDestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) vkelGetDeviceProcAddr(device, "vkDestroySwapchainKHR"); 1355 | __vkDeviceWaitIdle = (PFN_vkDeviceWaitIdle) vkelGetDeviceProcAddr(device, "vkDeviceWaitIdle"); 1356 | __vkEndCommandBuffer = (PFN_vkEndCommandBuffer) vkelGetDeviceProcAddr(device, "vkEndCommandBuffer"); 1357 | __vkEnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties) vkelGetDeviceProcAddr(device, "vkEnumerateDeviceExtensionProperties"); 1358 | __vkEnumerateDeviceLayerProperties = (PFN_vkEnumerateDeviceLayerProperties) vkelGetDeviceProcAddr(device, "vkEnumerateDeviceLayerProperties"); 1359 | __vkEnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties) vkelGetDeviceProcAddr(device, "vkEnumerateInstanceExtensionProperties"); 1360 | __vkEnumerateInstanceLayerProperties = (PFN_vkEnumerateInstanceLayerProperties) vkelGetDeviceProcAddr(device, "vkEnumerateInstanceLayerProperties"); 1361 | __vkEnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices) vkelGetDeviceProcAddr(device, "vkEnumeratePhysicalDevices"); 1362 | __vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges) vkelGetDeviceProcAddr(device, "vkFlushMappedMemoryRanges"); 1363 | __vkFreeCommandBuffers = (PFN_vkFreeCommandBuffers) vkelGetDeviceProcAddr(device, "vkFreeCommandBuffers"); 1364 | __vkFreeDescriptorSets = (PFN_vkFreeDescriptorSets) vkelGetDeviceProcAddr(device, "vkFreeDescriptorSets"); 1365 | __vkFreeFunction = (PFN_vkFreeFunction) vkelGetDeviceProcAddr(device, "vkFreeFunction"); 1366 | __vkFreeMemory = (PFN_vkFreeMemory) vkelGetDeviceProcAddr(device, "vkFreeMemory"); 1367 | __vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements) vkelGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements"); 1368 | __vkGetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment) vkelGetDeviceProcAddr(device, "vkGetDeviceMemoryCommitment"); 1369 | __vkGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr) vkelGetDeviceProcAddr(device, "vkGetDeviceProcAddr"); 1370 | __vkGetDeviceQueue = (PFN_vkGetDeviceQueue) vkelGetDeviceProcAddr(device, "vkGetDeviceQueue"); 1371 | __vkGetDisplayModePropertiesKHR = (PFN_vkGetDisplayModePropertiesKHR) vkelGetDeviceProcAddr(device, "vkGetDisplayModePropertiesKHR"); 1372 | __vkGetDisplayPlaneCapabilitiesKHR = (PFN_vkGetDisplayPlaneCapabilitiesKHR) vkelGetDeviceProcAddr(device, "vkGetDisplayPlaneCapabilitiesKHR"); 1373 | __vkGetDisplayPlaneSupportedDisplaysKHR = (PFN_vkGetDisplayPlaneSupportedDisplaysKHR) vkelGetDeviceProcAddr(device, "vkGetDisplayPlaneSupportedDisplaysKHR"); 1374 | __vkGetEventStatus = (PFN_vkGetEventStatus) vkelGetDeviceProcAddr(device, "vkGetEventStatus"); 1375 | __vkGetFenceStatus = (PFN_vkGetFenceStatus) vkelGetDeviceProcAddr(device, "vkGetFenceStatus"); 1376 | __vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements) vkelGetDeviceProcAddr(device, "vkGetImageMemoryRequirements"); 1377 | __vkGetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements) vkelGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements"); 1378 | __vkGetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout) vkelGetDeviceProcAddr(device, "vkGetImageSubresourceLayout"); 1379 | __vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr) vkelGetDeviceProcAddr(device, "vkGetInstanceProcAddr"); 1380 | __vkGetPhysicalDeviceDisplayPlanePropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"); 1381 | __vkGetPhysicalDeviceDisplayPropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPropertiesKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceDisplayPropertiesKHR"); 1382 | __vkGetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceFeatures"); 1383 | __vkGetPhysicalDeviceFormatProperties = (PFN_vkGetPhysicalDeviceFormatProperties) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceFormatProperties"); 1384 | __vkGetPhysicalDeviceImageFormatProperties = (PFN_vkGetPhysicalDeviceImageFormatProperties) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceImageFormatProperties"); 1385 | __vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceMemoryProperties"); 1386 | __vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceProperties"); 1387 | __vkGetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceQueueFamilyProperties"); 1388 | __vkGetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceSparseImageFormatProperties"); 1389 | __vkGetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); 1390 | __vkGetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceSurfaceFormatsKHR"); 1391 | __vkGetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceSurfacePresentModesKHR"); 1392 | __vkGetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceSurfaceSupportKHR"); 1393 | __vkGetPipelineCacheData = (PFN_vkGetPipelineCacheData) vkelGetDeviceProcAddr(device, "vkGetPipelineCacheData"); 1394 | __vkGetQueryPoolResults = (PFN_vkGetQueryPoolResults) vkelGetDeviceProcAddr(device, "vkGetQueryPoolResults"); 1395 | __vkGetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity) vkelGetDeviceProcAddr(device, "vkGetRenderAreaGranularity"); 1396 | __vkGetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) vkelGetDeviceProcAddr(device, "vkGetSwapchainImagesKHR"); 1397 | __vkInternalAllocationNotification = (PFN_vkInternalAllocationNotification) vkelGetDeviceProcAddr(device, "vkInternalAllocationNotification"); 1398 | __vkInternalFreeNotification = (PFN_vkInternalFreeNotification) vkelGetDeviceProcAddr(device, "vkInternalFreeNotification"); 1399 | __vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges) vkelGetDeviceProcAddr(device, "vkInvalidateMappedMemoryRanges"); 1400 | __vkMapMemory = (PFN_vkMapMemory) vkelGetDeviceProcAddr(device, "vkMapMemory"); 1401 | __vkMergePipelineCaches = (PFN_vkMergePipelineCaches) vkelGetDeviceProcAddr(device, "vkMergePipelineCaches"); 1402 | __vkQueueBindSparse = (PFN_vkQueueBindSparse) vkelGetDeviceProcAddr(device, "vkQueueBindSparse"); 1403 | __vkQueuePresentKHR = (PFN_vkQueuePresentKHR) vkelGetDeviceProcAddr(device, "vkQueuePresentKHR"); 1404 | __vkQueueSubmit = (PFN_vkQueueSubmit) vkelGetDeviceProcAddr(device, "vkQueueSubmit"); 1405 | __vkQueueWaitIdle = (PFN_vkQueueWaitIdle) vkelGetDeviceProcAddr(device, "vkQueueWaitIdle"); 1406 | __vkReallocationFunction = (PFN_vkReallocationFunction) vkelGetDeviceProcAddr(device, "vkReallocationFunction"); 1407 | __vkResetCommandBuffer = (PFN_vkResetCommandBuffer) vkelGetDeviceProcAddr(device, "vkResetCommandBuffer"); 1408 | __vkResetCommandPool = (PFN_vkResetCommandPool) vkelGetDeviceProcAddr(device, "vkResetCommandPool"); 1409 | __vkResetDescriptorPool = (PFN_vkResetDescriptorPool) vkelGetDeviceProcAddr(device, "vkResetDescriptorPool"); 1410 | __vkResetEvent = (PFN_vkResetEvent) vkelGetDeviceProcAddr(device, "vkResetEvent"); 1411 | __vkResetFences = (PFN_vkResetFences) vkelGetDeviceProcAddr(device, "vkResetFences"); 1412 | __vkSetEvent = (PFN_vkSetEvent) vkelGetDeviceProcAddr(device, "vkSetEvent"); 1413 | __vkUnmapMemory = (PFN_vkUnmapMemory) vkelGetDeviceProcAddr(device, "vkUnmapMemory"); 1414 | __vkUpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) vkelGetDeviceProcAddr(device, "vkUpdateDescriptorSets"); 1415 | __vkVoidFunction = (PFN_vkVoidFunction) vkelGetDeviceProcAddr(device, "vkVoidFunction"); 1416 | __vkWaitForFences = (PFN_vkWaitForFences) vkelGetDeviceProcAddr(device, "vkWaitForFences"); 1417 | 1418 | #ifdef VK_USE_PLATFORM_ANDROID_KHR 1419 | __vkCreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR) vkelGetDeviceProcAddr(device, "vkCreateAndroidSurfaceKHR"); 1420 | #endif /* VK_USE_PLATFORM_ANDROID_KHR */ 1421 | 1422 | #ifdef VK_USE_PLATFORM_MIR_KHR 1423 | __vkCreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR) vkelGetDeviceProcAddr(device, "vkCreateMirSurfaceKHR"); 1424 | __vkGetPhysicalDeviceMirPresentationSupportKHR = (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceMirPresentationSupportKHR"); 1425 | #endif /* VK_USE_PLATFORM_MIR_KHR */ 1426 | 1427 | #ifdef VK_USE_PLATFORM_WAYLAND_KHR 1428 | __vkCreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR) vkelGetDeviceProcAddr(device, "vkCreateWaylandSurfaceKHR"); 1429 | __vkGetPhysicalDeviceWaylandPresentationSupportKHR = (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"); 1430 | #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ 1431 | 1432 | #ifdef VK_USE_PLATFORM_WIN32_KHR 1433 | __vkCreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR) vkelGetDeviceProcAddr(device, "vkCreateWin32SurfaceKHR"); 1434 | __vkGetPhysicalDeviceWin32PresentationSupportKHR = (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceWin32PresentationSupportKHR"); 1435 | #endif /* VK_USE_PLATFORM_WIN32_KHR */ 1436 | 1437 | #ifdef VK_USE_PLATFORM_XCB_KHR 1438 | __vkCreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR) vkelGetDeviceProcAddr(device, "vkCreateXcbSurfaceKHR"); 1439 | __vkGetPhysicalDeviceXcbPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceXcbPresentationSupportKHR"); 1440 | #endif /* VK_USE_PLATFORM_XCB_KHR */ 1441 | 1442 | #ifdef VK_USE_PLATFORM_XLIB_KHR 1443 | __vkCreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR) vkelGetDeviceProcAddr(device, "vkCreateXlibSurfaceKHR"); 1444 | __vkGetPhysicalDeviceXlibPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR) vkelGetDeviceProcAddr(device, "vkGetPhysicalDeviceXlibPresentationSupportKHR"); 1445 | #endif /* VK_USE_PLATFORM_XLIB_KHR */ 1446 | 1447 | 1448 | // Instance and device extension names 1449 | VKEL_AMD_gcn_shader = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_AMD_gcn_shader"); 1450 | VKEL_AMD_rasterization_order = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_AMD_rasterization_order"); 1451 | VKEL_AMD_shader_explicit_vertex_parameter = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_AMD_shader_explicit_vertex_parameter"); 1452 | VKEL_AMD_shader_trinary_minmax = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_AMD_shader_trinary_minmax"); 1453 | VKEL_EXT_debug_marker = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_EXT_debug_marker"); 1454 | VKEL_EXT_debug_report = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_EXT_debug_report"); 1455 | VKEL_IMG_filter_cubic = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_IMG_filter_cubic"); 1456 | VKEL_IMG_format_pvrtc = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_IMG_format_pvrtc"); 1457 | VKEL_KHR_android_surface = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_android_surface"); 1458 | VKEL_KHR_display = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_display"); 1459 | VKEL_KHR_display_swapchain = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_display_swapchain"); 1460 | VKEL_KHR_mir_surface = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_mir_surface"); 1461 | VKEL_KHR_sampler_mirror_clamp_to_edge = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_sampler_mirror_clamp_to_edge"); 1462 | VKEL_KHR_surface = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_surface"); 1463 | VKEL_KHR_swapchain = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_swapchain"); 1464 | VKEL_KHR_wayland_surface = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_wayland_surface"); 1465 | VKEL_KHR_win32_surface = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_win32_surface"); 1466 | VKEL_KHR_xcb_surface = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_xcb_surface"); 1467 | VKEL_KHR_xlib_surface = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_KHR_xlib_surface"); 1468 | VKEL_NV_dedicated_allocation = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_NV_dedicated_allocation"); 1469 | VKEL_NV_glsl_shader = vkelIsDeviceExtensionSupported(physicalDevice, NULL, "VK_NV_glsl_shader"); 1470 | 1471 | // Instance and device layer names 1472 | VKEL_LAYER_GOOGLE_unique_objects = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_GOOGLE_unique_objects"); 1473 | VKEL_LAYER_LUNARG_api_dump = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_api_dump"); 1474 | VKEL_LAYER_LUNARG_device_limits = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_device_limits"); 1475 | VKEL_LAYER_LUNARG_draw_state = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_draw_state"); 1476 | VKEL_LAYER_LUNARG_image = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_image"); 1477 | VKEL_LAYER_LUNARG_mem_tracker = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_mem_tracker"); 1478 | VKEL_LAYER_LUNARG_object_tracker = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_object_tracker"); 1479 | VKEL_LAYER_LUNARG_param_checker = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_param_checker"); 1480 | VKEL_LAYER_LUNARG_screenshot = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_screenshot"); 1481 | VKEL_LAYER_LUNARG_swapchain = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_swapchain"); 1482 | VKEL_LAYER_LUNARG_threading = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_threading"); 1483 | VKEL_LAYER_LUNARG_vktrace = vkelIsDeviceLayerSupported(physicalDevice, "VK_LAYER_LUNARG_vktrace"); 1484 | 1485 | 1486 | return VK_TRUE; 1487 | } 1488 | 1489 | void vkelUninit(void) 1490 | { 1491 | if (vkelVkLibHandle) 1492 | { 1493 | vkelPlatformCloseLibrary(vkelVkLibHandle); 1494 | vkelVkLibHandle = NULL; 1495 | } 1496 | } 1497 | 1498 | 1499 | #ifdef __cplusplus 1500 | } 1501 | #endif /* __cplusplus */ -------------------------------------------------------------------------------- /vkel_gen.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | title vkel_gen.py ^| Christian Vallentin ^| https://github.com/MrVallentin/vkel 3 | python "%~dp0vkel_gen.py" -f %* 4 | pause -------------------------------------------------------------------------------- /vkel_gen.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | # Allow Python 2.6+ to use the print() function 4 | from __future__ import print_function 5 | 6 | COPYRIGHT = br'''//======================================================================== 7 | // Name 8 | // Vulkan (Cross-Platform) Extension Loader 9 | // 10 | // Repository 11 | // https://github.com/MrVallentin/vkel 12 | // 13 | // Overview 14 | // This is a simple, dynamic and tiny cross-platform Vulkan 15 | // extension loader. 16 | // 17 | // Dependencies 18 | // Vulkan (library) 19 | // Windows (header) - needed for library loading on Windows 20 | // dlfcn (header) - needed for library loading on non-Windows OS' 21 | // Standard C Libraries (stdio, stdlib, string, assert) - needed for NULL, malloc() 22 | // calloc(), free(), memset(), assert() 23 | // 24 | // Notice 25 | // Copyright (c) 2016 Christian Vallentin 26 | // 27 | // Developers & Contributors 28 | // Christian Vallentin 29 | // 30 | // Version History 31 | // Last Modified Date: May 16, 2016 32 | // Revision: 14 33 | // Version: 2.0.11 34 | // 35 | // Revision History 36 | // Revision 12, 2016/05/02 37 | // - Fixed "for loop initial declarations are only 38 | // allowed in C99 mode". 39 | // 40 | // Revision 3, 2016/02/26 41 | // - Rewrote vkel_gen.py, now it parses and directly 42 | // adds vulkan.h and vk_platform.h into vkel.h, 43 | // along with moving the appropriate copyrights 44 | // to the top of vkel.h. 45 | // - Fixed/added better differentiation for instance 46 | // and device related calls. 47 | // - Removed the need for having the vukan.h and 48 | // vk_platform.h headers. 49 | // 50 | // Revision 2, 2016/02/24 51 | // - Created a Python script for automatically generating 52 | // all the extensions and their functions. (Tested with 53 | // Python 3.5.1) 54 | // - Added cross-platform support, for loading libraries 55 | // and getting the function addresses. 56 | // - Fixed so platform specific functions defaults to NULL 57 | // - Added missing include for dlfcn (used on non-Window OS') 58 | // 59 | // Revision 1, 2016/02/23 60 | // - Implemented the basic version supporting a few (manually 61 | // written) dynamically loaded functions. 62 | // 63 | //------------------------------------------------------------------------ 64 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 65 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 66 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 67 | // IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 68 | // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 69 | // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 70 | // OTHER DEALINGS IN THE SOFTWARE. 71 | // 72 | // Permission is granted to anyone to use this software for any purpose, 73 | // including commercial applications, and to alter it and redistribute it 74 | // freely, subject to the following restrictions: 75 | // 76 | // 1. The origin of this software must not be misrepresented; you must not 77 | // claim that you wrote the original software. If you use this software 78 | // in a product, an acknowledgment in the product documentation would 79 | // be appreciated but is not required. 80 | // 81 | // 2. Altered source versions must be plainly marked as such, and must not 82 | // be misrepresented as being the original software. 83 | // 84 | // 3. This notice may not be removed or altered from any source 85 | // distribution. 86 | //======================================================================== 87 | 88 | ''' 89 | 90 | 91 | # Try to import Python 3 library urllib.request 92 | # and if it fails, fall back to Python 2 urllib2 93 | try: 94 | import urllib.request as urllib2 95 | except ImportError: 96 | import urllib2 97 | 98 | import os 99 | import re 100 | 101 | 102 | import sys 103 | 104 | # The first argument is always the script name, 105 | # we don't really care about that, so remove it! 106 | argv = sys.argv[1:] 107 | argc = len(argv) 108 | 109 | force = False 110 | keep = False 111 | 112 | if '-f' in argv: 113 | force = True 114 | 115 | if '-k' in argv: 116 | keep = True 117 | 118 | 119 | vulkan_h = "" 120 | vk_platform_h = "" 121 | 122 | 123 | if not force and os.path.exists("vulkan.h"): 124 | print("Using existing vulkan.h") 125 | 126 | with open("vulkan.h", "r") as f: 127 | for line in f: 128 | vulkan_h += line 129 | else: 130 | print("Downloading vulkan.h from GitHub") 131 | print("URL: https://github.com/KhronosGroup/Vulkan-Docs/tree/1.0/src/vulkan") 132 | 133 | vulkan_h_url = "http://raw.githubusercontent.com/KhronosGroup/Vulkan-Docs/1.0/src/vulkan/vulkan.h" 134 | vulkan_h_web = urllib2.urlopen(vulkan_h_url) 135 | 136 | for line in vulkan_h_web.readlines(): 137 | vulkan_h += line.decode("utf-8") 138 | 139 | if keep: 140 | with open("vulkan.h", "wb") as f: 141 | #f.writelines(vulkan_h_web.readlines()) 142 | f.write(vulkan_h.encode("utf-8")) 143 | 144 | 145 | if not force and os.path.exists("vk_platform.h"): 146 | print("Using existing vk_platform.h") 147 | 148 | with open("vk_platform.h", "r") as f: 149 | for line in f: 150 | vk_platform_h += line 151 | else: 152 | print("Downloading vk_platform.h from GitHub") 153 | print("URL: https://github.com/KhronosGroup/Vulkan-Docs/tree/1.0/src/vulkan") 154 | 155 | vk_platform_h_url = "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Docs/1.0/src/vulkan/vk_platform.h" 156 | vk_platform_h_web = urllib2.urlopen(vk_platform_h_url) 157 | 158 | for line in vk_platform_h_web.readlines(): 159 | vk_platform_h += line.decode("utf-8") 160 | 161 | if keep: 162 | with open("vk_platform.h", "wb") as f: 163 | #f.writelines(vk_platform_h_web.readlines()) 164 | f.write(vk_platform_h.encode("utf-8")) 165 | 166 | 167 | print("Parsing vulkan.h and vk_platform.h") 168 | 169 | 170 | extension_names = [] 171 | 172 | for extension_name in re.findall("#define\s+.*?_EXTENSION_NAME\s+\"VK_(.*?)\"", vulkan_h): 173 | extension_names.append(extension_name) 174 | 175 | 176 | # This device extension isn't listed in vulkan.h, to just manually add it for now 177 | if "NV_glsl_shader" not in extension_names: 178 | extension_names.append("NV_glsl_shader") 179 | 180 | 181 | # Layers aren't defined in vulkan.h (at the point of writing this at least), 182 | # so I need to find an easier way of automating. Currently they are hand 183 | # written using the output of vkEnumerateInstanceLayerProperties. 184 | layer_names = [ 185 | # Instance Layers 186 | "LAYER_LUNARG_api_dump", 187 | "LAYER_LUNARG_device_limits", 188 | "LAYER_LUNARG_draw_state", 189 | "LAYER_LUNARG_image", 190 | "LAYER_LUNARG_mem_tracker", 191 | "LAYER_LUNARG_object_tracker", 192 | "LAYER_LUNARG_param_checker", 193 | "LAYER_LUNARG_screenshot", 194 | "LAYER_LUNARG_swapchain", 195 | "LAYER_LUNARG_threading", 196 | "LAYER_GOOGLE_unique_objects", 197 | "LAYER_LUNARG_vktrace", 198 | 199 | # Device Layers 200 | "", 201 | ] 202 | 203 | 204 | # all the functions no matter which platform 205 | all_funcs = [] 206 | 207 | # all the function but platform specific 208 | platform_funcs = { 209 | "": [] # none-platform specific functions 210 | } 211 | 212 | # current platform 213 | platform = None 214 | 215 | 216 | # regex_function = re.compile(r"PFN_(\w+)") 217 | regex_function = re.compile(r"VKAPI_PTR\s+\*PFN_(\w+)") 218 | 219 | regex_platform_begin = re.compile(r"#ifdef\s+(VK_USE_PLATFORM\w+)") 220 | regex_platform_end = re.compile(r"#endif\s+/\*\s*(\w+)\s*\*/") 221 | 222 | 223 | for line in vulkan_h.splitlines(): 224 | match_platform = regex_platform_begin.search(line) 225 | 226 | if match_platform: 227 | platform = match_platform.group(1) 228 | 229 | if platform not in platform_funcs: 230 | platform_funcs[platform] = [] 231 | 232 | 233 | match_platform = regex_platform_end.search(line) 234 | 235 | if match_platform: 236 | if platform == match_platform.group(1): 237 | platform = None 238 | 239 | 240 | match_func = regex_function.search(line) 241 | 242 | if match_func: 243 | func = match_func.group(1) 244 | 245 | if func not in all_funcs: 246 | all_funcs.append(func) 247 | 248 | if platform is None: 249 | platform_funcs[""].append(func) 250 | else: 251 | platform_funcs[platform].append(func) 252 | 253 | 254 | print("Processing vulkan.h and vk_platform.h") 255 | 256 | 257 | def process_source_code(source): 258 | # Remove extern (we gonna add one overall later) 259 | source = re.compile("\s*?#\s*?ifdef\s+__cplusplus.*?#endif.*?$", re.S | re.I | re.M).sub("", source) 260 | 261 | # Remove everything within VK_NO_PROTOTYPES 262 | source = re.compile(r"^\s*?#\s*?ifndef VK_NO_PROTOTYPES.*?^#\s*endif", re.S | re.M).sub("", source) 263 | 264 | 265 | # Remove multi-line comments 266 | source = re.compile("\/\*[\s\S]*?\*\/").sub("", source) 267 | 268 | # Remove single-line comments, which are at the beginning of a line 269 | source = re.compile("^//.*?\r?\n", re.M).sub("", source) 270 | 271 | 272 | # Trim lines that only contain whitespace 273 | source = re.compile("^\s+$", re.M).sub("", source) 274 | 275 | # Turn repeating new lines into 1 new line 276 | source = re.compile(r"^(\r?\n)\s*?(\r?\n\s*?)+^", re.M).sub(r"\1", source) 277 | 278 | # Trim leading and trailing whitespace 279 | source = source.strip() 280 | 281 | 282 | return source 283 | 284 | 285 | # This works by selecting the longest found multi-line comment, 286 | # that contains the word "copyright" case-insensitive. 287 | def get_copyright(source): 288 | longest = "" 289 | 290 | re_copyright = re.compile("copyright", re.I) 291 | 292 | for comment in re.findall("\/\*[\s\S]*?\*\/", vulkan_h, re.M): 293 | if re_copyright.search(comment): 294 | if len(comment) > len(longest): 295 | longest = comment 296 | 297 | # Is it empty? 298 | if not longest: 299 | return None 300 | 301 | # Trim it 302 | longest = longest.strip() 303 | 304 | # Then add 2 new lines (just for formatting purposes in vkel) 305 | longest += "\n\n" 306 | 307 | return longest 308 | 309 | 310 | vulkan_h_copyright = get_copyright(vulkan_h) 311 | vk_platform_h_copyright = get_copyright(vulkan_h) 312 | 313 | # Are they identical copyrights? 314 | if vulkan_h_copyright == vk_platform_h_copyright: 315 | # Then just remove one of them 316 | vk_platform_h_copyright = None 317 | 318 | 319 | vk_platform_h = process_source_code(vk_platform_h) 320 | vulkan_h = process_source_code(vulkan_h) 321 | 322 | vulkan_h = re.compile(r"^\s*#\s*include\s+\"vk_platform.h\"", re.I | re.M).sub(vk_platform_h, vulkan_h) 323 | 324 | vulkan_h = process_source_code(vulkan_h) 325 | 326 | 327 | print("Generating vkel.h") 328 | 329 | 330 | def add_copyright(f): 331 | f.write(COPYRIGHT) 332 | 333 | if vulkan_h_copyright: 334 | f.write(vulkan_h_copyright.encode("utf-8")) 335 | 336 | if vk_platform_h_copyright: 337 | f.write(vk_platform_h_copyright.encode("utf-8")) 338 | 339 | 340 | with open("vkel.h", "wb") as f: 341 | add_copyright(f) 342 | 343 | 344 | f.write(br'''#ifndef _VKEL_H_ 345 | #define _VKEL_H_ 1 346 | 347 | #ifdef __cplusplus 348 | extern "C" { 349 | #endif /* __cplusplus */ 350 | 351 | 352 | #if !defined(_WIN32) && (defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)) 353 | # define _WIN32 354 | #endif /* _WIN32 */ 355 | 356 | #if defined(_WIN32) 357 | # ifndef VK_USE_PLATFORM_WIN32_KHR 358 | # define VK_USE_PLATFORM_WIN32_KHR 1 359 | # endif 360 | #elif defined(__ANDROID__) && defined(__ARM_EABI__) && !defined(__ARM_ARCH_7A__) 361 | # ifndef VK_USE_PLATFORM_ANDROID_KHR 362 | # define VK_USE_PLATFORM_ANDROID_KHR 1 363 | # endif 364 | // #elif defined(__linux__) || defined(__unix__) 365 | #else 366 | # ifndef VK_USE_PLATFORM_XCB_KHR 367 | # define VK_USE_PLATFORM_XCB_KHR 1 368 | # endif 369 | // #else 370 | // # error You need to open vkel.h and add a #define VK_USE_PLATFORM_*_KHR. Please also report your OS on https://github.com/MrVallentin/vkel 371 | #endif 372 | 373 | ''') 374 | 375 | 376 | f.write(br''' 377 | #ifdef __vulkan_h_ 378 | 379 | #if _MSC_VER 380 | # pragma message("Warning: Vulkan 1.0.4's include guard was changed from __vulkan_h_ to VULKAN_H_, so you might need to update your vulkan.h file") 381 | #elif __GNUC__ 382 | # warning "Warning: Vulkan 1.0.4's include guard was changed from __vulkan_h_ to VULKAN_H_, so you might need to update your vulkan.h file" 383 | #endif 384 | 385 | #endif /* __vulkan_h_ */ 386 | 387 | 388 | ''') 389 | 390 | # vulkan_h contains vk_platform_h 391 | f.write(vulkan_h.encode("utf-8")) 392 | f.write(b"\n\n") 393 | 394 | 395 | f.write(br''' 396 | extern PFN_vkVoidFunction vkelGetProcAddr(const char *pName); 397 | 398 | extern PFN_vkVoidFunction vkelGetInstanceProcAddr(VkInstance instance, const char *pName); 399 | extern PFN_vkVoidFunction vkelGetDeviceProcAddr(VkDevice device, const char *pName); 400 | 401 | 402 | extern void vkelDeleteNames(uint32_t nameCount, char **names); 403 | 404 | 405 | extern char** vkelGetInstanceExtensionNames(const char *pLayerName, uint32_t *extensionNameCount); 406 | #define vkelDeleteInstanceExtensionNames vkelDeleteNames 407 | 408 | extern char** vkelGetInstanceLayerNames(uint32_t *layerNameCount); 409 | #define vkelDeleteInstanceLayerNames vkelDeleteNames 410 | 411 | 412 | extern char** vkelGetDeviceExtensionNames(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *extensionNameCount); 413 | #define vkelDeleteDeviceExtensionNames vkelDeleteNames 414 | 415 | extern char** vkelGetDeviceLayerNames(VkPhysicalDevice physicalDevice, uint32_t *layerNameCount); 416 | #define vkelDeleteDeviceLayerNames vkelDeleteNames 417 | 418 | 419 | extern VkBool32 vkelIsInstanceLayerSupported(const char *pLayerName); 420 | extern VkBool32 vkelIsInstanceExtensionSupported(const char *pLayerName, const char *pExtensionName); 421 | 422 | extern VkBool32 vkelIsDeviceLayerSupported(VkPhysicalDevice physicalDevice, const char *pLayerName); 423 | extern VkBool32 vkelIsDeviceExtensionSupported(VkPhysicalDevice physicalDevice, const char *pLayerName, const char *pExtensionName); 424 | 425 | 426 | extern VkBool32 vkelInit(void); 427 | extern VkBool32 vkelInstanceInit(VkInstance instance); 428 | extern VkBool32 vkelDeviceInit(VkPhysicalDevice physicalDevice, VkDevice device); 429 | 430 | extern void vkelUninit(void); 431 | 432 | 433 | ''') 434 | 435 | 436 | f.write(b"// Instance and device extension names\n") 437 | 438 | # Are there any (instance or device) extensions? (is array empty) 439 | if extension_names: 440 | for extension_name in sorted(extension_names): 441 | if extension_name: 442 | f.write("extern VkBool32 VKEL_{0};\n".format(extension_name).encode("utf-8")) 443 | 444 | f.write(b"\n") 445 | 446 | 447 | f.write(b"// Instance and device layer names\n") 448 | 449 | # Are there any (instance or device) layers? (is array empty) 450 | if layer_names: 451 | for layer_name in sorted(layer_names): 452 | if layer_name: 453 | f.write("extern VkBool32 VKEL_{0};\n".format(layer_name).encode("utf-8")) 454 | 455 | f.write(b"\n\n") 456 | 457 | 458 | lines = [] 459 | 460 | lines.append("// Functions") 461 | 462 | # Generate all function pointers 463 | for platform in sorted(platform_funcs): 464 | if platform: 465 | lines.append("#ifdef " + platform) 466 | 467 | for func in sorted(platform_funcs[platform]): 468 | # lines.append("PFN_{0} {0};".format(func)) 469 | # lines.append("PFN_{0} __{0};".format(func)) 470 | lines.append("extern PFN_{0} __{0};".format(func)) 471 | 472 | 473 | if platform: 474 | lines.append("#endif /* " + platform + " */") 475 | 476 | lines.append("") 477 | 478 | # Generate NULL pointers for platform specific functions 479 | for platform in sorted(platform_funcs): 480 | if platform: 481 | lines.append("// {0}".format(platform)) 482 | 483 | for func in sorted(platform_funcs[platform]): 484 | lines.append("#define {0} NULL".format(func)) 485 | 486 | lines.append("") 487 | else: 488 | for func in sorted(platform_funcs[platform]): 489 | lines.append("#define {0} __{0}".format(func)) 490 | 491 | # Generate platform specific functions 492 | for platform in sorted(platform_funcs): 493 | if platform: 494 | lines.append("#ifdef " + platform) 495 | 496 | for func in sorted(platform_funcs[platform]): 497 | lines.append("#undef {0}".format(func)) 498 | 499 | for func in sorted(platform_funcs[platform]): 500 | lines.append("#define {0} __{0}".format(func)) 501 | 502 | lines.append("#endif /* " + platform + " */") 503 | lines.append("") 504 | 505 | lines.append("") 506 | 507 | f.write("\n".join(lines).encode("utf-8")) 508 | 509 | 510 | f.write(br''' 511 | #ifdef __cplusplus 512 | } 513 | #endif /* __cplusplus */ 514 | 515 | #endif /* _VKEL_H_ */''') 516 | 517 | 518 | print("Generating vkel.c") 519 | 520 | 521 | with open("vkel.c", "wb") as f: 522 | add_copyright(f) 523 | 524 | 525 | f.write(br'''#include "vkel.h" 526 | 527 | #ifdef __cplusplus 528 | extern "C" { 529 | #endif /* __cplusplus */ 530 | 531 | 532 | #include /* NULL, printf() */ 533 | #include /* malloc(), calloc(), free() */ 534 | #include /* memset() */ 535 | #include /* assert() */ 536 | 537 | 538 | #ifdef VK_USE_PLATFORM_WIN32_KHR 539 | 540 | #ifndef VC_EXTRALEAN 541 | # define VC_EXTRALEAN 542 | #endif 543 | 544 | #ifndef WIN32_LEAN_AND_MEAN 545 | # define WIN32_LEAN_AND_MEAN 546 | #endif 547 | 548 | // STOP THAT, BAD WINDOWS! 549 | #ifndef NOMINMAX 550 | # define NOMINMAX 551 | #endif 552 | 553 | #include 554 | #else 555 | 556 | #include 557 | 558 | #endif 559 | 560 | 561 | #ifdef VK_USE_PLATFORM_WIN32_KHR 562 | # define vkelPlatformOpenLibrary(name) LoadLibraryA(name) 563 | # define vkelPlatformCloseLibrary(handle) FreeLibrary((HMODULE) handle) 564 | # define vkelPlatformGetProcAddr(handle, name) GetProcAddress((HMODULE) handle, name) 565 | // #elif defined(__APPLE__) || defined(__linux__) || defined(__ANDROID__) || defined(__unix__ ) 566 | #else 567 | #define vkelPlatformOpenLibrary(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL) 568 | #define vkelPlatformCloseLibrary(handle) dlclose(handle) 569 | #define vkelPlatformGetProcAddr(handle, name) dlsym(handle, name) 570 | // #else 571 | // # error VKEL Unsupported Platform 572 | #endif 573 | 574 | static void *vkelVkLibHandle; 575 | 576 | 577 | ''') 578 | 579 | 580 | f.write(b"// Instance and device extension names\n") 581 | 582 | # Are there any (instance or device) extensions? (is array empty) 583 | if extension_names: 584 | for extension_name in sorted(extension_names): 585 | if extension_name: 586 | f.write("VkBool32 VKEL_{0};\n".format(extension_name).encode("utf-8")) 587 | 588 | f.write(b"\n") 589 | 590 | 591 | f.write(b"// Instance and device layer names\n") 592 | 593 | # Are there any (instance or device) layers? (is array empty) 594 | if layer_names: 595 | for layer_name in sorted(layer_names): 596 | if layer_name: 597 | f.write("VkBool32 VKEL_{0};\n".format(layer_name).encode("utf-8")) 598 | 599 | f.write(b"\n\n") 600 | 601 | 602 | lines = [] 603 | 604 | lines.append("// Functions") 605 | 606 | # Generate all function pointers 607 | for platform in sorted(platform_funcs): 608 | if platform: 609 | lines.append("#ifdef " + platform) 610 | 611 | for func in sorted(platform_funcs[platform]): 612 | # lines.append("PFN_{0} {0};".format(func)) 613 | lines.append("PFN_{0} __{0};".format(func)) 614 | 615 | 616 | if platform: 617 | lines.append("#endif /* " + platform + " */") 618 | 619 | lines.append("") 620 | 621 | lines.append("") 622 | 623 | f.write("\n".join(lines).encode("utf-8")) 624 | 625 | 626 | 627 | f.write(br''' 628 | PFN_vkVoidFunction vkelGetProcAddr(const char *name) 629 | { 630 | return (PFN_vkVoidFunction) vkelPlatformGetProcAddr(vkelVkLibHandle, name); 631 | } 632 | 633 | PFN_vkVoidFunction vkelGetInstanceProcAddr(VkInstance instance, const char *pName) 634 | { 635 | PFN_vkVoidFunction proc = (PFN_vkVoidFunction) vkGetInstanceProcAddr(instance, pName); 636 | 637 | if (!proc) 638 | proc = (PFN_vkVoidFunction) vkelGetProcAddr(pName); 639 | 640 | return proc; 641 | } 642 | 643 | PFN_vkVoidFunction vkelGetDeviceProcAddr(VkDevice device, const char *pName) 644 | { 645 | PFN_vkVoidFunction proc = (PFN_vkVoidFunction) vkGetDeviceProcAddr(device, pName); 646 | 647 | if (!proc) 648 | proc = (PFN_vkVoidFunction) vkelGetInstanceProcAddr(NULL, pName); 649 | 650 | return proc; 651 | } 652 | 653 | 654 | static int vkel_strcmp(const char *str1, const char *str2) 655 | { 656 | while (*str1 && (*str1 == *str2)) 657 | { 658 | str1++, str2++; 659 | } 660 | 661 | return *(const unsigned char*) str1 - *(const unsigned char*) str2; 662 | } 663 | 664 | static void vkel_strpy(char *dest, char *src) 665 | { 666 | while (*dest++ = *src++); 667 | } 668 | 669 | 670 | void vkelDeleteNames(uint32_t nameCount, char **names) 671 | { 672 | // assert(names); 673 | if (!names) 674 | return; 675 | 676 | uint32_t nameIndex = 0; 677 | for (nameIndex = 0; nameIndex < nameCount; nameIndex++) 678 | { 679 | // assert(names[nameIndex]); 680 | if (!names[nameIndex]) 681 | continue; 682 | 683 | free(names[nameIndex]); 684 | } 685 | 686 | free(names); 687 | } 688 | 689 | 690 | char** vkelGetInstanceExtensionNames(const char *pLayerName, uint32_t *extensionNameCount) 691 | { 692 | assert(extensionNameCount); 693 | 694 | 695 | VkResult err; 696 | 697 | 698 | uint32_t extPropertyCount; 699 | err = vkEnumerateInstanceExtensionProperties(pLayerName, &extPropertyCount, NULL); 700 | assert(!err); 701 | 702 | (*extensionNameCount) = extPropertyCount; 703 | 704 | if (extPropertyCount < 1) 705 | return NULL; 706 | 707 | 708 | char **extensionNames = (char**) calloc(extPropertyCount, sizeof(char*)); 709 | 710 | uint32_t extensionNameIndex = 0; 711 | for (extensionNameIndex = 0; extensionNameIndex < extPropertyCount; extensionNameIndex++) 712 | { 713 | extensionNames[extensionNameIndex] = (char*)calloc(VK_MAX_EXTENSION_NAME_SIZE, sizeof(char)); 714 | } 715 | 716 | 717 | VkExtensionProperties *extProperties = (VkExtensionProperties*) calloc(extPropertyCount, sizeof(VkExtensionProperties)); 718 | assert(extProperties); 719 | 720 | 721 | err = vkEnumerateInstanceExtensionProperties(pLayerName, &extPropertyCount, extProperties); 722 | assert(!err); 723 | 724 | uint32_t extPropertyIndex = 0; 725 | for (extPropertyIndex = 0; extPropertyIndex < extPropertyCount; extPropertyIndex++) 726 | { 727 | VkExtensionProperties extProperty = extProperties[extPropertyIndex]; 728 | 729 | vkel_strpy(extensionNames[extPropertyIndex], extProperty.extensionName); 730 | } 731 | 732 | 733 | free(extProperties); 734 | 735 | 736 | return extensionNames; 737 | } 738 | 739 | char** vkelGetInstanceLayerNames(uint32_t *layerNameCount) 740 | { 741 | assert(layerNameCount); 742 | 743 | 744 | VkResult err; 745 | 746 | 747 | uint32_t layerPropertyCount; 748 | err = vkEnumerateInstanceLayerProperties(&layerPropertyCount, NULL); 749 | assert(!err); 750 | 751 | (*layerNameCount) = layerPropertyCount; 752 | 753 | if (layerPropertyCount < 1) 754 | return NULL; 755 | 756 | 757 | char **layerNames = (char**) calloc(layerPropertyCount, sizeof(char*)); 758 | 759 | uint32_t layerNameIndex = 0; 760 | for (layerNameIndex = 0; layerNameIndex < layerPropertyCount; layerNameIndex++) 761 | { 762 | layerNames[layerNameIndex] = (char*) calloc(VK_MAX_EXTENSION_NAME_SIZE, sizeof(char)); 763 | } 764 | 765 | 766 | VkLayerProperties *layerProperties = (VkLayerProperties*) calloc(layerPropertyCount, sizeof(VkLayerProperties)); 767 | assert(layerProperties); 768 | 769 | err = vkEnumerateInstanceLayerProperties(&layerPropertyCount, layerProperties); 770 | assert(!err); 771 | 772 | uint32_t layerPropertyIndex = 0; 773 | for (layerPropertyIndex = 0; layerPropertyIndex < layerPropertyCount; layerPropertyIndex++) 774 | { 775 | VkLayerProperties layerProperty = layerProperties[layerPropertyIndex]; 776 | 777 | vkel_strpy(layerNames[layerPropertyIndex], layerProperty.layerName); 778 | } 779 | 780 | 781 | free(layerProperties); 782 | 783 | 784 | return layerNames; 785 | } 786 | 787 | 788 | char** vkelGetDeviceExtensionNames(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *extensionNameCount) 789 | { 790 | assert(extensionNameCount); 791 | 792 | 793 | VkResult err; 794 | 795 | 796 | uint32_t extPropertyCount; 797 | err = vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, &extPropertyCount, NULL); 798 | assert(!err); 799 | 800 | (*extensionNameCount) = extPropertyCount; 801 | 802 | if (extPropertyCount < 1) 803 | return NULL; 804 | 805 | 806 | char **extensionNames = (char**) calloc(extPropertyCount, sizeof(char*)); 807 | 808 | uint32_t extensionNameIndex = 0; 809 | for (extensionNameIndex = 0; extensionNameIndex < extPropertyCount; extensionNameIndex++) 810 | { 811 | extensionNames[extensionNameIndex] = (char*) calloc(VK_MAX_EXTENSION_NAME_SIZE, sizeof(char)); 812 | } 813 | 814 | 815 | VkExtensionProperties *extProperties = (VkExtensionProperties*) calloc(extPropertyCount, sizeof(VkExtensionProperties)); 816 | assert(extProperties); 817 | 818 | 819 | err = vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, &extPropertyCount, extProperties); 820 | assert(!err); 821 | 822 | uint32_t extPropertyIndex = 0; 823 | for (extPropertyIndex = 0; extPropertyIndex < extPropertyCount; extPropertyIndex++) 824 | { 825 | VkExtensionProperties extProperty = extProperties[extPropertyIndex]; 826 | 827 | vkel_strpy(extensionNames[extPropertyIndex], extProperty.extensionName); 828 | } 829 | 830 | 831 | free(extProperties); 832 | 833 | 834 | return extensionNames; 835 | } 836 | 837 | char** vkelGetDeviceLayerNames(VkPhysicalDevice physicalDevice, uint32_t *layerNameCount) 838 | { 839 | assert(layerNameCount); 840 | 841 | 842 | VkResult err; 843 | 844 | 845 | uint32_t layerPropertyCount; 846 | err = vkEnumerateDeviceLayerProperties(physicalDevice, &layerPropertyCount, NULL); 847 | assert(!err); 848 | 849 | (*layerNameCount) = layerPropertyCount; 850 | 851 | if (layerPropertyCount < 1) 852 | return NULL; 853 | 854 | 855 | char **layerNames = (char**) calloc(layerPropertyCount, sizeof(char*)); 856 | 857 | uint32_t layerNameIndex = 0; 858 | for (layerNameIndex = 0; layerNameIndex < layerPropertyCount; layerNameIndex++) 859 | { 860 | layerNames[layerNameIndex] = (char*) calloc(VK_MAX_EXTENSION_NAME_SIZE, sizeof(char)); 861 | } 862 | 863 | 864 | VkLayerProperties *layerProperties = (VkLayerProperties*) calloc(layerPropertyCount, sizeof(VkLayerProperties)); 865 | assert(layerProperties); 866 | 867 | err = vkEnumerateDeviceLayerProperties(physicalDevice, &layerPropertyCount, layerProperties); 868 | assert(!err); 869 | 870 | uint32_t layerPropertyIndex = 0; 871 | for (layerPropertyIndex = 0; layerPropertyIndex < layerPropertyCount; layerPropertyIndex++) 872 | { 873 | VkLayerProperties layerProperty = layerProperties[layerPropertyIndex]; 874 | 875 | vkel_strpy(layerNames[layerPropertyIndex], layerProperty.layerName); 876 | } 877 | 878 | 879 | free(layerProperties); 880 | 881 | 882 | return layerNames; 883 | } 884 | 885 | 886 | VkBool32 vkelIsInstanceLayerSupported(const char *pLayerName) 887 | { 888 | uint32_t layerNameCount = 0; 889 | char **layerNames = vkelGetInstanceLayerNames(&layerNameCount); 890 | 891 | uint32_t layerNameIndex = 0; 892 | for (layerNameIndex = 0; layerNameIndex < layerNameCount; layerNameIndex++) 893 | { 894 | if (vkel_strcmp(layerNames[layerNameIndex], pLayerName)) 895 | { 896 | vkelDeleteInstanceLayerNames(layerNameCount, layerNames); 897 | 898 | return VK_TRUE; 899 | } 900 | } 901 | 902 | vkelDeleteInstanceLayerNames(layerNameCount, layerNames); 903 | 904 | return VK_FALSE; 905 | } 906 | 907 | VkBool32 vkelIsInstanceExtensionSupported(const char *pLayerName, const char *pExtensionName) 908 | { 909 | uint32_t extensionNameCount = 0; 910 | char **extensionNames = vkelGetInstanceExtensionNames(pLayerName, &extensionNameCount); 911 | 912 | uint32_t extensionNameIndex = 0; 913 | for (extensionNameIndex = 0; extensionNameIndex < extensionNameCount; extensionNameIndex++) 914 | { 915 | if (vkel_strcmp(extensionNames[extensionNameIndex], pExtensionName)) 916 | { 917 | vkelDeleteInstanceExtensionNames(extensionNameCount, extensionNames); 918 | 919 | return VK_TRUE; 920 | } 921 | } 922 | 923 | vkelDeleteInstanceExtensionNames(extensionNameCount, extensionNames); 924 | 925 | return VK_FALSE; 926 | } 927 | 928 | 929 | VkBool32 vkelIsDeviceLayerSupported(VkPhysicalDevice physicalDevice, const char *pLayerName) 930 | { 931 | uint32_t layerNameCount = 0; 932 | char **layerNames = vkelGetDeviceLayerNames(physicalDevice, &layerNameCount); 933 | 934 | uint32_t layerNameIndex = 0; 935 | for (layerNameIndex = 0; layerNameIndex < layerNameCount; layerNameIndex++) 936 | { 937 | if (vkel_strcmp(layerNames[layerNameIndex], pLayerName)) 938 | { 939 | vkelDeleteDeviceLayerNames(layerNameCount, layerNames); 940 | 941 | return VK_TRUE; 942 | } 943 | } 944 | 945 | vkelDeleteDeviceLayerNames(layerNameCount, layerNames); 946 | 947 | return VK_FALSE; 948 | } 949 | 950 | VkBool32 vkelIsDeviceExtensionSupported(VkPhysicalDevice physicalDevice, const char *pLayerName, const char *pExtensionName) 951 | { 952 | uint32_t extensionNameCount = 0; 953 | char **extensionNames = vkelGetDeviceExtensionNames(physicalDevice, pLayerName, &extensionNameCount); 954 | 955 | uint32_t extensionNameIndex = 0; 956 | for (extensionNameIndex = 0; extensionNameIndex < extensionNameCount; extensionNameIndex++) 957 | { 958 | if (vkel_strcmp(extensionNames[extensionNameIndex], pExtensionName)) 959 | { 960 | vkelDeleteDeviceExtensionNames(extensionNameCount, extensionNames); 961 | 962 | return VK_TRUE; 963 | } 964 | } 965 | 966 | vkelDeleteDeviceExtensionNames(extensionNameCount, extensionNames); 967 | 968 | return VK_FALSE; 969 | } 970 | 971 | ''') 972 | 973 | 974 | # vkelInit() 975 | 976 | f.write(br''' 977 | VkBool32 vkelInit(void) 978 | { 979 | vkelUninit(); 980 | 981 | #ifdef VK_USE_PLATFORM_WIN32_KHR 982 | const char *name = "vulkan-1.dll"; 983 | #else 984 | const char *name = "libvulkan.so.1"; 985 | #endif 986 | 987 | vkelVkLibHandle = vkelPlatformOpenLibrary(name); 988 | 989 | if (!vkelVkLibHandle) 990 | return VK_FALSE; 991 | 992 | 993 | ''') 994 | 995 | 996 | lines = [] 997 | 998 | for platform in sorted(platform_funcs): 999 | if platform: 1000 | lines.append("#ifdef " + platform) 1001 | 1002 | for func in sorted(platform_funcs[platform]): 1003 | lines.append("\t__{0} = (PFN_{0}) vkelGetProcAddr(\"{0}\");".format(func)) 1004 | 1005 | if platform: 1006 | lines.append("#endif /* " + platform + " */") 1007 | 1008 | lines.append("") 1009 | 1010 | lines.append("") 1011 | 1012 | 1013 | lines.append("\t// Instance and device extension names") 1014 | 1015 | # Are there any (instance or device) extensions? (is array empty) 1016 | if extension_names: 1017 | for extension_name in sorted(extension_names): 1018 | if extension_name: 1019 | lines.append("\tVKEL_" + extension_name + " = vkelIsInstanceExtensionSupported(NULL, \"VK_" + extension_name + "\");") 1020 | 1021 | lines.append("") 1022 | 1023 | 1024 | lines.append("\t// Instance and device layer names") 1025 | 1026 | # Are there any (instance or device) layers? (is array empty) 1027 | if layer_names: 1028 | for layer_name in sorted(layer_names): 1029 | if layer_name: 1030 | lines.append("\tVKEL_" + layer_name + " = vkelIsInstanceLayerSupported(\"VK_" + layer_name + "\");") 1031 | 1032 | lines.append("") 1033 | 1034 | 1035 | f.write("\n".join(lines).encode("utf-8")) 1036 | 1037 | 1038 | f.write(br''' 1039 | 1040 | return VK_TRUE; 1041 | } 1042 | ''') 1043 | 1044 | 1045 | # vkelInstanceInit() 1046 | 1047 | f.write(br''' 1048 | VkBool32 vkelInstanceInit(VkInstance instance) 1049 | { 1050 | if (!vkelVkLibHandle && !vkelInit()) 1051 | return VK_FALSE; 1052 | 1053 | 1054 | ''') 1055 | 1056 | 1057 | lines = [] 1058 | 1059 | for platform in sorted(platform_funcs): 1060 | if platform: 1061 | lines.append("#ifdef " + platform) 1062 | 1063 | for func in sorted(platform_funcs[platform]): 1064 | lines.append("\t__{0} = (PFN_{0}) vkelGetInstanceProcAddr(instance, \"{0}\");".format(func)) 1065 | 1066 | if platform: 1067 | lines.append("#endif /* " + platform + " */") 1068 | 1069 | lines.append("") 1070 | 1071 | lines.append("") 1072 | 1073 | 1074 | lines.append("\t// Instance and device extension names") 1075 | 1076 | # Are there any (instance or device) extensions? (is array empty) 1077 | if extension_names: 1078 | for extension_name in sorted(extension_names): 1079 | if extension_name: 1080 | lines.append("\tVKEL_" + extension_name + " = vkelIsInstanceExtensionSupported(NULL, \"VK_" + extension_name + "\");") 1081 | 1082 | lines.append("") 1083 | 1084 | 1085 | lines.append("\t// Instance and device layer names") 1086 | 1087 | # Are there any (instance or device) layers? (is array empty) 1088 | if layer_names: 1089 | for layer_name in sorted(layer_names): 1090 | if layer_name: 1091 | lines.append("\tVKEL_" + layer_name + " = vkelIsInstanceLayerSupported(\"VK_" + layer_name + "\");") 1092 | 1093 | lines.append("") 1094 | 1095 | 1096 | f.write("\n".join(lines).encode("utf-8")) 1097 | 1098 | 1099 | f.write(br''' 1100 | 1101 | return VK_TRUE; 1102 | } 1103 | ''') 1104 | 1105 | 1106 | # vkelDeviceInit() 1107 | 1108 | f.write(br''' 1109 | VkBool32 vkelDeviceInit(VkPhysicalDevice physicalDevice, VkDevice device) 1110 | { 1111 | if (!vkelVkLibHandle && !vkelInit()) 1112 | return VK_FALSE; 1113 | 1114 | 1115 | ''') 1116 | 1117 | 1118 | lines = [] 1119 | 1120 | for platform in sorted(platform_funcs): 1121 | if platform: 1122 | lines.append("#ifdef " + platform) 1123 | 1124 | for func in sorted(platform_funcs[platform]): 1125 | lines.append("\t__{0} = (PFN_{0}) vkelGetDeviceProcAddr(device, \"{0}\");".format(func)) 1126 | 1127 | if platform: 1128 | lines.append("#endif /* " + platform + " */") 1129 | 1130 | lines.append("") 1131 | 1132 | lines.append("") 1133 | 1134 | 1135 | lines.append("\t// Instance and device extension names") 1136 | 1137 | # Are there any (instance or device) extensions? (is array empty) 1138 | if extension_names: 1139 | for extension_name in sorted(extension_names): 1140 | if extension_name: 1141 | lines.append("\tVKEL_" + extension_name + " = vkelIsDeviceExtensionSupported(physicalDevice, NULL, \"VK_" + extension_name + "\");") 1142 | 1143 | lines.append("") 1144 | 1145 | 1146 | lines.append("\t// Instance and device layer names") 1147 | 1148 | # Are there any (instance or device) layers? (is array empty) 1149 | if layer_names: 1150 | for layer_name in sorted(layer_names): 1151 | if layer_name: 1152 | lines.append("\tVKEL_" + layer_name + " = vkelIsDeviceLayerSupported(physicalDevice, \"VK_" + layer_name + "\");") 1153 | 1154 | lines.append("") 1155 | 1156 | 1157 | f.write("\n".join(lines).encode("utf-8")) 1158 | 1159 | 1160 | f.write(br''' 1161 | 1162 | return VK_TRUE; 1163 | } 1164 | ''') 1165 | 1166 | 1167 | f.write(br''' 1168 | void vkelUninit(void) 1169 | { 1170 | if (vkelVkLibHandle) 1171 | { 1172 | vkelPlatformCloseLibrary(vkelVkLibHandle); 1173 | vkelVkLibHandle = NULL; 1174 | } 1175 | } 1176 | ''') 1177 | 1178 | f.write(b"\n") 1179 | 1180 | 1181 | f.write(br''' 1182 | #ifdef __cplusplus 1183 | } 1184 | #endif /* __cplusplus */''') 1185 | 1186 | 1187 | print("Done") 1188 | --------------------------------------------------------------------------------