opengl
/
Vulkan
1
0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
8 Commits
1 Branch
458 KiB
 
 
Struktur: 35e5dfbdb1
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „35e5dfbdb1“
${ noResults }
Vulkan/projects/Vulkan.pas

4813 Zeilen
266 KiB
Originalformat Blame Verlauf 

  1. { ============================================================================

  2.   This file is autogenerated from vk.xml

  3.   You may retrieve the latest version of this file at the Delphi OpenGL

  4.   Community home page, located at http://www.delphigl.com/

  5.   

  6.   The contents of this file are used with permission, subject to

  7.   the Mozilla Public License Version 1.1 (the "License"); you may

  8.   not use this file except in compliance with the License. You may

  9.   obtain a copy of the License at

  10.   http://www.mozilla.org/MPL/MPL-1.1.html

  11.   

  12.   Software distributed under the License is distributed on an

  13.   "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or

  14.   implied. See the License for the specific language governing

  15.   rights and limitations under the License.

  16. 

  17. Original vk.xml comment:

  18. ==============================================================================

  19. Copyright (c) 2015-2016 The Khronos Group Inc.

  20. 

  21. Permission is hereby granted, free of charge, to any person obtaining a

  22. copy of this software and/or associated documentation files (the

  23. "Materials"), to deal in the Materials without restriction, including

  24. without limitation the rights to use, copy, modify, merge, publish,

  25. distribute, sublicense, and/or sell copies of the Materials, and to

  26. permit persons to whom the Materials are furnished to do so, subject to

  27. the following conditions:

  28. 

  29. The above copyright notice and this permission notice shall be included

  30. in all copies or substantial portions of the Materials.

  31. 

  32. THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  33. EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  34. MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

  35. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

  36. CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

  37. TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

  38. MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

  39. 

  40. ------------------------------------------------------------------------

  41. 

  42. This file, vk.xml, is the Vulkan API Registry. It is a critically important

  43. and normative part of the Vulkan Specification, including a canonical

  44. machine-readable definition of the API, parameter and member validation

  45. language incorporated into the Specification and reference pages, and other

  46. material which is registered by Khronos, such as tags used by extension and

  47. layer authors. The only authoritative version of vk.xml is the one

  48. maintained in the master branch of the Khronos Vulkan Github project.

  49. 

  50. ============================================================================ }

  51.   

  52. unit Vulkan;

  53. 

  54. {$IFDEF FPC}

  55.   {$MODE Delphi}

  56.   {$IFNDEF WINDOWS}

  57.     {$LINKLIB c}

  58.   {$ENDIF}

  59.   {$MINENUMSIZE 4}

  60. {$ENDIF}

  61. 

  62. {$I Vulkan.inc}

  63. 

  64. interface

  65. 

  66. type

  67.   VkUint8                   = Byte;

  68.   VkUint16                  = Word;

  69.   VkUint32                  = Cardinal;

  70.   VkUint64                  = QWord;

  71.   VkInt16                   = SmallInt;

  72.   VkInt32                   = Integer;

  73.   VkInt64                   = Int64;

  74.   VkFloat                   = Single;

  75.   VkDouble                  = Double;

  76.   VkChar                    = AnsiChar;

  77.   VkSize                    = SizeUInt;

  78.   VkHandle                  = Pointer;

  79.   VkNonDispatchableHandle   = {$IFDEF VK_CPU64}Pointer{$ELSE}VkUint64{$ENDIF};

  80. 

  81. const

  82.   VK_INVALID_HANDLE:     VkHandle                = nil;

  83.   VK_INVALID_NDP_HANDLE: VkNonDispatchableHandle = {$IFDEF VK_CPU64}nil{$ELSE}0{$ENDIF};

  84. 

  85. type

  86. {$IFDEF VK_USE_PLATFORM_WIN32_KHR}

  87.   HINSTANCE = VkHandle;

  88.   HWND      = VkHandle;

  89. {$ENDIF}

  90. 

  91.   PVkVoid   = Pointer;

  92.   PVkHandle = ^VkHandle;

  93.   PVkUint8  = ^VkUint8;

  94.   PVkUint16 = ^VkUint16;

  95.   PVkUint32 = ^VkUint32;

  96.   PVkUint64 = ^VkUint64;

  97.   PVkInt16  = ^VkInt16;

  98.   PVkInt32  = ^VkInt32;

  99.   PVkInt64  = ^VkInt64;

  100.   PVkFloat  = ^VkFloat;

  101.   PVkDouble = ^VkDouble;

  102.   PVkChar   = ^VkChar;

  103.   PVkSize   = ^VkSize;

  104.   

  105.   PPVkVoid   = ^PVkVoid;

  106.   PPVkHandle = ^PVkHandle;

  107.   PPVkUint8  = ^PVkUint8;

  108.   PPVkUint16 = ^PVkUint16;

  109.   PPVkUint32 = ^PVkUint32;

  110.   PPVkUint64 = ^PVkUint64;

  111.   PPVkInt16  = ^PVkInt16;

  112.   PPVkInt32  = ^PVkInt32;

  113.   PPVkInt64  = ^PVkInt64;

  114.   PPVkFloat  = ^PVkFloat;

  115.   PPVkDouble = ^PVkDouble;

  116.   PPVkChar   = ^PVkChar;

  117.   PPVkSize   = ^PVkSize;

  118. 

  119. const

  120.   VK_API_VERSION                                                 = 4194307;

  121.   VK_API_VERSION_MAJOR                                           = 1;

  122.   VK_API_VERSION_MINOR                                           = 0;

  123.   VK_API_VERSION_BUGFIX                                          = 3;

  124. 

  125. { ========================================== VK_VERSION_1_0 ========================================== }

  126.   VK_LOD_CLAMP_NONE                                              = 1000;

  127.   VK_REMAINING_MIP_LEVELS                                        = $FFFFFFFF;

  128.   VK_REMAINING_ARRAY_LAYERS                                      = $FFFFFFFF;

  129.   VK_WHOLE_SIZE                                                  = $FFFFFFFF;

  130.   VK_ATTACHMENT_UNUSED                                           = $FFFFFFFF;

  131.   VK_TRUE                                                        = 1;

  132.   VK_FALSE                                                       = 0;

  133.   VK_QUEUE_FAMILY_IGNORED                                        = $FFFFFFFF;

  134.   VK_SUBPASS_EXTERNAL                                            = $FFFFFFFF;

  135.   VK_MAX_PHYSICAL_DEVICE_NAME_SIZE                               = 256;

  136.   VK_UUID_SIZE                                                   = 16;

  137.   VK_MAX_MEMORY_TYPES                                            = 32;

  138.   VK_MAX_MEMORY_HEAPS                                            = 16;

  139.   VK_MAX_EXTENSION_NAME_SIZE                                     = 256;

  140.   VK_MAX_DESCRIPTION_SIZE                                        = 256;

  141. 

  142. { ========================================== VK_KHR_surface ========================================== }

  143.   VK_KHR_SURFACE_SPEC_VERSION                                    = 25;

  144.   VK_KHR_SURFACE_EXTENSION_NAME                                  = 'VK_KHR_surface';

  145. 

  146. { ========================================= VK_KHR_swapchain ========================================= }

  147.   VK_KHR_SWAPCHAIN_SPEC_VERSION                                  = 67;

  148.   VK_KHR_SWAPCHAIN_EXTENSION_NAME                                = 'VK_KHR_swapchain';

  149. 

  150. { ========================================== VK_KHR_display ========================================== }

  151.   VK_KHR_DISPLAY_SPEC_VERSION                                    = 21;

  152.   VK_KHR_DISPLAY_EXTENSION_NAME                                  = 'VK_KHR_display';

  153. 

  154. { ===================================== VK_KHR_display_swapchain ===================================== }

  155.   VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION                          = 9;

  156.   VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME                        = 'VK_KHR_display_swapchain';

  157. 

  158. { ======================================= VK_KHR_xlib_surface ======================================== }

  159. {$IFDEF VK_USE_PLATFORM_XLIB_KHR}

  160.   VK_KHR_XLIB_SURFACE_SPEC_VERSION                               = 6;

  161.   VK_KHR_XLIB_SURFACE_EXTENSION_NAME                             = 'VK_KHR_xlib_surface';

  162. {$ENDIF}

  163. 

  164. { ======================================== VK_KHR_xcb_surface ======================================== }

  165. {$IFDEF VK_USE_PLATFORM_XCB_KHR}

  166.   VK_KHR_XCB_SURFACE_SPEC_VERSION                                = 6;

  167.   VK_KHR_XCB_SURFACE_EXTENSION_NAME                              = 'VK_KHR_xcb_surface';

  168. {$ENDIF}

  169. 

  170. { ====================================== VK_KHR_wayland_surface ====================================== }

  171. {$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}

  172.   VK_KHR_WAYLAND_SURFACE_SPEC_VERSION                            = 5;

  173.   VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME                          = 'VK_KHR_wayland_surface';

  174. {$ENDIF}

  175. 

  176. { ======================================== VK_KHR_mir_surface ======================================== }

  177. {$IFDEF VK_USE_PLATFORM_MIR_KHR}

  178.   VK_KHR_MIR_SURFACE_SPEC_VERSION                                = 4;

  179.   VK_KHR_MIR_SURFACE_EXTENSION_NAME                              = 'VK_KHR_mir_surface';

  180. {$ENDIF}

  181. 

  182. { ====================================== VK_KHR_android_surface ====================================== }

  183. {$IFDEF VK_USE_PLATFORM_ANDROID_KHR}

  184.   VK_KHR_ANDROID_SURFACE_SPEC_VERSION                            = 6;

  185.   VK_KHR_ANDROID_SURFACE_EXTENSION_NAME                          = 'VK_KHR_android_surface';

  186. {$ENDIF}

  187. 

  188. { ======================================= VK_KHR_win32_surface ======================================= }

  189. {$IFDEF VK_USE_PLATFORM_WIN32_KHR}

  190.   VK_KHR_WIN32_SURFACE_SPEC_VERSION                              = 5;

  191.   VK_KHR_WIN32_SURFACE_EXTENSION_NAME                            = 'VK_KHR_win32_surface';

  192. {$ENDIF}

  193. 

  194. { ======================================= VK_EXT_debug_report ======================================== }

  195.   VK_EXT_DEBUG_REPORT_SPEC_VERSION                               = 1;

  196.   VK_EXT_DEBUG_REPORT_EXTENSION_NAME                             = 'VK_EXT_debug_report';

  197. 

  198. type { simple types }

  199. 

  200. { ========================================== VK_VERSION_1_0 ========================================== }

  201.   VkFlags                                                        = VkUint32;

  202.   PVkFlags                                                       = ^VkFlags;

  203.   PPVkFlags                                                      = ^PVkFlags;

  204. 

  205.   VkInstanceCreateFlags                                          = VkFlags;

  206.   PVkInstanceCreateFlags                                         = ^VkInstanceCreateFlags;

  207.   PPVkInstanceCreateFlags                                        = ^PVkInstanceCreateFlags;

  208. 

  209.   _VkInstance                                                    = record end;

  210.   VkInstance                                                     = ^_VkInstance;

  211.   PVkInstance                                                    = ^VkInstance;

  212.   PPVkInstance                                                   = ^PVkInstance;

  213. 

  214.   _VkPhysicalDevice                                              = record end;

  215.   VkPhysicalDevice                                               = ^_VkPhysicalDevice;

  216.   PVkPhysicalDevice                                              = ^VkPhysicalDevice;

  217.   PPVkPhysicalDevice                                             = ^PVkPhysicalDevice;

  218. 

  219.   VkBool32                                                       = VkUint32;

  220.   PVkBool32                                                      = ^VkBool32;

  221.   PPVkBool32                                                     = ^PVkBool32;

  222. 

  223.   VkFormatFeatureFlags                                           = VkFlags;

  224.   PVkFormatFeatureFlags                                          = ^VkFormatFeatureFlags;

  225.   PPVkFormatFeatureFlags                                         = ^PVkFormatFeatureFlags;

  226. 

  227.   VkImageUsageFlags                                              = VkFlags;

  228.   PVkImageUsageFlags                                             = ^VkImageUsageFlags;

  229.   PPVkImageUsageFlags                                            = ^PVkImageUsageFlags;

  230. 

  231.   VkImageCreateFlags                                             = VkFlags;

  232.   PVkImageCreateFlags                                            = ^VkImageCreateFlags;

  233.   PPVkImageCreateFlags                                           = ^PVkImageCreateFlags;

  234. 

  235.   VkSampleCountFlags                                             = VkFlags;

  236.   PVkSampleCountFlags                                            = ^VkSampleCountFlags;

  237.   PPVkSampleCountFlags                                           = ^PVkSampleCountFlags;

  238. 

  239.   VkDeviceSize                                                   = VkUint64;

  240.   PVkDeviceSize                                                  = ^VkDeviceSize;

  241.   PPVkDeviceSize                                                 = ^PVkDeviceSize;

  242. 

  243.   VkQueueFlags                                                   = VkFlags;

  244.   PVkQueueFlags                                                  = ^VkQueueFlags;

  245.   PPVkQueueFlags                                                 = ^PVkQueueFlags;

  246. 

  247.   VkMemoryPropertyFlags                                          = VkFlags;

  248.   PVkMemoryPropertyFlags                                         = ^VkMemoryPropertyFlags;

  249.   PPVkMemoryPropertyFlags                                        = ^PVkMemoryPropertyFlags;

  250. 

  251.   VkMemoryHeapFlags                                              = VkFlags;

  252.   PVkMemoryHeapFlags                                             = ^VkMemoryHeapFlags;

  253.   PPVkMemoryHeapFlags                                            = ^PVkMemoryHeapFlags;

  254. 

  255.   _VkDevice                                                      = record end;

  256.   VkDevice                                                       = ^_VkDevice;

  257.   PVkDevice                                                      = ^VkDevice;

  258.   PPVkDevice                                                     = ^PVkDevice;

  259. 

  260.   VkDeviceCreateFlags                                            = VkFlags;

  261.   PVkDeviceCreateFlags                                           = ^VkDeviceCreateFlags;

  262.   PPVkDeviceCreateFlags                                          = ^PVkDeviceCreateFlags;

  263. 

  264.   VkDeviceQueueCreateFlags                                       = VkFlags;

  265.   PVkDeviceQueueCreateFlags                                      = ^VkDeviceQueueCreateFlags;

  266.   PPVkDeviceQueueCreateFlags                                     = ^PVkDeviceQueueCreateFlags;

  267. 

  268.   _VkQueue                                                       = record end;

  269.   VkQueue                                                        = ^_VkQueue;

  270.   PVkQueue                                                       = ^VkQueue;

  271.   PPVkQueue                                                      = ^PVkQueue;

  272. 

  273.   _VkSemaphore                                                   = record end;

  274.   VkSemaphore                                                    = {$IFDEF VK_CPU64}^_VkSemaphore{$ELSE}VkNonDispatchableHandle{$ENDIF};

  275.   PVkSemaphore                                                   = ^VkSemaphore;

  276.   PPVkSemaphore                                                  = ^PVkSemaphore;

  277. 

  278.   VkPipelineStageFlags                                           = VkFlags;

  279.   PVkPipelineStageFlags                                          = ^VkPipelineStageFlags;

  280.   PPVkPipelineStageFlags                                         = ^PVkPipelineStageFlags;

  281. 

  282.   _VkCommandPool                                                 = record end;

  283.   VkCommandPool                                                  = {$IFDEF VK_CPU64}^_VkCommandPool{$ELSE}VkNonDispatchableHandle{$ENDIF};

  284.   PVkCommandPool                                                 = ^VkCommandPool;

  285.   PPVkCommandPool                                                = ^PVkCommandPool;

  286. 

  287.   _VkCommandBuffer                                               = record end;

  288.   VkCommandBuffer                                                = ^_VkCommandBuffer;

  289.   PVkCommandBuffer                                               = ^VkCommandBuffer;

  290.   PPVkCommandBuffer                                              = ^PVkCommandBuffer;

  291. 

  292.   _VkFence                                                       = record end;

  293.   VkFence                                                        = {$IFDEF VK_CPU64}^_VkFence{$ELSE}VkNonDispatchableHandle{$ENDIF};

  294.   PVkFence                                                       = ^VkFence;

  295.   PPVkFence                                                      = ^PVkFence;

  296. 

  297.   _VkDeviceMemory                                                = record end;

  298.   VkDeviceMemory                                                 = {$IFDEF VK_CPU64}^_VkDeviceMemory{$ELSE}VkNonDispatchableHandle{$ENDIF};

  299.   PVkDeviceMemory                                                = ^VkDeviceMemory;

  300.   PPVkDeviceMemory                                               = ^PVkDeviceMemory;

  301. 

  302.   VkMemoryMapFlags                                               = VkFlags;

  303.   PVkMemoryMapFlags                                              = ^VkMemoryMapFlags;

  304.   PPVkMemoryMapFlags                                             = ^PVkMemoryMapFlags;

  305. 

  306.   _VkBuffer                                                      = record end;

  307.   VkBuffer                                                       = {$IFDEF VK_CPU64}^_VkBuffer{$ELSE}VkNonDispatchableHandle{$ENDIF};

  308.   PVkBuffer                                                      = ^VkBuffer;

  309.   PPVkBuffer                                                     = ^PVkBuffer;

  310. 

  311.   _VkImage                                                       = record end;

  312.   VkImage                                                        = {$IFDEF VK_CPU64}^_VkImage{$ELSE}VkNonDispatchableHandle{$ENDIF};

  313.   PVkImage                                                       = ^VkImage;

  314.   PPVkImage                                                      = ^PVkImage;

  315. 

  316.   VkImageAspectFlags                                             = VkFlags;

  317.   PVkImageAspectFlags                                            = ^VkImageAspectFlags;

  318.   PPVkImageAspectFlags                                           = ^PVkImageAspectFlags;

  319. 

  320.   VkSparseImageFormatFlags                                       = VkFlags;

  321.   PVkSparseImageFormatFlags                                      = ^VkSparseImageFormatFlags;

  322.   PPVkSparseImageFormatFlags                                     = ^PVkSparseImageFormatFlags;

  323. 

  324.   VkSparseMemoryBindFlags                                        = VkFlags;

  325.   PVkSparseMemoryBindFlags                                       = ^VkSparseMemoryBindFlags;

  326.   PPVkSparseMemoryBindFlags                                      = ^PVkSparseMemoryBindFlags;

  327. 

  328.   VkFenceCreateFlags                                             = VkFlags;

  329.   PVkFenceCreateFlags                                            = ^VkFenceCreateFlags;

  330.   PPVkFenceCreateFlags                                           = ^PVkFenceCreateFlags;

  331. 

  332.   VkSemaphoreCreateFlags                                         = VkFlags;

  333.   PVkSemaphoreCreateFlags                                        = ^VkSemaphoreCreateFlags;

  334.   PPVkSemaphoreCreateFlags                                       = ^PVkSemaphoreCreateFlags;

  335. 

  336.   VkEventCreateFlags                                             = VkFlags;

  337.   PVkEventCreateFlags                                            = ^VkEventCreateFlags;

  338.   PPVkEventCreateFlags                                           = ^PVkEventCreateFlags;

  339. 

  340.   _VkEvent                                                       = record end;

  341.   VkEvent                                                        = {$IFDEF VK_CPU64}^_VkEvent{$ELSE}VkNonDispatchableHandle{$ENDIF};

  342.   PVkEvent                                                       = ^VkEvent;

  343.   PPVkEvent                                                      = ^PVkEvent;

  344. 

  345.   VkQueryPoolCreateFlags                                         = VkFlags;

  346.   PVkQueryPoolCreateFlags                                        = ^VkQueryPoolCreateFlags;

  347.   PPVkQueryPoolCreateFlags                                       = ^PVkQueryPoolCreateFlags;

  348. 

  349.   VkQueryPipelineStatisticFlags                                  = VkFlags;

  350.   PVkQueryPipelineStatisticFlags                                 = ^VkQueryPipelineStatisticFlags;

  351.   PPVkQueryPipelineStatisticFlags                                = ^PVkQueryPipelineStatisticFlags;

  352. 

  353.   _VkQueryPool                                                   = record end;

  354.   VkQueryPool                                                    = {$IFDEF VK_CPU64}^_VkQueryPool{$ELSE}VkNonDispatchableHandle{$ENDIF};

  355.   PVkQueryPool                                                   = ^VkQueryPool;

  356.   PPVkQueryPool                                                  = ^PVkQueryPool;

  357. 

  358.   VkQueryResultFlags                                             = VkFlags;

  359.   PVkQueryResultFlags                                            = ^VkQueryResultFlags;

  360.   PPVkQueryResultFlags                                           = ^PVkQueryResultFlags;

  361. 

  362.   VkBufferCreateFlags                                            = VkFlags;

  363.   PVkBufferCreateFlags                                           = ^VkBufferCreateFlags;

  364.   PPVkBufferCreateFlags                                          = ^PVkBufferCreateFlags;

  365. 

  366.   VkBufferUsageFlags                                             = VkFlags;

  367.   PVkBufferUsageFlags                                            = ^VkBufferUsageFlags;

  368.   PPVkBufferUsageFlags                                           = ^PVkBufferUsageFlags;

  369. 

  370.   VkBufferViewCreateFlags                                        = VkFlags;

  371.   PVkBufferViewCreateFlags                                       = ^VkBufferViewCreateFlags;

  372.   PPVkBufferViewCreateFlags                                      = ^PVkBufferViewCreateFlags;

  373. 

  374.   _VkBufferView                                                  = record end;

  375.   VkBufferView                                                   = {$IFDEF VK_CPU64}^_VkBufferView{$ELSE}VkNonDispatchableHandle{$ENDIF};

  376.   PVkBufferView                                                  = ^VkBufferView;

  377.   PPVkBufferView                                                 = ^PVkBufferView;

  378. 

  379.   VkImageViewCreateFlags                                         = VkFlags;

  380.   PVkImageViewCreateFlags                                        = ^VkImageViewCreateFlags;

  381.   PPVkImageViewCreateFlags                                       = ^PVkImageViewCreateFlags;

  382. 

  383.   _VkImageView                                                   = record end;

  384.   VkImageView                                                    = {$IFDEF VK_CPU64}^_VkImageView{$ELSE}VkNonDispatchableHandle{$ENDIF};

  385.   PVkImageView                                                   = ^VkImageView;

  386.   PPVkImageView                                                  = ^PVkImageView;

  387. 

  388.   VkShaderModuleCreateFlags                                      = VkFlags;

  389.   PVkShaderModuleCreateFlags                                     = ^VkShaderModuleCreateFlags;

  390.   PPVkShaderModuleCreateFlags                                    = ^PVkShaderModuleCreateFlags;

  391. 

  392.   _VkShaderModule                                                = record end;

  393.   VkShaderModule                                                 = {$IFDEF VK_CPU64}^_VkShaderModule{$ELSE}VkNonDispatchableHandle{$ENDIF};

  394.   PVkShaderModule                                                = ^VkShaderModule;

  395.   PPVkShaderModule                                               = ^PVkShaderModule;

  396. 

  397.   VkPipelineCacheCreateFlags                                     = VkFlags;

  398.   PVkPipelineCacheCreateFlags                                    = ^VkPipelineCacheCreateFlags;

  399.   PPVkPipelineCacheCreateFlags                                   = ^PVkPipelineCacheCreateFlags;

  400. 

  401.   _VkPipelineCache                                               = record end;

  402.   VkPipelineCache                                                = {$IFDEF VK_CPU64}^_VkPipelineCache{$ELSE}VkNonDispatchableHandle{$ENDIF};

  403.   PVkPipelineCache                                               = ^VkPipelineCache;

  404.   PPVkPipelineCache                                              = ^PVkPipelineCache;

  405. 

  406.   VkPipelineCreateFlags                                          = VkFlags;

  407.   PVkPipelineCreateFlags                                         = ^VkPipelineCreateFlags;

  408.   PPVkPipelineCreateFlags                                        = ^PVkPipelineCreateFlags;

  409. 

  410.   VkPipelineShaderStageCreateFlags                               = VkFlags;

  411.   PVkPipelineShaderStageCreateFlags                              = ^VkPipelineShaderStageCreateFlags;

  412.   PPVkPipelineShaderStageCreateFlags                             = ^PVkPipelineShaderStageCreateFlags;

  413. 

  414.   VkPipelineVertexInputStateCreateFlags                          = VkFlags;

  415.   PVkPipelineVertexInputStateCreateFlags                         = ^VkPipelineVertexInputStateCreateFlags;

  416.   PPVkPipelineVertexInputStateCreateFlags                        = ^PVkPipelineVertexInputStateCreateFlags;

  417. 

  418.   VkPipelineInputAssemblyStateCreateFlags                        = VkFlags;

  419.   PVkPipelineInputAssemblyStateCreateFlags                       = ^VkPipelineInputAssemblyStateCreateFlags;

  420.   PPVkPipelineInputAssemblyStateCreateFlags                      = ^PVkPipelineInputAssemblyStateCreateFlags;

  421. 

  422.   VkPipelineTessellationStateCreateFlags                         = VkFlags;

  423.   PVkPipelineTessellationStateCreateFlags                        = ^VkPipelineTessellationStateCreateFlags;

  424.   PPVkPipelineTessellationStateCreateFlags                       = ^PVkPipelineTessellationStateCreateFlags;

  425. 

  426.   VkPipelineViewportStateCreateFlags                             = VkFlags;

  427.   PVkPipelineViewportStateCreateFlags                            = ^VkPipelineViewportStateCreateFlags;

  428.   PPVkPipelineViewportStateCreateFlags                           = ^PVkPipelineViewportStateCreateFlags;

  429. 

  430.   VkPipelineRasterizationStateCreateFlags                        = VkFlags;

  431.   PVkPipelineRasterizationStateCreateFlags                       = ^VkPipelineRasterizationStateCreateFlags;

  432.   PPVkPipelineRasterizationStateCreateFlags                      = ^PVkPipelineRasterizationStateCreateFlags;

  433. 

  434.   VkCullModeFlags                                                = VkFlags;

  435.   PVkCullModeFlags                                               = ^VkCullModeFlags;

  436.   PPVkCullModeFlags                                              = ^PVkCullModeFlags;

  437. 

  438.   VkPipelineMultisampleStateCreateFlags                          = VkFlags;

  439.   PVkPipelineMultisampleStateCreateFlags                         = ^VkPipelineMultisampleStateCreateFlags;

  440.   PPVkPipelineMultisampleStateCreateFlags                        = ^PVkPipelineMultisampleStateCreateFlags;

  441. 

  442.   VkSampleMask                                                   = VkUint32;

  443.   PVkSampleMask                                                  = ^VkSampleMask;

  444.   PPVkSampleMask                                                 = ^PVkSampleMask;

  445. 

  446.   VkPipelineDepthStencilStateCreateFlags                         = VkFlags;

  447.   PVkPipelineDepthStencilStateCreateFlags                        = ^VkPipelineDepthStencilStateCreateFlags;

  448.   PPVkPipelineDepthStencilStateCreateFlags                       = ^PVkPipelineDepthStencilStateCreateFlags;

  449. 

  450.   VkPipelineColorBlendStateCreateFlags                           = VkFlags;

  451.   PVkPipelineColorBlendStateCreateFlags                          = ^VkPipelineColorBlendStateCreateFlags;

  452.   PPVkPipelineColorBlendStateCreateFlags                         = ^PVkPipelineColorBlendStateCreateFlags;

  453. 

  454.   VkColorComponentFlags                                          = VkFlags;

  455.   PVkColorComponentFlags                                         = ^VkColorComponentFlags;

  456.   PPVkColorComponentFlags                                        = ^PVkColorComponentFlags;

  457. 

  458.   VkPipelineDynamicStateCreateFlags                              = VkFlags;

  459.   PVkPipelineDynamicStateCreateFlags                             = ^VkPipelineDynamicStateCreateFlags;

  460.   PPVkPipelineDynamicStateCreateFlags                            = ^PVkPipelineDynamicStateCreateFlags;

  461. 

  462.   _VkPipelineLayout                                              = record end;

  463.   VkPipelineLayout                                               = {$IFDEF VK_CPU64}^_VkPipelineLayout{$ELSE}VkNonDispatchableHandle{$ENDIF};

  464.   PVkPipelineLayout                                              = ^VkPipelineLayout;

  465.   PPVkPipelineLayout                                             = ^PVkPipelineLayout;

  466. 

  467.   _VkRenderPass                                                  = record end;

  468.   VkRenderPass                                                   = {$IFDEF VK_CPU64}^_VkRenderPass{$ELSE}VkNonDispatchableHandle{$ENDIF};

  469.   PVkRenderPass                                                  = ^VkRenderPass;

  470.   PPVkRenderPass                                                 = ^PVkRenderPass;

  471. 

  472.   _VkPipeline                                                    = record end;

  473.   VkPipeline                                                     = {$IFDEF VK_CPU64}^_VkPipeline{$ELSE}VkNonDispatchableHandle{$ENDIF};

  474.   PVkPipeline                                                    = ^VkPipeline;

  475.   PPVkPipeline                                                   = ^PVkPipeline;

  476. 

  477.   VkPipelineLayoutCreateFlags                                    = VkFlags;

  478.   PVkPipelineLayoutCreateFlags                                   = ^VkPipelineLayoutCreateFlags;

  479.   PPVkPipelineLayoutCreateFlags                                  = ^PVkPipelineLayoutCreateFlags;

  480. 

  481.   _VkDescriptorSetLayout                                         = record end;

  482.   VkDescriptorSetLayout                                          = {$IFDEF VK_CPU64}^_VkDescriptorSetLayout{$ELSE}VkNonDispatchableHandle{$ENDIF};

  483.   PVkDescriptorSetLayout                                         = ^VkDescriptorSetLayout;

  484.   PPVkDescriptorSetLayout                                        = ^PVkDescriptorSetLayout;

  485. 

  486.   VkShaderStageFlags                                             = VkFlags;

  487.   PVkShaderStageFlags                                            = ^VkShaderStageFlags;

  488.   PPVkShaderStageFlags                                           = ^PVkShaderStageFlags;

  489. 

  490.   VkSamplerCreateFlags                                           = VkFlags;

  491.   PVkSamplerCreateFlags                                          = ^VkSamplerCreateFlags;

  492.   PPVkSamplerCreateFlags                                         = ^PVkSamplerCreateFlags;

  493. 

  494.   _VkSampler                                                     = record end;

  495.   VkSampler                                                      = {$IFDEF VK_CPU64}^_VkSampler{$ELSE}VkNonDispatchableHandle{$ENDIF};

  496.   PVkSampler                                                     = ^VkSampler;

  497.   PPVkSampler                                                    = ^PVkSampler;

  498. 

  499.   VkDescriptorSetLayoutCreateFlags                               = VkFlags;

  500.   PVkDescriptorSetLayoutCreateFlags                              = ^VkDescriptorSetLayoutCreateFlags;

  501.   PPVkDescriptorSetLayoutCreateFlags                             = ^PVkDescriptorSetLayoutCreateFlags;

  502. 

  503.   VkDescriptorPoolCreateFlags                                    = VkFlags;

  504.   PVkDescriptorPoolCreateFlags                                   = ^VkDescriptorPoolCreateFlags;

  505.   PPVkDescriptorPoolCreateFlags                                  = ^PVkDescriptorPoolCreateFlags;

  506. 

  507.   _VkDescriptorPool                                              = record end;

  508.   VkDescriptorPool                                               = {$IFDEF VK_CPU64}^_VkDescriptorPool{$ELSE}VkNonDispatchableHandle{$ENDIF};

  509.   PVkDescriptorPool                                              = ^VkDescriptorPool;

  510.   PPVkDescriptorPool                                             = ^PVkDescriptorPool;

  511. 

  512.   VkDescriptorPoolResetFlags                                     = VkFlags;

  513.   PVkDescriptorPoolResetFlags                                    = ^VkDescriptorPoolResetFlags;

  514.   PPVkDescriptorPoolResetFlags                                   = ^PVkDescriptorPoolResetFlags;

  515. 

  516.   _VkDescriptorSet                                               = record end;

  517.   VkDescriptorSet                                                = {$IFDEF VK_CPU64}^_VkDescriptorSet{$ELSE}VkNonDispatchableHandle{$ENDIF};

  518.   PVkDescriptorSet                                               = ^VkDescriptorSet;

  519.   PPVkDescriptorSet                                              = ^PVkDescriptorSet;

  520. 

  521.   VkFramebufferCreateFlags                                       = VkFlags;

  522.   PVkFramebufferCreateFlags                                      = ^VkFramebufferCreateFlags;

  523.   PPVkFramebufferCreateFlags                                     = ^PVkFramebufferCreateFlags;

  524. 

  525.   _VkFramebuffer                                                 = record end;

  526.   VkFramebuffer                                                  = {$IFDEF VK_CPU64}^_VkFramebuffer{$ELSE}VkNonDispatchableHandle{$ENDIF};

  527.   PVkFramebuffer                                                 = ^VkFramebuffer;

  528.   PPVkFramebuffer                                                = ^PVkFramebuffer;

  529. 

  530.   VkRenderPassCreateFlags                                        = VkFlags;

  531.   PVkRenderPassCreateFlags                                       = ^VkRenderPassCreateFlags;

  532.   PPVkRenderPassCreateFlags                                      = ^PVkRenderPassCreateFlags;

  533. 

  534.   VkAttachmentDescriptionFlags                                   = VkFlags;

  535.   PVkAttachmentDescriptionFlags                                  = ^VkAttachmentDescriptionFlags;

  536.   PPVkAttachmentDescriptionFlags                                 = ^PVkAttachmentDescriptionFlags;

  537. 

  538.   VkSubpassDescriptionFlags                                      = VkFlags;

  539.   PVkSubpassDescriptionFlags                                     = ^VkSubpassDescriptionFlags;

  540.   PPVkSubpassDescriptionFlags                                    = ^PVkSubpassDescriptionFlags;

  541. 

  542.   VkAccessFlags                                                  = VkFlags;

  543.   PVkAccessFlags                                                 = ^VkAccessFlags;

  544.   PPVkAccessFlags                                                = ^PVkAccessFlags;

  545. 

  546.   VkDependencyFlags                                              = VkFlags;

  547.   PVkDependencyFlags                                             = ^VkDependencyFlags;

  548.   PPVkDependencyFlags                                            = ^PVkDependencyFlags;

  549. 

  550.   VkCommandPoolCreateFlags                                       = VkFlags;

  551.   PVkCommandPoolCreateFlags                                      = ^VkCommandPoolCreateFlags;

  552.   PPVkCommandPoolCreateFlags                                     = ^PVkCommandPoolCreateFlags;

  553. 

  554.   VkCommandPoolResetFlags                                        = VkFlags;

  555.   PVkCommandPoolResetFlags                                       = ^VkCommandPoolResetFlags;

  556.   PPVkCommandPoolResetFlags                                      = ^PVkCommandPoolResetFlags;

  557. 

  558.   VkCommandBufferUsageFlags                                      = VkFlags;

  559.   PVkCommandBufferUsageFlags                                     = ^VkCommandBufferUsageFlags;

  560.   PPVkCommandBufferUsageFlags                                    = ^PVkCommandBufferUsageFlags;

  561. 

  562.   VkQueryControlFlags                                            = VkFlags;

  563.   PVkQueryControlFlags                                           = ^VkQueryControlFlags;

  564.   PPVkQueryControlFlags                                          = ^PVkQueryControlFlags;

  565. 

  566.   VkCommandBufferResetFlags                                      = VkFlags;

  567.   PVkCommandBufferResetFlags                                     = ^VkCommandBufferResetFlags;

  568.   PPVkCommandBufferResetFlags                                    = ^PVkCommandBufferResetFlags;

  569. 

  570.   VkStencilFaceFlags                                             = VkFlags;

  571.   PVkStencilFaceFlags                                            = ^VkStencilFaceFlags;

  572.   PPVkStencilFaceFlags                                           = ^PVkStencilFaceFlags;

  573. 

  574. { ========================================== VK_KHR_surface ========================================== }

  575.   _VkSurfaceKHR                                                  = record end;

  576.   VkSurfaceKHR                                                   = {$IFDEF VK_CPU64}^_VkSurfaceKHR{$ELSE}VkNonDispatchableHandle{$ENDIF};

  577.   PVkSurfaceKHR                                                  = ^VkSurfaceKHR;

  578.   PPVkSurfaceKHR                                                 = ^PVkSurfaceKHR;

  579. 

  580.   VkSurfaceTransformFlagsKHR                                     = VkFlags;

  581.   PVkSurfaceTransformFlagsKHR                                    = ^VkSurfaceTransformFlagsKHR;

  582.   PPVkSurfaceTransformFlagsKHR                                   = ^PVkSurfaceTransformFlagsKHR;

  583. 

  584.   VkCompositeAlphaFlagsKHR                                       = VkFlags;

  585.   PVkCompositeAlphaFlagsKHR                                      = ^VkCompositeAlphaFlagsKHR;

  586.   PPVkCompositeAlphaFlagsKHR                                     = ^PVkCompositeAlphaFlagsKHR;

  587. 

  588. { ========================================= VK_KHR_swapchain ========================================= }

  589.   VkSwapchainCreateFlagsKHR                                      = VkFlags;

  590.   PVkSwapchainCreateFlagsKHR                                     = ^VkSwapchainCreateFlagsKHR;

  591.   PPVkSwapchainCreateFlagsKHR                                    = ^PVkSwapchainCreateFlagsKHR;

  592. 

  593.   _VkSwapchainKHR                                                = record end;

  594.   VkSwapchainKHR                                                 = {$IFDEF VK_CPU64}^_VkSwapchainKHR{$ELSE}VkNonDispatchableHandle{$ENDIF};

  595.   PVkSwapchainKHR                                                = ^VkSwapchainKHR;

  596.   PPVkSwapchainKHR                                               = ^PVkSwapchainKHR;

  597. 

  598. { ========================================== VK_KHR_display ========================================== }

  599.   _VkDisplayKHR                                                  = record end;

  600.   VkDisplayKHR                                                   = {$IFDEF VK_CPU64}^_VkDisplayKHR{$ELSE}VkNonDispatchableHandle{$ENDIF};

  601.   PVkDisplayKHR                                                  = ^VkDisplayKHR;

  602.   PPVkDisplayKHR                                                 = ^PVkDisplayKHR;

  603. 

  604.   _VkDisplayModeKHR                                              = record end;

  605.   VkDisplayModeKHR                                               = {$IFDEF VK_CPU64}^_VkDisplayModeKHR{$ELSE}VkNonDispatchableHandle{$ENDIF};

  606.   PVkDisplayModeKHR                                              = ^VkDisplayModeKHR;

  607.   PPVkDisplayModeKHR                                             = ^PVkDisplayModeKHR;

  608. 

  609.   VkDisplayModeCreateFlagsKHR                                    = VkFlags;

  610.   PVkDisplayModeCreateFlagsKHR                                   = ^VkDisplayModeCreateFlagsKHR;

  611.   PPVkDisplayModeCreateFlagsKHR                                  = ^PVkDisplayModeCreateFlagsKHR;

  612. 

  613.   VkDisplayPlaneAlphaFlagsKHR                                    = VkFlags;

  614.   PVkDisplayPlaneAlphaFlagsKHR                                   = ^VkDisplayPlaneAlphaFlagsKHR;

  615.   PPVkDisplayPlaneAlphaFlagsKHR                                  = ^PVkDisplayPlaneAlphaFlagsKHR;

  616. 

  617.   VkDisplaySurfaceCreateFlagsKHR                                 = VkFlags;

  618.   PVkDisplaySurfaceCreateFlagsKHR                                = ^VkDisplaySurfaceCreateFlagsKHR;

  619.   PPVkDisplaySurfaceCreateFlagsKHR                               = ^PVkDisplaySurfaceCreateFlagsKHR;

  620. 

  621. { ======================================= VK_KHR_xlib_surface ======================================== }

  622. {$IFDEF VK_USE_PLATFORM_XLIB_KHR}

  623.   VkXlibSurfaceCreateFlagsKHR                                    = VkFlags;

  624.   PVkXlibSurfaceCreateFlagsKHR                                   = ^VkXlibSurfaceCreateFlagsKHR;

  625.   PPVkXlibSurfaceCreateFlagsKHR                                  = ^PVkXlibSurfaceCreateFlagsKHR;

  626. {$ENDIF}

  627. 

  628. { ======================================== VK_KHR_xcb_surface ======================================== }

  629. {$IFDEF VK_USE_PLATFORM_XCB_KHR}

  630.   VkXcbSurfaceCreateFlagsKHR                                     = VkFlags;

  631.   PVkXcbSurfaceCreateFlagsKHR                                    = ^VkXcbSurfaceCreateFlagsKHR;

  632.   PPVkXcbSurfaceCreateFlagsKHR                                   = ^PVkXcbSurfaceCreateFlagsKHR;

  633. {$ENDIF}

  634. 

  635. { ====================================== VK_KHR_wayland_surface ====================================== }

  636. {$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}

  637.   VkWaylandSurfaceCreateFlagsKHR                                 = VkFlags;

  638.   PVkWaylandSurfaceCreateFlagsKHR                                = ^VkWaylandSurfaceCreateFlagsKHR;

  639.   PPVkWaylandSurfaceCreateFlagsKHR                               = ^PVkWaylandSurfaceCreateFlagsKHR;

  640. {$ENDIF}

  641. 

  642. { ======================================== VK_KHR_mir_surface ======================================== }

  643. {$IFDEF VK_USE_PLATFORM_MIR_KHR}

  644.   VkMirSurfaceCreateFlagsKHR                                     = VkFlags;

  645.   PVkMirSurfaceCreateFlagsKHR                                    = ^VkMirSurfaceCreateFlagsKHR;

  646.   PPVkMirSurfaceCreateFlagsKHR                                   = ^PVkMirSurfaceCreateFlagsKHR;

  647. {$ENDIF}

  648. 

  649. { ====================================== VK_KHR_android_surface ====================================== }

  650. {$IFDEF VK_USE_PLATFORM_ANDROID_KHR}

  651.   VkAndroidSurfaceCreateFlagsKHR                                 = VkFlags;

  652.   PVkAndroidSurfaceCreateFlagsKHR                                = ^VkAndroidSurfaceCreateFlagsKHR;

  653.   PPVkAndroidSurfaceCreateFlagsKHR                               = ^PVkAndroidSurfaceCreateFlagsKHR;

  654. {$ENDIF}

  655. 

  656. { ======================================= VK_KHR_win32_surface ======================================= }

  657. {$IFDEF VK_USE_PLATFORM_WIN32_KHR}

  658.   VkWin32SurfaceCreateFlagsKHR                                   = VkFlags;

  659.   PVkWin32SurfaceCreateFlagsKHR                                  = ^VkWin32SurfaceCreateFlagsKHR;

  660.   PPVkWin32SurfaceCreateFlagsKHR                                 = ^PVkWin32SurfaceCreateFlagsKHR;

  661. {$ENDIF}

  662. 

  663. { ======================================= VK_EXT_debug_report ======================================== }

  664.   VkDebugReportFlagsEXT                                          = VkFlags;

  665.   PVkDebugReportFlagsEXT                                         = ^VkDebugReportFlagsEXT;

  666.   PPVkDebugReportFlagsEXT                                        = ^PVkDebugReportFlagsEXT;

  667. 

  668.   _VkDebugReportCallbackEXT                                      = record end;

  669.   VkDebugReportCallbackEXT                                       = {$IFDEF VK_CPU64}^_VkDebugReportCallbackEXT{$ELSE}VkNonDispatchableHandle{$ENDIF};

  670.   PVkDebugReportCallbackEXT                                      = ^VkDebugReportCallbackEXT;

  671.   PPVkDebugReportCallbackEXT                                     = ^PVkDebugReportCallbackEXT;

  672. 

  673. type { enumerations }

  674. 

  675. { ========================================== VK_VERSION_1_0 ========================================== }

  676.   TVkPipelineCacheHeaderVersion = (

  677.     VK_PIPELINE_CACHE_HEADER_VERSION_ONE                         = 1,

  678.     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM                    = $7FFFFFFF

  679.   );

  680.   PVkPipelineCacheHeaderVersion = ^TVkPipelineCacheHeaderVersion;

  681.   PPVkPipelineCacheHeaderVersion = ^PVkPipelineCacheHeaderVersion;

  682. 

  683.   TVkResult = (

  684.     VK_SUCCESS                                                   = 0,

  685.     VK_NOT_READY                                                 = 1,

  686.     VK_TIMEOUT                                                   = 2,

  687.     VK_EVENT_SET                                                 = 3,

  688.     VK_EVENT_RESET                                               = 4,

  689.     VK_INCOMPLETE                                                = 5,

  690.     VK_ERROR_OUT_OF_HOST_MEMORY                                  = -1,

  691.     VK_ERROR_OUT_OF_DEVICE_MEMORY                                = -2,

  692.     VK_ERROR_INITIALIZATION_FAILED                               = -3,

  693.     VK_ERROR_DEVICE_LOST                                         = -4,

  694.     VK_ERROR_MEMORY_MAP_FAILED                                   = -5,

  695.     VK_ERROR_LAYER_NOT_PRESENT                                   = -6,

  696.     VK_ERROR_EXTENSION_NOT_PRESENT                               = -7,

  697.     VK_ERROR_FEATURE_NOT_PRESENT                                 = -8,

  698.     VK_ERROR_INCOMPATIBLE_DRIVER                                 = -9,

  699.     VK_ERROR_TOO_MANY_OBJECTS                                    = -10,

  700.     VK_ERROR_FORMAT_NOT_SUPPORTED                                = -11,

  701.     VK_ERROR_SURFACE_LOST_KHR                                    = -1000000000,

  702.     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR                            = -1000000001,

  703.     VK_SUBOPTIMAL_KHR                                            = 1000001003,

  704.     VK_ERROR_OUT_OF_DATE_KHR                                     = -1000001004,

  705.     VK_ERROR_INCOMPATIBLE_DISPLAY_KHR                            = -1000003001,

  706.     VK_ERROR_VALIDATION_FAILED_EXT                               = -1000011001,

  707.     VK_RESULT_MAX_ENUM                                           = $7FFFFFFF

  708.   );

  709.   PVkResult = ^TVkResult;

  710.   PPVkResult = ^PVkResult;

  711. 

  712.   TVkStructureType = (

  713.     VK_STRUCTURE_TYPE_APPLICATION_INFO                           = 0,

  714.     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO                       = 1,

  715.     VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO                   = 2,

  716.     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO                         = 3,

  717.     VK_STRUCTURE_TYPE_SUBMIT_INFO                                = 4,

  718.     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO                       = 5,

  719.     VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE                        = 6,

  720.     VK_STRUCTURE_TYPE_BIND_SPARSE_INFO                           = 7,

  721.     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO                          = 8,

  722.     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO                      = 9,

  723.     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO                          = 10,

  724.     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO                     = 11,

  725.     VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO                         = 12,

  726.     VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO                    = 13,

  727.     VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO                          = 14,

  728.     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO                     = 15,

  729.     VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO                  = 16,

  730.     VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO                 = 17,

  731.     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO          = 18,

  732.     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO    = 19,

  733.     VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO  = 20,

  734.     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO    = 21,

  735.     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO        = 22,

  736.     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO   = 23,

  737.     VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO     = 24,

  738.     VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO   = 25,

  739.     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO     = 26,

  740.     VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO         = 27,

  741.     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO              = 28,

  742.     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO               = 29,

  743.     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO                = 30,

  744.     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO                        = 31,

  745.     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO          = 32,

  746.     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO                = 33,

  747.     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO               = 34,

  748.     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET                       = 35,

  749.     VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET                        = 36,

  750.     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO                    = 37,

  751.     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO                    = 38,

  752.     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO                   = 39,

  753.     VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO               = 40,

  754.     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO            = 41,

  755.     VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO                  = 42,

  756.     VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO                     = 43,

  757.     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER                      = 44,

  758.     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER                       = 45,

  759.     VK_STRUCTURE_TYPE_MEMORY_BARRIER                             = 46,

  760.     VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO                = 47,

  761.     VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO                  = 48,

  762.     VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR                  = 1000001000,

  763.     VK_STRUCTURE_TYPE_PRESENT_INFO_KHR                           = 1000001001,

  764.     VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR               = 1000002000,

  765.     VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR            = 1000002001,

  766.     VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR                   = 1000003000,

  767.     VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR               = 1000004000,

  768.     VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR                = 1000005000,

  769.     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR            = 1000006000,

  770.     VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR                = 1000007000,

  771.     VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR            = 1000008000,

  772.     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR              = 1000009000,

  773.     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT               = 1000011000,

  774.     VK_STRUCTURE_TYPE_MAX_ENUM                                   = $7FFFFFFF

  775.   );

  776.   PVkStructureType = ^TVkStructureType;

  777.   PPVkStructureType = ^PVkStructureType;

  778. 

  779.   TVkSystemAllocationScope = (

  780.     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND                           = 0,

  781.     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT                            = 1,

  782.     VK_SYSTEM_ALLOCATION_SCOPE_CACHE                             = 2,

  783.     VK_SYSTEM_ALLOCATION_SCOPE_DEVICE                            = 3,

  784.     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE                          = 4,

  785.     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM                          = $7FFFFFFF

  786.   );

  787.   PVkSystemAllocationScope = ^TVkSystemAllocationScope;

  788.   PPVkSystemAllocationScope = ^PVkSystemAllocationScope;

  789. 

  790.   TVkInternalAllocationType = (

  791.     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE                       = 0,

  792.     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM                         = $7FFFFFFF

  793.   );

  794.   PVkInternalAllocationType = ^TVkInternalAllocationType;

  795.   PPVkInternalAllocationType = ^PVkInternalAllocationType;

  796. 

  797.   TVkFormat = (

  798.     VK_FORMAT_UNDEFINED                                          = 0,

  799.     VK_FORMAT_R4G4_UNORM_PACK8                                   = 1,

  800.     VK_FORMAT_R4G4B4A4_UNORM_PACK16                              = 2,

  801.     VK_FORMAT_B4G4R4A4_UNORM_PACK16                              = 3,

  802.     VK_FORMAT_R5G6B5_UNORM_PACK16                                = 4,

  803.     VK_FORMAT_B5G6R5_UNORM_PACK16                                = 5,

  804.     VK_FORMAT_R5G5B5A1_UNORM_PACK16                              = 6,

  805.     VK_FORMAT_B5G5R5A1_UNORM_PACK16                              = 7,

  806.     VK_FORMAT_A1R5G5B5_UNORM_PACK16                              = 8,

  807.     VK_FORMAT_R8_UNORM                                           = 9,

  808.     VK_FORMAT_R8_SNORM                                           = 10,

  809.     VK_FORMAT_R8_USCALED                                         = 11,

  810.     VK_FORMAT_R8_SSCALED                                         = 12,

  811.     VK_FORMAT_R8_UINT                                            = 13,

  812.     VK_FORMAT_R8_SINT                                            = 14,

  813.     VK_FORMAT_R8_SRGB                                            = 15,

  814.     VK_FORMAT_R8G8_UNORM                                         = 16,

  815.     VK_FORMAT_R8G8_SNORM                                         = 17,

  816.     VK_FORMAT_R8G8_USCALED                                       = 18,

  817.     VK_FORMAT_R8G8_SSCALED                                       = 19,

  818.     VK_FORMAT_R8G8_UINT                                          = 20,

  819.     VK_FORMAT_R8G8_SINT                                          = 21,

  820.     VK_FORMAT_R8G8_SRGB                                          = 22,

  821.     VK_FORMAT_R8G8B8_UNORM                                       = 23,

  822.     VK_FORMAT_R8G8B8_SNORM                                       = 24,

  823.     VK_FORMAT_R8G8B8_USCALED                                     = 25,

  824.     VK_FORMAT_R8G8B8_SSCALED                                     = 26,

  825.     VK_FORMAT_R8G8B8_UINT                                        = 27,

  826.     VK_FORMAT_R8G8B8_SINT                                        = 28,

  827.     VK_FORMAT_R8G8B8_SRGB                                        = 29,

  828.     VK_FORMAT_B8G8R8_UNORM                                       = 30,

  829.     VK_FORMAT_B8G8R8_SNORM                                       = 31,

  830.     VK_FORMAT_B8G8R8_USCALED                                     = 32,

  831.     VK_FORMAT_B8G8R8_SSCALED                                     = 33,

  832.     VK_FORMAT_B8G8R8_UINT                                        = 34,

  833.     VK_FORMAT_B8G8R8_SINT                                        = 35,

  834.     VK_FORMAT_B8G8R8_SRGB                                        = 36,

  835.     VK_FORMAT_R8G8B8A8_UNORM                                     = 37,

  836.     VK_FORMAT_R8G8B8A8_SNORM                                     = 38,

  837.     VK_FORMAT_R8G8B8A8_USCALED                                   = 39,

  838.     VK_FORMAT_R8G8B8A8_SSCALED                                   = 40,

  839.     VK_FORMAT_R8G8B8A8_UINT                                      = 41,

  840.     VK_FORMAT_R8G8B8A8_SINT                                      = 42,

  841.     VK_FORMAT_R8G8B8A8_SRGB                                      = 43,

  842.     VK_FORMAT_B8G8R8A8_UNORM                                     = 44,

  843.     VK_FORMAT_B8G8R8A8_SNORM                                     = 45,

  844.     VK_FORMAT_B8G8R8A8_USCALED                                   = 46,

  845.     VK_FORMAT_B8G8R8A8_SSCALED                                   = 47,

  846.     VK_FORMAT_B8G8R8A8_UINT                                      = 48,

  847.     VK_FORMAT_B8G8R8A8_SINT                                      = 49,

  848.     VK_FORMAT_B8G8R8A8_SRGB                                      = 50,

  849.     VK_FORMAT_A8B8G8R8_UNORM_PACK32                              = 51,

  850.     VK_FORMAT_A8B8G8R8_SNORM_PACK32                              = 52,

  851.     VK_FORMAT_A8B8G8R8_USCALED_PACK32                            = 53,

  852.     VK_FORMAT_A8B8G8R8_SSCALED_PACK32                            = 54,

  853.     VK_FORMAT_A8B8G8R8_UINT_PACK32                               = 55,

  854.     VK_FORMAT_A8B8G8R8_SINT_PACK32                               = 56,

  855.     VK_FORMAT_A8B8G8R8_SRGB_PACK32                               = 57,

  856.     VK_FORMAT_A2R10G10B10_UNORM_PACK32                           = 58,

  857.     VK_FORMAT_A2R10G10B10_SNORM_PACK32                           = 59,

  858.     VK_FORMAT_A2R10G10B10_USCALED_PACK32                         = 60,

  859.     VK_FORMAT_A2R10G10B10_SSCALED_PACK32                         = 61,

  860.     VK_FORMAT_A2R10G10B10_UINT_PACK32                            = 62,

  861.     VK_FORMAT_A2R10G10B10_SINT_PACK32                            = 63,

  862.     VK_FORMAT_A2B10G10R10_UNORM_PACK32                           = 64,

  863.     VK_FORMAT_A2B10G10R10_SNORM_PACK32                           = 65,

  864.     VK_FORMAT_A2B10G10R10_USCALED_PACK32                         = 66,

  865.     VK_FORMAT_A2B10G10R10_SSCALED_PACK32                         = 67,

  866.     VK_FORMAT_A2B10G10R10_UINT_PACK32                            = 68,

  867.     VK_FORMAT_A2B10G10R10_SINT_PACK32                            = 69,

  868.     VK_FORMAT_R16_UNORM                                          = 70,

  869.     VK_FORMAT_R16_SNORM                                          = 71,

  870.     VK_FORMAT_R16_USCALED                                        = 72,

  871.     VK_FORMAT_R16_SSCALED                                        = 73,

  872.     VK_FORMAT_R16_UINT                                           = 74,

  873.     VK_FORMAT_R16_SINT                                           = 75,

  874.     VK_FORMAT_R16_SFLOAT                                         = 76,

  875.     VK_FORMAT_R16G16_UNORM                                       = 77,

  876.     VK_FORMAT_R16G16_SNORM                                       = 78,

  877.     VK_FORMAT_R16G16_USCALED                                     = 79,

  878.     VK_FORMAT_R16G16_SSCALED                                     = 80,

  879.     VK_FORMAT_R16G16_UINT                                        = 81,

  880.     VK_FORMAT_R16G16_SINT                                        = 82,

  881.     VK_FORMAT_R16G16_SFLOAT                                      = 83,

  882.     VK_FORMAT_R16G16B16_UNORM                                    = 84,

  883.     VK_FORMAT_R16G16B16_SNORM                                    = 85,

  884.     VK_FORMAT_R16G16B16_USCALED                                  = 86,

  885.     VK_FORMAT_R16G16B16_SSCALED                                  = 87,

  886.     VK_FORMAT_R16G16B16_UINT                                     = 88,

  887.     VK_FORMAT_R16G16B16_SINT                                     = 89,

  888.     VK_FORMAT_R16G16B16_SFLOAT                                   = 90,

  889.     VK_FORMAT_R16G16B16A16_UNORM                                 = 91,

  890.     VK_FORMAT_R16G16B16A16_SNORM                                 = 92,

  891.     VK_FORMAT_R16G16B16A16_USCALED                               = 93,

  892.     VK_FORMAT_R16G16B16A16_SSCALED                               = 94,

  893.     VK_FORMAT_R16G16B16A16_UINT                                  = 95,

  894.     VK_FORMAT_R16G16B16A16_SINT                                  = 96,

  895.     VK_FORMAT_R16G16B16A16_SFLOAT                                = 97,

  896.     VK_FORMAT_R32_UINT                                           = 98,

  897.     VK_FORMAT_R32_SINT                                           = 99,

  898.     VK_FORMAT_R32_SFLOAT                                         = 100,

  899.     VK_FORMAT_R32G32_UINT                                        = 101,

  900.     VK_FORMAT_R32G32_SINT                                        = 102,

  901.     VK_FORMAT_R32G32_SFLOAT                                      = 103,

  902.     VK_FORMAT_R32G32B32_UINT                                     = 104,

  903.     VK_FORMAT_R32G32B32_SINT                                     = 105,

  904.     VK_FORMAT_R32G32B32_SFLOAT                                   = 106,

  905.     VK_FORMAT_R32G32B32A32_UINT                                  = 107,

  906.     VK_FORMAT_R32G32B32A32_SINT                                  = 108,

  907.     VK_FORMAT_R32G32B32A32_SFLOAT                                = 109,

  908.     VK_FORMAT_R64_UINT                                           = 110,

  909.     VK_FORMAT_R64_SINT                                           = 111,

  910.     VK_FORMAT_R64_SFLOAT                                         = 112,

  911.     VK_FORMAT_R64G64_UINT                                        = 113,

  912.     VK_FORMAT_R64G64_SINT                                        = 114,

  913.     VK_FORMAT_R64G64_SFLOAT                                      = 115,

  914.     VK_FORMAT_R64G64B64_UINT                                     = 116,

  915.     VK_FORMAT_R64G64B64_SINT                                     = 117,

  916.     VK_FORMAT_R64G64B64_SFLOAT                                   = 118,

  917.     VK_FORMAT_R64G64B64A64_UINT                                  = 119,

  918.     VK_FORMAT_R64G64B64A64_SINT                                  = 120,

  919.     VK_FORMAT_R64G64B64A64_SFLOAT                                = 121,

  920.     VK_FORMAT_B10G11R11_UFLOAT_PACK32                            = 122,

  921.     VK_FORMAT_E5B9G9R9_UFLOAT_PACK32                             = 123,

  922.     VK_FORMAT_D16_UNORM                                          = 124,

  923.     VK_FORMAT_X8_D24_UNORM_PACK32                                = 125,

  924.     VK_FORMAT_D32_SFLOAT                                         = 126,

  925.     VK_FORMAT_S8_UINT                                            = 127,

  926.     VK_FORMAT_D16_UNORM_S8_UINT                                  = 128,

  927.     VK_FORMAT_D24_UNORM_S8_UINT                                  = 129,

  928.     VK_FORMAT_D32_SFLOAT_S8_UINT                                 = 130,

  929.     VK_FORMAT_BC1_RGB_UNORM_BLOCK                                = 131,

  930.     VK_FORMAT_BC1_RGB_SRGB_BLOCK                                 = 132,

  931.     VK_FORMAT_BC1_RGBA_UNORM_BLOCK                               = 133,

  932.     VK_FORMAT_BC1_RGBA_SRGB_BLOCK                                = 134,

  933.     VK_FORMAT_BC2_UNORM_BLOCK                                    = 135,

  934.     VK_FORMAT_BC2_SRGB_BLOCK                                     = 136,

  935.     VK_FORMAT_BC3_UNORM_BLOCK                                    = 137,

  936.     VK_FORMAT_BC3_SRGB_BLOCK                                     = 138,

  937.     VK_FORMAT_BC4_UNORM_BLOCK                                    = 139,

  938.     VK_FORMAT_BC4_SNORM_BLOCK                                    = 140,

  939.     VK_FORMAT_BC5_UNORM_BLOCK                                    = 141,

  940.     VK_FORMAT_BC5_SNORM_BLOCK                                    = 142,

  941.     VK_FORMAT_BC6H_UFLOAT_BLOCK                                  = 143,

  942.     VK_FORMAT_BC6H_SFLOAT_BLOCK                                  = 144,

  943.     VK_FORMAT_BC7_UNORM_BLOCK                                    = 145,

  944.     VK_FORMAT_BC7_SRGB_BLOCK                                     = 146,

  945.     VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK                            = 147,

  946.     VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK                             = 148,

  947.     VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK                          = 149,

  948.     VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK                           = 150,

  949.     VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK                          = 151,

  950.     VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK                           = 152,

  951.     VK_FORMAT_EAC_R11_UNORM_BLOCK                                = 153,

  952.     VK_FORMAT_EAC_R11_SNORM_BLOCK                                = 154,

  953.     VK_FORMAT_EAC_R11G11_UNORM_BLOCK                             = 155,

  954.     VK_FORMAT_EAC_R11G11_SNORM_BLOCK                             = 156,

  955.     VK_FORMAT_ASTC_4x4_UNORM_BLOCK                               = 157,

  956.     VK_FORMAT_ASTC_4x4_SRGB_BLOCK                                = 158,

  957.     VK_FORMAT_ASTC_5x4_UNORM_BLOCK                               = 159,

  958.     VK_FORMAT_ASTC_5x4_SRGB_BLOCK                                = 160,

  959.     VK_FORMAT_ASTC_5x5_UNORM_BLOCK                               = 161,

  960.     VK_FORMAT_ASTC_5x5_SRGB_BLOCK                                = 162,

  961.     VK_FORMAT_ASTC_6x5_UNORM_BLOCK                               = 163,

  962.     VK_FORMAT_ASTC_6x5_SRGB_BLOCK                                = 164,

  963.     VK_FORMAT_ASTC_6x6_UNORM_BLOCK                               = 165,

  964.     VK_FORMAT_ASTC_6x6_SRGB_BLOCK                                = 166,

  965.     VK_FORMAT_ASTC_8x5_UNORM_BLOCK                               = 167,

  966.     VK_FORMAT_ASTC_8x5_SRGB_BLOCK                                = 168,

  967.     VK_FORMAT_ASTC_8x6_UNORM_BLOCK                               = 169,

  968.     VK_FORMAT_ASTC_8x6_SRGB_BLOCK                                = 170,

  969.     VK_FORMAT_ASTC_8x8_UNORM_BLOCK                               = 171,

  970.     VK_FORMAT_ASTC_8x8_SRGB_BLOCK                                = 172,

  971.     VK_FORMAT_ASTC_10x5_UNORM_BLOCK                              = 173,

  972.     VK_FORMAT_ASTC_10x5_SRGB_BLOCK                               = 174,

  973.     VK_FORMAT_ASTC_10x6_UNORM_BLOCK                              = 175,

  974.     VK_FORMAT_ASTC_10x6_SRGB_BLOCK                               = 176,

  975.     VK_FORMAT_ASTC_10x8_UNORM_BLOCK                              = 177,

  976.     VK_FORMAT_ASTC_10x8_SRGB_BLOCK                               = 178,

  977.     VK_FORMAT_ASTC_10x10_UNORM_BLOCK                             = 179,

  978.     VK_FORMAT_ASTC_10x10_SRGB_BLOCK                              = 180,

  979.     VK_FORMAT_ASTC_12x10_UNORM_BLOCK                             = 181,

  980.     VK_FORMAT_ASTC_12x10_SRGB_BLOCK                              = 182,

  981.     VK_FORMAT_ASTC_12x12_UNORM_BLOCK                             = 183,

  982.     VK_FORMAT_ASTC_12x12_SRGB_BLOCK                              = 184,

  983.     VK_FORMAT_MAX_ENUM                                           = $7FFFFFFF

  984.   );

  985.   PVkFormat = ^TVkFormat;

  986.   PPVkFormat = ^PVkFormat;

  987. 

  988.   TVkImageType = (

  989.     VK_IMAGE_TYPE_1D                                             = 0,

  990.     VK_IMAGE_TYPE_2D                                             = 1,

  991.     VK_IMAGE_TYPE_3D                                             = 2,

  992.     VK_IMAGE_TYPE_MAX_ENUM                                       = $7FFFFFFF

  993.   );

  994.   PVkImageType = ^TVkImageType;

  995.   PPVkImageType = ^PVkImageType;

  996. 

  997.   TVkImageTiling = (

  998.     VK_IMAGE_TILING_OPTIMAL                                      = 0,

  999.     VK_IMAGE_TILING_LINEAR                                       = 1,

  1000.     VK_IMAGE_TILING_MAX_ENUM                                     = $7FFFFFFF

  1001.   );

  1002.   PVkImageTiling = ^TVkImageTiling;

  1003.   PPVkImageTiling = ^PVkImageTiling;

  1004. 

  1005.   TVkPhysicalDeviceType = (

  1006.     VK_PHYSICAL_DEVICE_TYPE_OTHER                                = 0,

  1007.     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU                       = 1,

  1008.     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU                         = 2,

  1009.     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU                          = 3,

  1010.     VK_PHYSICAL_DEVICE_TYPE_CPU                                  = 4,

  1011.     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM                             = $7FFFFFFF

  1012.   );

  1013.   PVkPhysicalDeviceType = ^TVkPhysicalDeviceType;

  1014.   PPVkPhysicalDeviceType = ^PVkPhysicalDeviceType;

  1015. 

  1016.   TVkSampleCountFlagBits = (

  1017.     VK_SAMPLE_COUNT_1_BIT                                        = (1 shl 0),

  1018.     VK_SAMPLE_COUNT_2_BIT                                        = (1 shl 1),

  1019.     VK_SAMPLE_COUNT_4_BIT                                        = (1 shl 2),

  1020.     VK_SAMPLE_COUNT_8_BIT                                        = (1 shl 3),

  1021.     VK_SAMPLE_COUNT_16_BIT                                       = (1 shl 4),

  1022.     VK_SAMPLE_COUNT_32_BIT                                       = (1 shl 5),

  1023.     VK_SAMPLE_COUNT_64_BIT                                       = (1 shl 6)

  1024.   );

  1025.   PVkSampleCountFlagBits = ^TVkSampleCountFlagBits;

  1026.   PPVkSampleCountFlagBits = ^PVkSampleCountFlagBits;

  1027. 

  1028.   TVkQueryType = (

  1029.     VK_QUERY_TYPE_OCCLUSION                                      = 0,

  1030.     VK_QUERY_TYPE_PIPELINE_STATISTICS                            = 1,

  1031.     VK_QUERY_TYPE_TIMESTAMP                                      = 2,

  1032.     VK_QUERY_TYPE_MAX_ENUM                                       = $7FFFFFFF

  1033.   );

  1034.   PVkQueryType = ^TVkQueryType;

  1035.   PPVkQueryType = ^PVkQueryType;

  1036. 

  1037.   TVkSharingMode = (

  1038.     VK_SHARING_MODE_EXCLUSIVE                                    = 0,

  1039.     VK_SHARING_MODE_CONCURRENT                                   = 1,

  1040.     VK_SHARING_MODE_MAX_ENUM                                     = $7FFFFFFF

  1041.   );

  1042.   PVkSharingMode = ^TVkSharingMode;

  1043.   PPVkSharingMode = ^PVkSharingMode;

  1044. 

  1045.   TVkImageLayout = (

  1046.     VK_IMAGE_LAYOUT_UNDEFINED                                    = 0,

  1047.     VK_IMAGE_LAYOUT_GENERAL                                      = 1,

  1048.     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                     = 2,

  1049.     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL             = 3,

  1050.     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL              = 4,

  1051.     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL                     = 5,

  1052.     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL                         = 6,

  1053.     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL                         = 7,

  1054.     VK_IMAGE_LAYOUT_PREINITIALIZED                               = 8,

  1055.     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR                              = 1000001002,

  1056.     VK_IMAGE_LAYOUT_MAX_ENUM                                     = $7FFFFFFF

  1057.   );

  1058.   PVkImageLayout = ^TVkImageLayout;

  1059.   PPVkImageLayout = ^PVkImageLayout;

  1060. 

  1061.   TVkImageViewType = (

  1062.     VK_IMAGE_VIEW_TYPE_1D                                        = 0,

  1063.     VK_IMAGE_VIEW_TYPE_2D                                        = 1,

  1064.     VK_IMAGE_VIEW_TYPE_3D                                        = 2,

  1065.     VK_IMAGE_VIEW_TYPE_CUBE                                      = 3,

  1066.     VK_IMAGE_VIEW_TYPE_1D_ARRAY                                  = 4,

  1067.     VK_IMAGE_VIEW_TYPE_2D_ARRAY                                  = 5,

  1068.     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY                                = 6,

  1069.     VK_IMAGE_VIEW_TYPE_MAX_ENUM                                  = $7FFFFFFF

  1070.   );

  1071.   PVkImageViewType = ^TVkImageViewType;

  1072.   PPVkImageViewType = ^PVkImageViewType;

  1073. 

  1074.   TVkComponentSwizzle = (

  1075.     VK_COMPONENT_SWIZZLE_IDENTITY                                = 0,

  1076.     VK_COMPONENT_SWIZZLE_ZERO                                    = 1,

  1077.     VK_COMPONENT_SWIZZLE_ONE                                     = 2,

  1078.     VK_COMPONENT_SWIZZLE_R                                       = 3,

  1079.     VK_COMPONENT_SWIZZLE_G                                       = 4,

  1080.     VK_COMPONENT_SWIZZLE_B                                       = 5,

  1081.     VK_COMPONENT_SWIZZLE_A                                       = 6,

  1082.     VK_COMPONENT_SWIZZLE_MAX_ENUM                                = $7FFFFFFF

  1083.   );

  1084.   PVkComponentSwizzle = ^TVkComponentSwizzle;

  1085.   PPVkComponentSwizzle = ^PVkComponentSwizzle;

  1086. 

  1087.   TVkShaderStageFlagBits = (

  1088.     VK_SHADER_STAGE_VERTEX_BIT                                   = (1 shl 0),

  1089.     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT                     = (1 shl 1),

  1090.     VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT                  = (1 shl 2),

  1091.     VK_SHADER_STAGE_GEOMETRY_BIT                                 = (1 shl 3),

  1092.     VK_SHADER_STAGE_FRAGMENT_BIT                                 = (1 shl 4),

  1093.     VK_SHADER_STAGE_COMPUTE_BIT                                  = (1 shl 5),

  1094.     VK_SHADER_STAGE_ALL_GRAPHICS                                 = $1F,

  1095.     VK_SHADER_STAGE_ALL                                          = $7FFFFFFF

  1096.   );

  1097.   PVkShaderStageFlagBits = ^TVkShaderStageFlagBits;

  1098.   PPVkShaderStageFlagBits = ^PVkShaderStageFlagBits;

  1099. 

  1100.   TVkVertexInputRate = (

  1101.     VK_VERTEX_INPUT_RATE_VERTEX                                  = 0,

  1102.     VK_VERTEX_INPUT_RATE_INSTANCE                                = 1,

  1103.     VK_VERTEX_INPUT_RATE_MAX_ENUM                                = $7FFFFFFF

  1104.   );

  1105.   PVkVertexInputRate = ^TVkVertexInputRate;

  1106.   PPVkVertexInputRate = ^PVkVertexInputRate;

  1107. 

  1108.   TVkPrimitiveTopology = (

  1109.     VK_PRIMITIVE_TOPOLOGY_POINT_LIST                             = 0,

  1110.     VK_PRIMITIVE_TOPOLOGY_LINE_LIST                              = 1,

  1111.     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP                             = 2,

  1112.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST                          = 3,

  1113.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP                         = 4,

  1114.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN                           = 5,

  1115.     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY               = 6,

  1116.     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY              = 7,

  1117.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY           = 8,

  1118.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY          = 9,

  1119.     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST                             = 10,

  1120.     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM                               = $7FFFFFFF

  1121.   );

  1122.   PVkPrimitiveTopology = ^TVkPrimitiveTopology;

  1123.   PPVkPrimitiveTopology = ^PVkPrimitiveTopology;

  1124. 

  1125.   TVkPolygonMode = (

  1126.     VK_POLYGON_MODE_FILL                                         = 0,

  1127.     VK_POLYGON_MODE_LINE                                         = 1,

  1128.     VK_POLYGON_MODE_POINT                                        = 2,

  1129.     VK_POLYGON_MODE_MAX_ENUM                                     = $7FFFFFFF

  1130.   );

  1131.   PVkPolygonMode = ^TVkPolygonMode;

  1132.   PPVkPolygonMode = ^PVkPolygonMode;

  1133. 

  1134.   TVkFrontFace = (

  1135.     VK_FRONT_FACE_COUNTER_CLOCKWISE                              = 0,

  1136.     VK_FRONT_FACE_CLOCKWISE                                      = 1,

  1137.     VK_FRONT_FACE_MAX_ENUM                                       = $7FFFFFFF

  1138.   );

  1139.   PVkFrontFace = ^TVkFrontFace;

  1140.   PPVkFrontFace = ^PVkFrontFace;

  1141. 

  1142.   TVkCompareOp = (

  1143.     VK_COMPARE_OP_NEVER                                          = 0,

  1144.     VK_COMPARE_OP_LESS                                           = 1,

  1145.     VK_COMPARE_OP_EQUAL                                          = 2,

  1146.     VK_COMPARE_OP_LESS_OR_EQUAL                                  = 3,

  1147.     VK_COMPARE_OP_GREATER                                        = 4,

  1148.     VK_COMPARE_OP_NOT_EQUAL                                      = 5,

  1149.     VK_COMPARE_OP_GREATER_OR_EQUAL                               = 6,

  1150.     VK_COMPARE_OP_ALWAYS                                         = 7,

  1151.     VK_COMPARE_OP_MAX_ENUM                                       = $7FFFFFFF

  1152.   );

  1153.   PVkCompareOp = ^TVkCompareOp;

  1154.   PPVkCompareOp = ^PVkCompareOp;

  1155. 

  1156.   TVkStencilOp = (

  1157.     VK_STENCIL_OP_KEEP                                           = 0,

  1158.     VK_STENCIL_OP_ZERO                                           = 1,

  1159.     VK_STENCIL_OP_REPLACE                                        = 2,

  1160.     VK_STENCIL_OP_INCREMENT_AND_CLAMP                            = 3,

  1161.     VK_STENCIL_OP_DECREMENT_AND_CLAMP                            = 4,

  1162.     VK_STENCIL_OP_INVERT                                         = 5,

  1163.     VK_STENCIL_OP_INCREMENT_AND_WRAP                             = 6,

  1164.     VK_STENCIL_OP_DECREMENT_AND_WRAP                             = 7,

  1165.     VK_STENCIL_OP_MAX_ENUM                                       = $7FFFFFFF

  1166.   );

  1167.   PVkStencilOp = ^TVkStencilOp;

  1168.   PPVkStencilOp = ^PVkStencilOp;

  1169. 

  1170.   TVkLogicOp = (

  1171.     VK_LOGIC_OP_CLEAR                                            = 0,

  1172.     VK_LOGIC_OP_AND                                              = 1,

  1173.     VK_LOGIC_OP_AND_REVERSE                                      = 2,

  1174.     VK_LOGIC_OP_COPY                                             = 3,

  1175.     VK_LOGIC_OP_AND_INVERTED                                     = 4,

  1176.     VK_LOGIC_OP_NO_OP                                            = 5,

  1177.     VK_LOGIC_OP_XOR                                              = 6,

  1178.     VK_LOGIC_OP_OR                                               = 7,

  1179.     VK_LOGIC_OP_NOR                                              = 8,

  1180.     VK_LOGIC_OP_EQUIVALENT                                       = 9,

  1181.     VK_LOGIC_OP_INVERT                                           = 10,

  1182.     VK_LOGIC_OP_OR_REVERSE                                       = 11,

  1183.     VK_LOGIC_OP_COPY_INVERTED                                    = 12,

  1184.     VK_LOGIC_OP_OR_INVERTED                                      = 13,

  1185.     VK_LOGIC_OP_NAND                                             = 14,

  1186.     VK_LOGIC_OP_SET                                              = 15,

  1187.     VK_LOGIC_OP_MAX_ENUM                                         = $7FFFFFFF

  1188.   );

  1189.   PVkLogicOp = ^TVkLogicOp;

  1190.   PPVkLogicOp = ^PVkLogicOp;

  1191. 

  1192.   TVkBlendFactor = (

  1193.     VK_BLEND_FACTOR_ZERO                                         = 0,

  1194.     VK_BLEND_FACTOR_ONE                                          = 1,

  1195.     VK_BLEND_FACTOR_SRC_COLOR                                    = 2,

  1196.     VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR                          = 3,

  1197.     VK_BLEND_FACTOR_DST_COLOR                                    = 4,

  1198.     VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR                          = 5,

  1199.     VK_BLEND_FACTOR_SRC_ALPHA                                    = 6,

  1200.     VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA                          = 7,

  1201.     VK_BLEND_FACTOR_DST_ALPHA                                    = 8,

  1202.     VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA                          = 9,

  1203.     VK_BLEND_FACTOR_CONSTANT_COLOR                               = 10,

  1204.     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR                     = 11,

  1205.     VK_BLEND_FACTOR_CONSTANT_ALPHA                               = 12,

  1206.     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA                     = 13,

  1207.     VK_BLEND_FACTOR_SRC_ALPHA_SATURATE                           = 14,

  1208.     VK_BLEND_FACTOR_SRC1_COLOR                                   = 15,

  1209.     VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR                         = 16,

  1210.     VK_BLEND_FACTOR_SRC1_ALPHA                                   = 17,

  1211.     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA                         = 18,

  1212.     VK_BLEND_FACTOR_MAX_ENUM                                     = $7FFFFFFF

  1213.   );

  1214.   PVkBlendFactor = ^TVkBlendFactor;

  1215.   PPVkBlendFactor = ^PVkBlendFactor;

  1216. 

  1217.   TVkBlendOp = (

  1218.     VK_BLEND_OP_ADD                                              = 0,

  1219.     VK_BLEND_OP_SUBTRACT                                         = 1,

  1220.     VK_BLEND_OP_REVERSE_SUBTRACT                                 = 2,

  1221.     VK_BLEND_OP_MIN                                              = 3,

  1222.     VK_BLEND_OP_MAX                                              = 4,

  1223.     VK_BLEND_OP_MAX_ENUM                                         = $7FFFFFFF

  1224.   );

  1225.   PVkBlendOp = ^TVkBlendOp;

  1226.   PPVkBlendOp = ^PVkBlendOp;

  1227. 

  1228.   TVkDynamicState = (

  1229.     VK_DYNAMIC_STATE_VIEWPORT                                    = 0,

  1230.     VK_DYNAMIC_STATE_SCISSOR                                     = 1,

  1231.     VK_DYNAMIC_STATE_LINE_WIDTH                                  = 2,

  1232.     VK_DYNAMIC_STATE_DEPTH_BIAS                                  = 3,

  1233.     VK_DYNAMIC_STATE_BLEND_CONSTANTS                             = 4,

  1234.     VK_DYNAMIC_STATE_DEPTH_BOUNDS                                = 5,

  1235.     VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK                        = 6,

  1236.     VK_DYNAMIC_STATE_STENCIL_WRITE_MASK                          = 7,

  1237.     VK_DYNAMIC_STATE_STENCIL_REFERENCE                           = 8,

  1238.     VK_DYNAMIC_STATE_MAX_ENUM                                    = $7FFFFFFF

  1239.   );

  1240.   PVkDynamicState = ^TVkDynamicState;

  1241.   PPVkDynamicState = ^PVkDynamicState;

  1242. 

  1243.   TVkFilter = (

  1244.     VK_FILTER_NEAREST                                            = 0,

  1245.     VK_FILTER_LINEAR                                             = 1,

  1246.     VK_FILTER_MAX_ENUM                                           = $7FFFFFFF

  1247.   );

  1248.   PVkFilter = ^TVkFilter;

  1249.   PPVkFilter = ^PVkFilter;

  1250. 

  1251.   TVkSamplerMipmapMode = (

  1252.     VK_SAMPLER_MIPMAP_MODE_NEAREST                               = 0,

  1253.     VK_SAMPLER_MIPMAP_MODE_LINEAR                                = 1,

  1254.     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM                              = $7FFFFFFF

  1255.   );

  1256.   PVkSamplerMipmapMode = ^TVkSamplerMipmapMode;

  1257.   PPVkSamplerMipmapMode = ^PVkSamplerMipmapMode;

  1258. 

  1259.   TVkSamplerAddressMode = (

  1260.     VK_SAMPLER_ADDRESS_MODE_REPEAT                               = 0,

  1261.     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT                      = 1,

  1262.     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE                        = 2,

  1263.     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER                      = 3,

  1264.     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE                 = 4,

  1265.     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM                             = $7FFFFFFF

  1266.   );

  1267.   PVkSamplerAddressMode = ^TVkSamplerAddressMode;

  1268.   PPVkSamplerAddressMode = ^PVkSamplerAddressMode;

  1269. 

  1270.   TVkBorderColor = (

  1271.     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK                      = 0,

  1272.     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK                        = 1,

  1273.     VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK                           = 2,

  1274.     VK_BORDER_COLOR_INT_OPAQUE_BLACK                             = 3,

  1275.     VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE                           = 4,

  1276.     VK_BORDER_COLOR_INT_OPAQUE_WHITE                             = 5,

  1277.     VK_BORDER_COLOR_MAX_ENUM                                     = $7FFFFFFF

  1278.   );

  1279.   PVkBorderColor = ^TVkBorderColor;

  1280.   PPVkBorderColor = ^PVkBorderColor;

  1281. 

  1282.   TVkDescriptorType = (

  1283.     VK_DESCRIPTOR_TYPE_SAMPLER                                   = 0,

  1284.     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER                    = 1,

  1285.     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE                             = 2,

  1286.     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE                             = 3,

  1287.     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER                      = 4,

  1288.     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER                      = 5,

  1289.     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER                            = 6,

  1290.     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER                            = 7,

  1291.     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC                    = 8,

  1292.     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC                    = 9,

  1293.     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT                          = 10,

  1294.     VK_DESCRIPTOR_TYPE_MAX_ENUM                                  = $7FFFFFFF

  1295.   );

  1296.   PVkDescriptorType = ^TVkDescriptorType;

  1297.   PPVkDescriptorType = ^PVkDescriptorType;

  1298. 

  1299.   TVkAttachmentLoadOp = (

  1300.     VK_ATTACHMENT_LOAD_OP_LOAD                                   = 0,

  1301.     VK_ATTACHMENT_LOAD_OP_CLEAR                                  = 1,

  1302.     VK_ATTACHMENT_LOAD_OP_DONT_CARE                              = 2,

  1303.     VK_ATTACHMENT_LOAD_OP_MAX_ENUM                               = $7FFFFFFF

  1304.   );

  1305.   PVkAttachmentLoadOp = ^TVkAttachmentLoadOp;

  1306.   PPVkAttachmentLoadOp = ^PVkAttachmentLoadOp;

  1307. 

  1308.   TVkAttachmentStoreOp = (

  1309.     VK_ATTACHMENT_STORE_OP_STORE                                 = 0,

  1310.     VK_ATTACHMENT_STORE_OP_DONT_CARE                             = 1,

  1311.     VK_ATTACHMENT_STORE_OP_MAX_ENUM                              = $7FFFFFFF

  1312.   );

  1313.   PVkAttachmentStoreOp = ^TVkAttachmentStoreOp;

  1314.   PPVkAttachmentStoreOp = ^PVkAttachmentStoreOp;

  1315. 

  1316.   TVkPipelineBindPoint = (

  1317.     VK_PIPELINE_BIND_POINT_GRAPHICS                              = 0,

  1318.     VK_PIPELINE_BIND_POINT_COMPUTE                               = 1,

  1319.     VK_PIPELINE_BIND_POINT_MAX_ENUM                              = $7FFFFFFF

  1320.   );

  1321.   PVkPipelineBindPoint = ^TVkPipelineBindPoint;

  1322.   PPVkPipelineBindPoint = ^PVkPipelineBindPoint;

  1323. 

  1324.   TVkCommandBufferLevel = (

  1325.     VK_COMMAND_BUFFER_LEVEL_PRIMARY                              = 0,

  1326.     VK_COMMAND_BUFFER_LEVEL_SECONDARY                            = 1,

  1327.     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM                             = $7FFFFFFF

  1328.   );

  1329.   PVkCommandBufferLevel = ^TVkCommandBufferLevel;

  1330.   PPVkCommandBufferLevel = ^PVkCommandBufferLevel;

  1331. 

  1332.   TVkIndexType = (

  1333.     VK_INDEX_TYPE_UINT16                                         = 0,

  1334.     VK_INDEX_TYPE_UINT32                                         = 1,

  1335.     VK_INDEX_TYPE_MAX_ENUM                                       = $7FFFFFFF

  1336.   );

  1337.   PVkIndexType = ^TVkIndexType;

  1338.   PPVkIndexType = ^PVkIndexType;

  1339. 

  1340.   TVkPipelineStageFlagBits = (

  1341.     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT                            = (1 shl 0),

  1342.     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT                          = (1 shl 1),

  1343.     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT                           = (1 shl 2),

  1344.     VK_PIPELINE_STAGE_VERTEX_SHADER_BIT                          = (1 shl 3),

  1345.     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT            = (1 shl 4),

  1346.     VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT         = (1 shl 5),

  1347.     VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT                        = (1 shl 6),

  1348.     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT                        = (1 shl 7),

  1349.     VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT                   = (1 shl 8),

  1350.     VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT                    = (1 shl 9),

  1351.     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT                = (1 shl 10),

  1352.     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT                         = (1 shl 11),

  1353.     VK_PIPELINE_STAGE_TRANSFER_BIT                               = (1 shl 12),

  1354.     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT                         = (1 shl 13),

  1355.     VK_PIPELINE_STAGE_HOST_BIT                                   = (1 shl 14),

  1356.     VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT                           = (1 shl 15),

  1357.     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT                           = (1 shl 16)

  1358.   );

  1359.   PVkPipelineStageFlagBits = ^TVkPipelineStageFlagBits;

  1360.   PPVkPipelineStageFlagBits = ^PVkPipelineStageFlagBits;

  1361. 

  1362.   TVkSubpassContents = (

  1363.     VK_SUBPASS_CONTENTS_INLINE                                   = 0,

  1364.     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS                = 1,

  1365.     VK_SUBPASS_CONTENTS_MAX_ENUM                                 = $7FFFFFFF

  1366.   );

  1367.   PVkSubpassContents = ^TVkSubpassContents;

  1368.   PPVkSubpassContents = ^PVkSubpassContents;

  1369. 

  1370. { ========================================== VK_KHR_surface ========================================== }

  1371.   TVkSurfaceTransformFlagBitsKHR = (

  1372.     VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR                        = (1 shl 0),

  1373.     VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR                       = (1 shl 1),

  1374.     VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR                      = (1 shl 2),

  1375.     VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR                      = (1 shl 3),

  1376.     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR               = (1 shl 4),

  1377.     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR     = (1 shl 5),

  1378.     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR    = (1 shl 6),

  1379.     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR    = (1 shl 7),

  1380.     VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR                         = (1 shl 8)

  1381.   );

  1382.   PVkSurfaceTransformFlagBitsKHR = ^TVkSurfaceTransformFlagBitsKHR;

  1383.   PPVkSurfaceTransformFlagBitsKHR = ^PVkSurfaceTransformFlagBitsKHR;

  1384. 

  1385.   TVkColorSpaceKHR = (

  1386.     VK_COLORSPACE_SRGB_NONLINEAR_KHR                             = 0,

  1387.     VK_COLORSPACE_MAX_ENUM                                       = $7FFFFFFF

  1388.   );

  1389.   PVkColorSpaceKHR = ^TVkColorSpaceKHR;

  1390.   PPVkColorSpaceKHR = ^PVkColorSpaceKHR;

  1391. 

  1392.   TVkPresentModeKHR = (

  1393.     VK_PRESENT_MODE_IMMEDIATE_KHR                                = 0,

  1394.     VK_PRESENT_MODE_MAILBOX_KHR                                  = 1,

  1395.     VK_PRESENT_MODE_FIFO_KHR                                     = 2,

  1396.     VK_PRESENT_MODE_FIFO_RELAXED_KHR                             = 3,

  1397.     VK_PRESENT_MODE_MAX_ENUM                                     = $7FFFFFFF

  1398.   );

  1399.   PVkPresentModeKHR = ^TVkPresentModeKHR;

  1400.   PPVkPresentModeKHR = ^PVkPresentModeKHR;

  1401. 

  1402. { ========================================= VK_KHR_swapchain ========================================= }

  1403.   TVkCompositeAlphaFlagBitsKHR = (

  1404.     VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR                            = (1 shl 0),

  1405.     VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR                    = (1 shl 1),

  1406.     VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR                   = (1 shl 2),

  1407.     VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR                           = (1 shl 3)

  1408.   );

  1409.   PVkCompositeAlphaFlagBitsKHR = ^TVkCompositeAlphaFlagBitsKHR;

  1410.   PPVkCompositeAlphaFlagBitsKHR = ^PVkCompositeAlphaFlagBitsKHR;

  1411. 

  1412. { ========================================== VK_KHR_display ========================================== }

  1413.   TVkDisplayPlaneAlphaFlagBitsKHR = (

  1414.     VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR                        = (1 shl 0),

  1415.     VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR                        = (1 shl 1),

  1416.     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR                     = (1 shl 2),

  1417.     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR       = (1 shl 3)

  1418.   );

  1419.   PVkDisplayPlaneAlphaFlagBitsKHR = ^TVkDisplayPlaneAlphaFlagBitsKHR;

  1420.   PPVkDisplayPlaneAlphaFlagBitsKHR = ^PVkDisplayPlaneAlphaFlagBitsKHR;

  1421. 

  1422. { ======================================= VK_EXT_debug_report ======================================== }

  1423.   TVkDebugReportObjectTypeEXT = (

  1424.     VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT                      = 0,

  1425.     VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT                     = 1,

  1426.     VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT              = 2,

  1427.     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT                       = 3,

  1428.     VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT                        = 4,

  1429.     VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT                    = 5,

  1430.     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT               = 6,

  1431.     VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT                        = 7,

  1432.     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT                = 8,

  1433.     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT                       = 9,

  1434.     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT                        = 10,

  1435.     VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT                        = 11,

  1436.     VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT                   = 12,

  1437.     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT                  = 13,

  1438.     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT                   = 14,

  1439.     VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT                = 15,

  1440.     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT               = 16,

  1441.     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT              = 17,

  1442.     VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT                  = 18,

  1443.     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT                     = 19,

  1444.     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT        = 20,

  1445.     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT                      = 21,

  1446.     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT              = 22,

  1447.     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT               = 23,

  1448.     VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT                  = 24,

  1449.     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT                 = 25,

  1450.     VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT                  = 26,

  1451.     VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT                = 27,

  1452.     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT                 = 28

  1453.   );

  1454.   PVkDebugReportObjectTypeEXT = ^TVkDebugReportObjectTypeEXT;

  1455.   PPVkDebugReportObjectTypeEXT = ^PVkDebugReportObjectTypeEXT;

  1456. 

  1457.   TVkDebugReportErrorEXT = (

  1458.     VK_DEBUG_REPORT_ERROR_NONE_EXT                               = 0,

  1459.     VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT                       = 1

  1460.   );

  1461.   PVkDebugReportErrorEXT = ^TVkDebugReportErrorEXT;

  1462.   PPVkDebugReportErrorEXT = ^PVkDebugReportErrorEXT;

  1463. 

  1464. type { function pointers }

  1465. 

  1466. { ========================================== VK_VERSION_1_0 ========================================== }

  1467.   TvkAllocationFunction = function (

  1468.           pUserData:                    PVkVoid; 

  1469.           size:                         VkSize; 

  1470.           alignment:                    VkSize; 

  1471.           allocationScope:              TVkSystemAllocationScope

  1472.   ): PVkVoid; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1473. 

  1474.   TvkReallocationFunction = function (

  1475.           pUserData:                    PVkVoid; 

  1476.           pOriginal:                    PVkVoid; 

  1477.           size:                         VkSize; 

  1478.           alignment:                    VkSize; 

  1479.           allocationScope:              TVkSystemAllocationScope

  1480.   ): PVkVoid; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1481. 

  1482.   TvkFreeFunction = procedure(

  1483.           pUserData:                    PVkVoid; 

  1484.           pMemory:                      PVkVoid

  1485.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1486. 

  1487.   TvkInternalAllocationNotification = procedure(

  1488.           pUserData:                    PVkVoid; 

  1489.           size:                         VkSize; 

  1490.           allocationType:               TVkInternalAllocationType; 

  1491.           allocationScope:              TVkSystemAllocationScope

  1492.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1493. 

  1494.   TvkInternalFreeNotification = procedure(

  1495.           pUserData:                    PVkVoid; 

  1496.           size:                         VkSize; 

  1497.           allocationType:               TVkInternalAllocationType; 

  1498.           allocationScope:              TVkSystemAllocationScope

  1499.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1500. 

  1501.   TvkVoidFunction = procedure(

  1502.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1503. 

  1504. { ======================================= VK_EXT_debug_report ======================================== }

  1505.   TvkDebugReportCallbackEXT = function (

  1506.           flags:                        VkDebugReportFlagsEXT; 

  1507.           objectType:                   TVkDebugReportObjectTypeEXT; 

  1508.           uObject:                      VkUint64; 

  1509.           location:                     VkSize; 

  1510.           messageCode:                  VkInt32; 

  1511.           pLayerPrefix:                 PVkChar; 

  1512.           pMessage:                     PVkChar; 

  1513.           pUserData:                    PVkVoid

  1514.   ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1515. 

  1516. type { structures }

  1517. 

  1518. { ========================================== VK_VERSION_1_0 ========================================== }

  1519.   TVkApplicationInfo = record

  1520.     sType:                                            TVkStructureType;

  1521.     pNext:                                            PVkVoid;

  1522.     pApplicationName:                                 PVkChar;

  1523.     applicationVersion:                               VkUint32;

  1524.     pEngineName:                                      PVkChar;

  1525.     engineVersion:                                    VkUint32;

  1526.     apiVersion:                                       VkUint32;

  1527.   end;

  1528.   PVkApplicationInfo = ^TVkApplicationInfo;

  1529.   PPVkApplicationInfo = ^PVkApplicationInfo;

  1530. 

  1531.   TVkInstanceCreateInfo = record

  1532.     sType:                                            TVkStructureType;

  1533.     pNext:                                            PVkVoid;

  1534.     flags:                                            VkInstanceCreateFlags;

  1535.     pApplicationInfo:                                 PVkApplicationInfo;

  1536.     enabledLayerCount:                                VkUint32;

  1537.     ppEnabledLayerNames:                              PPVkChar;

  1538.     enabledExtensionCount:                            VkUint32;

  1539.     ppEnabledExtensionNames:                          PPVkChar;

  1540.   end;

  1541.   PVkInstanceCreateInfo = ^TVkInstanceCreateInfo;

  1542.   PPVkInstanceCreateInfo = ^PVkInstanceCreateInfo;

  1543. 

  1544.   TVkAllocationCallbacks = record

  1545.     pUserData:                                        PVkVoid;

  1546.     pfnAllocation:                                    TvkAllocationFunction;

  1547.     pfnReallocation:                                  TvkReallocationFunction;

  1548.     pfnFree:                                          TvkFreeFunction;

  1549.     pfnInternalAllocation:                            TvkInternalAllocationNotification;

  1550.     pfnInternalFree:                                  TvkInternalFreeNotification;

  1551.   end;

  1552.   PVkAllocationCallbacks = ^TVkAllocationCallbacks;

  1553.   PPVkAllocationCallbacks = ^PVkAllocationCallbacks;

  1554. 

  1555.   TVkPhysicalDeviceFeatures = record

  1556.     robustBufferAccess:                               VkBool32;

  1557.     fullDrawIndexUint32:                              VkBool32;

  1558.     imageCubeArray:                                   VkBool32;

  1559.     independentBlend:                                 VkBool32;

  1560.     geometryShader:                                   VkBool32;

  1561.     tessellationShader:                               VkBool32;

  1562.     sampleRateShading:                                VkBool32;

  1563.     dualSrcBlend:                                     VkBool32;

  1564.     logicOp:                                          VkBool32;

  1565.     multiDrawIndirect:                                VkBool32;

  1566.     drawIndirectFirstInstance:                        VkBool32;

  1567.     depthClamp:                                       VkBool32;

  1568.     depthBiasClamp:                                   VkBool32;

  1569.     fillModeNonSolid:                                 VkBool32;

  1570.     depthBounds:                                      VkBool32;

  1571.     wideLines:                                        VkBool32;

  1572.     largePoints:                                      VkBool32;

  1573.     alphaToOne:                                       VkBool32;

  1574.     multiViewport:                                    VkBool32;

  1575.     samplerAnisotropy:                                VkBool32;

  1576.     textureCompressionETC2:                           VkBool32;

  1577.     textureCompressionASTC_LDR:                       VkBool32;

  1578.     textureCompressionBC:                             VkBool32;

  1579.     occlusionQueryPrecise:                            VkBool32;

  1580.     pipelineStatisticsQuery:                          VkBool32;

  1581.     vertexPipelineStoresAndAtomics:                   VkBool32;

  1582.     fragmentStoresAndAtomics:                         VkBool32;

  1583.     shaderTessellationAndGeometryPointSize:           VkBool32;

  1584.     shaderImageGatherExtended:                        VkBool32;

  1585.     shaderStorageImageExtendedFormats:                VkBool32;

  1586.     shaderStorageImageMultisample:                    VkBool32;

  1587.     shaderStorageImageReadWithoutFormat:              VkBool32;

  1588.     shaderStorageImageWriteWithoutFormat:             VkBool32;

  1589.     shaderUniformBufferArrayDynamicIndexing:          VkBool32;

  1590.     shaderSampledImageArrayDynamicIndexing:           VkBool32;

  1591.     shaderStorageBufferArrayDynamicIndexing:          VkBool32;

  1592.     shaderStorageImageArrayDynamicIndexing:           VkBool32;

  1593.     shaderClipDistance:                               VkBool32;

  1594.     shaderCullDistance:                               VkBool32;

  1595.     shaderFloat64:                                    VkBool32;

  1596.     shaderInt64:                                      VkBool32;

  1597.     shaderInt16:                                      VkBool32;

  1598.     shaderResourceResidency:                          VkBool32;

  1599.     shaderResourceMinLod:                             VkBool32;

  1600.     sparseBinding:                                    VkBool32;

  1601.     sparseResidencyBuffer:                            VkBool32;

  1602.     sparseResidencyImage2D:                           VkBool32;

  1603.     sparseResidencyImage3D:                           VkBool32;

  1604.     sparseResidency2Samples:                          VkBool32;

  1605.     sparseResidency4Samples:                          VkBool32;

  1606.     sparseResidency8Samples:                          VkBool32;

  1607.     sparseResidency16Samples:                         VkBool32;

  1608.     sparseResidencyAliased:                           VkBool32;

  1609.     variableMultisampleRate:                          VkBool32;

  1610.     inheritedQueries:                                 VkBool32;

  1611.   end;

  1612.   PVkPhysicalDeviceFeatures = ^TVkPhysicalDeviceFeatures;

  1613.   PPVkPhysicalDeviceFeatures = ^PVkPhysicalDeviceFeatures;

  1614. 

  1615.   TVkFormatProperties = record

  1616.     linearTilingFeatures:                             VkFormatFeatureFlags;

  1617.     optimalTilingFeatures:                            VkFormatFeatureFlags;

  1618.     bufferFeatures:                                   VkFormatFeatureFlags;

  1619.   end;

  1620.   PVkFormatProperties = ^TVkFormatProperties;

  1621.   PPVkFormatProperties = ^PVkFormatProperties;

  1622. 

  1623.   TVkExtent3D = record

  1624.     width:                                            VkUint32;

  1625.     height:                                           VkUint32;

  1626.     depth:                                            VkUint32;

  1627.   end;

  1628.   PVkExtent3D = ^TVkExtent3D;

  1629.   PPVkExtent3D = ^PVkExtent3D;

  1630. 

  1631.   TVkImageFormatProperties = record

  1632.     maxExtent:                                        TVkExtent3D;

  1633.     maxMipLevels:                                     VkUint32;

  1634.     maxArrayLayers:                                   VkUint32;

  1635.     sampleCounts:                                     VkSampleCountFlags;

  1636.     maxResourceSize:                                  VkDeviceSize;

  1637.   end;

  1638.   PVkImageFormatProperties = ^TVkImageFormatProperties;

  1639.   PPVkImageFormatProperties = ^PVkImageFormatProperties;

  1640. 

  1641.   TVkPhysicalDeviceLimits = record

  1642.     maxImageDimension1D:                              VkUint32;

  1643.     maxImageDimension2D:                              VkUint32;

  1644.     maxImageDimension3D:                              VkUint32;

  1645.     maxImageDimensionCube:                            VkUint32;

  1646.     maxImageArrayLayers:                              VkUint32;

  1647.     maxTexelBufferElements:                           VkUint32;

  1648.     maxUniformBufferRange:                            VkUint32;

  1649.     maxStorageBufferRange:                            VkUint32;

  1650.     maxPushConstantsSize:                             VkUint32;

  1651.     maxMemoryAllocationCount:                         VkUint32;

  1652.     maxSamplerAllocationCount:                        VkUint32;

  1653.     bufferImageGranularity:                           VkDeviceSize;

  1654.     sparseAddressSpaceSize:                           VkDeviceSize;

  1655.     maxBoundDescriptorSets:                           VkUint32;

  1656.     maxPerStageDescriptorSamplers:                    VkUint32;

  1657.     maxPerStageDescriptorUniformBuffers:              VkUint32;

  1658.     maxPerStageDescriptorStorageBuffers:              VkUint32;

  1659.     maxPerStageDescriptorSampledImages:               VkUint32;

  1660.     maxPerStageDescriptorStorageImages:               VkUint32;

  1661.     maxPerStageDescriptorInputAttachments:            VkUint32;

  1662.     maxPerStageResources:                             VkUint32;

  1663.     maxDescriptorSetSamplers:                         VkUint32;

  1664.     maxDescriptorSetUniformBuffers:                   VkUint32;

  1665.     maxDescriptorSetUniformBuffersDynamic:            VkUint32;

  1666.     maxDescriptorSetStorageBuffers:                   VkUint32;

  1667.     maxDescriptorSetStorageBuffersDynamic:            VkUint32;

  1668.     maxDescriptorSetSampledImages:                    VkUint32;

  1669.     maxDescriptorSetStorageImages:                    VkUint32;

  1670.     maxDescriptorSetInputAttachments:                 VkUint32;

  1671.     maxVertexInputAttributes:                         VkUint32;

  1672.     maxVertexInputBindings:                           VkUint32;

  1673.     maxVertexInputAttributeOffset:                    VkUint32;

  1674.     maxVertexInputBindingStride:                      VkUint32;

  1675.     maxVertexOutputComponents:                        VkUint32;

  1676.     maxTessellationGenerationLevel:                   VkUint32;

  1677.     maxTessellationPatchSize:                         VkUint32;

  1678.     maxTessellationControlPerVertexInputComponents:   VkUint32;

  1679.     maxTessellationControlPerVertexOutputComponents:  VkUint32;

  1680.     maxTessellationControlPerPatchOutputComponents:   VkUint32;

  1681.     maxTessellationControlTotalOutputComponents:      VkUint32;

  1682.     maxTessellationEvaluationInputComponents:         VkUint32;

  1683.     maxTessellationEvaluationOutputComponents:        VkUint32;

  1684.     maxGeometryShaderInvocations:                     VkUint32;

  1685.     maxGeometryInputComponents:                       VkUint32;

  1686.     maxGeometryOutputComponents:                      VkUint32;

  1687.     maxGeometryOutputVertices:                        VkUint32;

  1688.     maxGeometryTotalOutputComponents:                 VkUint32;

  1689.     maxFragmentInputComponents:                       VkUint32;

  1690.     maxFragmentOutputAttachments:                     VkUint32;

  1691.     maxFragmentDualSrcAttachments:                    VkUint32;

  1692.     maxFragmentCombinedOutputResources:               VkUint32;

  1693.     maxComputeSharedMemorySize:                       VkUint32;

  1694.     maxComputeWorkGroupCount:                         array[0..3] of VkUint32;

  1695.     maxComputeWorkGroupInvocations:                   VkUint32;

  1696.     maxComputeWorkGroupSize:                          array[0..3] of VkUint32;

  1697.     subPixelPrecisionBits:                            VkUint32;

  1698.     subTexelPrecisionBits:                            VkUint32;

  1699.     mipmapPrecisionBits:                              VkUint32;

  1700.     maxDrawIndexedIndexValue:                         VkUint32;

  1701.     maxDrawIndirectCount:                             VkUint32;

  1702.     maxSamplerLodBias:                                VkFloat;

  1703.     maxSamplerAnisotropy:                             VkFloat;

  1704.     maxViewports:                                     VkUint32;

  1705.     maxViewportDimensions:                            array[0..2] of VkUint32;

  1706.     viewportBoundsRange:                              array[0..2] of VkFloat;

  1707.     viewportSubPixelBits:                             VkUint32;

  1708.     minMemoryMapAlignment:                            VkSize;

  1709.     minTexelBufferOffsetAlignment:                    VkDeviceSize;

  1710.     minUniformBufferOffsetAlignment:                  VkDeviceSize;

  1711.     minStorageBufferOffsetAlignment:                  VkDeviceSize;

  1712.     minTexelOffset:                                   VkInt32;

  1713.     maxTexelOffset:                                   VkUint32;

  1714.     minTexelGatherOffset:                             VkInt32;

  1715.     maxTexelGatherOffset:                             VkUint32;

  1716.     minInterpolationOffset:                           VkFloat;

  1717.     maxInterpolationOffset:                           VkFloat;

  1718.     subPixelInterpolationOffsetBits:                  VkUint32;

  1719.     maxFramebufferWidth:                              VkUint32;

  1720.     maxFramebufferHeight:                             VkUint32;

  1721.     maxFramebufferLayers:                             VkUint32;

  1722.     framebufferColorSampleCounts:                     VkSampleCountFlags;

  1723.     framebufferDepthSampleCounts:                     VkSampleCountFlags;

  1724.     framebufferStencilSampleCounts:                   VkSampleCountFlags;

  1725.     framebufferNoAttachmentsSampleCounts:             VkSampleCountFlags;

  1726.     maxColorAttachments:                              VkUint32;

  1727.     sampledImageColorSampleCounts:                    VkSampleCountFlags;

  1728.     sampledImageIntegerSampleCounts:                  VkSampleCountFlags;

  1729.     sampledImageDepthSampleCounts:                    VkSampleCountFlags;

  1730.     sampledImageStencilSampleCounts:                  VkSampleCountFlags;

  1731.     storageImageSampleCounts:                         VkSampleCountFlags;

  1732.     maxSampleMaskWords:                               VkUint32;

  1733.     timestampComputeAndGraphics:                      VkBool32;

  1734.     timestampPeriod:                                  VkFloat;

  1735.     maxClipDistances:                                 VkUint32;

  1736.     maxCullDistances:                                 VkUint32;

  1737.     maxCombinedClipAndCullDistances:                  VkUint32;

  1738.     discreteQueuePriorities:                          VkUint32;

  1739.     pointSizeRange:                                   array[0..2] of VkFloat;

  1740.     lineWidthRange:                                   array[0..2] of VkFloat;

  1741.     pointSizeGranularity:                             VkFloat;

  1742.     lineWidthGranularity:                             VkFloat;

  1743.     strictLines:                                      VkBool32;

  1744.     standardSampleLocations:                          VkBool32;

  1745.     optimalBufferCopyOffsetAlignment:                 VkDeviceSize;

  1746.     optimalBufferCopyRowPitchAlignment:               VkDeviceSize;

  1747.     nonCoherentAtomSize:                              VkDeviceSize;

  1748.   end;

  1749.   PVkPhysicalDeviceLimits = ^TVkPhysicalDeviceLimits;

  1750.   PPVkPhysicalDeviceLimits = ^PVkPhysicalDeviceLimits;

  1751. 

  1752.   TVkPhysicalDeviceSparseProperties = record

  1753.     residencyStandard2DBlockShape:                    VkBool32;

  1754.     residencyStandard2DMultisampleBlockShape:         VkBool32;

  1755.     residencyStandard3DBlockShape:                    VkBool32;

  1756.     residencyAlignedMipSize:                          VkBool32;

  1757.     residencyNonResidentStrict:                       VkBool32;

  1758.   end;

  1759.   PVkPhysicalDeviceSparseProperties = ^TVkPhysicalDeviceSparseProperties;

  1760.   PPVkPhysicalDeviceSparseProperties = ^PVkPhysicalDeviceSparseProperties;

  1761. 

  1762.   TVkPhysicalDeviceProperties = record

  1763.     apiVersion:                                       VkUint32;

  1764.     driverVersion:                                    VkUint32;

  1765.     vendorID:                                         VkUint32;

  1766.     deviceID:                                         VkUint32;

  1767.     deviceType:                                       TVkPhysicalDeviceType;

  1768.     deviceName:                                       array[0..VK_MAX_PHYSICAL_DEVICE_NAME_SIZE-1] of VkChar;

  1769.     pipelineCacheUUID:                                array[0..VK_UUID_SIZE-1] of VkUint8;

  1770.     limits:                                           TVkPhysicalDeviceLimits;

  1771.     sparseProperties:                                 TVkPhysicalDeviceSparseProperties;

  1772.   end;

  1773.   PVkPhysicalDeviceProperties = ^TVkPhysicalDeviceProperties;

  1774.   PPVkPhysicalDeviceProperties = ^PVkPhysicalDeviceProperties;

  1775. 

  1776.   TVkQueueFamilyProperties = record

  1777.     queueFlags:                                       VkQueueFlags;

  1778.     queueCount:                                       VkUint32;

  1779.     timestampValidBits:                               VkUint32;

  1780.     minImageTransferGranularity:                      TVkExtent3D;

  1781.   end;

  1782.   PVkQueueFamilyProperties = ^TVkQueueFamilyProperties;

  1783.   PPVkQueueFamilyProperties = ^PVkQueueFamilyProperties;

  1784. 

  1785.   TVkMemoryType = record

  1786.     propertyFlags:                                    VkMemoryPropertyFlags;

  1787.     heapIndex:                                        VkUint32;

  1788.   end;

  1789.   PVkMemoryType = ^TVkMemoryType;

  1790.   PPVkMemoryType = ^PVkMemoryType;

  1791. 

  1792.   TVkMemoryHeap = record

  1793.     size:                                             VkDeviceSize;

  1794.     flags:                                            VkMemoryHeapFlags;

  1795.   end;

  1796.   PVkMemoryHeap = ^TVkMemoryHeap;

  1797.   PPVkMemoryHeap = ^PVkMemoryHeap;

  1798. 

  1799.   TVkPhysicalDeviceMemoryProperties = record

  1800.     memoryTypeCount:                                  VkUint32;

  1801.     memoryTypes:                                      array[0..VK_MAX_MEMORY_TYPES-1] of TVkMemoryType;

  1802.     memoryHeapCount:                                  VkUint32;

  1803.     memoryHeaps:                                      array[0..VK_MAX_MEMORY_HEAPS-1] of TVkMemoryHeap;

  1804.   end;

  1805.   PVkPhysicalDeviceMemoryProperties = ^TVkPhysicalDeviceMemoryProperties;

  1806.   PPVkPhysicalDeviceMemoryProperties = ^PVkPhysicalDeviceMemoryProperties;

  1807. 

  1808.   TVkDeviceQueueCreateInfo = record

  1809.     sType:                                            TVkStructureType;

  1810.     pNext:                                            PVkVoid;

  1811.     flags:                                            VkDeviceQueueCreateFlags;

  1812.     queueFamilyIndex:                                 VkUint32;

  1813.     queueCount:                                       VkUint32;

  1814.     pQueuePriorities:                                 PVkFloat;

  1815.   end;

  1816.   PVkDeviceQueueCreateInfo = ^TVkDeviceQueueCreateInfo;

  1817.   PPVkDeviceQueueCreateInfo = ^PVkDeviceQueueCreateInfo;

  1818. 

  1819.   TVkDeviceCreateInfo = record

  1820.     sType:                                            TVkStructureType;

  1821.     pNext:                                            PVkVoid;

  1822.     flags:                                            VkDeviceCreateFlags;

  1823.     queueCreateInfoCount:                             VkUint32;

  1824.     pQueueCreateInfos:                                PVkDeviceQueueCreateInfo;

  1825.     enabledLayerCount:                                VkUint32;

  1826.     ppEnabledLayerNames:                              PPVkChar;

  1827.     enabledExtensionCount:                            VkUint32;

  1828.     ppEnabledExtensionNames:                          PPVkChar;

  1829.     pEnabledFeatures:                                 PVkPhysicalDeviceFeatures;

  1830.   end;

  1831.   PVkDeviceCreateInfo = ^TVkDeviceCreateInfo;

  1832.   PPVkDeviceCreateInfo = ^PVkDeviceCreateInfo;

  1833. 

  1834.   TVkExtensionProperties = record

  1835.     extensionName:                                    array[0..VK_MAX_EXTENSION_NAME_SIZE-1] of VkChar;

  1836.     specVersion:                                      VkUint32;

  1837.   end;

  1838.   PVkExtensionProperties = ^TVkExtensionProperties;

  1839.   PPVkExtensionProperties = ^PVkExtensionProperties;

  1840. 

  1841.   TVkLayerProperties = record

  1842.     layerName:                                        array[0..VK_MAX_EXTENSION_NAME_SIZE-1] of VkChar;

  1843.     specVersion:                                      VkUint32;

  1844.     implementationVersion:                            VkUint32;

  1845.     description:                                      array[0..VK_MAX_DESCRIPTION_SIZE-1] of VkChar;

  1846.   end;

  1847.   PVkLayerProperties = ^TVkLayerProperties;

  1848.   PPVkLayerProperties = ^PVkLayerProperties;

  1849. 

  1850.   TVkSubmitInfo = record

  1851.     sType:                                            TVkStructureType;

  1852.     pNext:                                            PVkVoid;

  1853.     waitSemaphoreCount:                               VkUint32;

  1854.     pWaitSemaphores:                                  PVkSemaphore;

  1855.     pWaitDstStageMask:                                PVkPipelineStageFlags;

  1856.     commandBufferCount:                               VkUint32;

  1857.     pCommandBuffers:                                  PVkCommandBuffer;

  1858.     signalSemaphoreCount:                             VkUint32;

  1859.     pSignalSemaphores:                                PVkSemaphore;

  1860.   end;

  1861.   PVkSubmitInfo = ^TVkSubmitInfo;

  1862.   PPVkSubmitInfo = ^PVkSubmitInfo;

  1863. 

  1864.   TVkMemoryAllocateInfo = record

  1865.     sType:                                            TVkStructureType;

  1866.     pNext:                                            PVkVoid;

  1867.     allocationSize:                                   VkDeviceSize;

  1868.     memoryTypeIndex:                                  VkUint32;

  1869.   end;

  1870.   PVkMemoryAllocateInfo = ^TVkMemoryAllocateInfo;

  1871.   PPVkMemoryAllocateInfo = ^PVkMemoryAllocateInfo;

  1872. 

  1873.   TVkMappedMemoryRange = record

  1874.     sType:                                            TVkStructureType;

  1875.     pNext:                                            PVkVoid;

  1876.     memory:                                           VkDeviceMemory;

  1877.     offset:                                           VkDeviceSize;

  1878.     size:                                             VkDeviceSize;

  1879.   end;

  1880.   PVkMappedMemoryRange = ^TVkMappedMemoryRange;

  1881.   PPVkMappedMemoryRange = ^PVkMappedMemoryRange;

  1882. 

  1883.   TVkMemoryRequirements = record

  1884.     size:                                             VkDeviceSize;

  1885.     alignment:                                        VkDeviceSize;

  1886.     memoryTypeBits:                                   VkUint32;

  1887.   end;

  1888.   PVkMemoryRequirements = ^TVkMemoryRequirements;

  1889.   PPVkMemoryRequirements = ^PVkMemoryRequirements;

  1890. 

  1891.   TVkSparseImageFormatProperties = record

  1892.     aspectMask:                                       VkImageAspectFlags;

  1893.     imageGranularity:                                 TVkExtent3D;

  1894.     flags:                                            VkSparseImageFormatFlags;

  1895.   end;

  1896.   PVkSparseImageFormatProperties = ^TVkSparseImageFormatProperties;

  1897.   PPVkSparseImageFormatProperties = ^PVkSparseImageFormatProperties;

  1898. 

  1899.   TVkSparseImageMemoryRequirements = record

  1900.     formatProperties:                                 TVkSparseImageFormatProperties;

  1901.     imageMipTailFirstLod:                             VkUint32;

  1902.     imageMipTailSize:                                 VkDeviceSize;

  1903.     imageMipTailOffset:                               VkDeviceSize;

  1904.     imageMipTailStride:                               VkDeviceSize;

  1905.   end;

  1906.   PVkSparseImageMemoryRequirements = ^TVkSparseImageMemoryRequirements;

  1907.   PPVkSparseImageMemoryRequirements = ^PVkSparseImageMemoryRequirements;

  1908. 

  1909.   TVkSparseMemoryBind = record

  1910.     resourceOffset:                                   VkDeviceSize;

  1911.     size:                                             VkDeviceSize;

  1912.     memory:                                           VkDeviceMemory;

  1913.     memoryOffset:                                     VkDeviceSize;

  1914.     flags:                                            VkSparseMemoryBindFlags;

  1915.   end;

  1916.   PVkSparseMemoryBind = ^TVkSparseMemoryBind;

  1917.   PPVkSparseMemoryBind = ^PVkSparseMemoryBind;

  1918. 

  1919.   TVkSparseBufferMemoryBindInfo = record

  1920.     buffer:                                           VkBuffer;

  1921.     bindCount:                                        VkUint32;

  1922.     pBinds:                                           PVkSparseMemoryBind;

  1923.   end;

  1924.   PVkSparseBufferMemoryBindInfo = ^TVkSparseBufferMemoryBindInfo;

  1925.   PPVkSparseBufferMemoryBindInfo = ^PVkSparseBufferMemoryBindInfo;

  1926. 

  1927.   TVkSparseImageOpaqueMemoryBindInfo = record

  1928.     image:                                            VkImage;

  1929.     bindCount:                                        VkUint32;

  1930.     pBinds:                                           PVkSparseMemoryBind;

  1931.   end;

  1932.   PVkSparseImageOpaqueMemoryBindInfo = ^TVkSparseImageOpaqueMemoryBindInfo;

  1933.   PPVkSparseImageOpaqueMemoryBindInfo = ^PVkSparseImageOpaqueMemoryBindInfo;

  1934. 

  1935.   TVkImageSubresource = record

  1936.     aspectMask:                                       VkImageAspectFlags;

  1937.     mipLevel:                                         VkUint32;

  1938.     arrayLayer:                                       VkUint32;

  1939.   end;

  1940.   PVkImageSubresource = ^TVkImageSubresource;

  1941.   PPVkImageSubresource = ^PVkImageSubresource;

  1942. 

  1943.   TVkOffset3D = record

  1944.     x:                                                VkInt32;

  1945.     y:                                                VkInt32;

  1946.     z:                                                VkInt32;

  1947.   end;

  1948.   PVkOffset3D = ^TVkOffset3D;

  1949.   PPVkOffset3D = ^PVkOffset3D;

  1950. 

  1951.   TVkSparseImageMemoryBind = record

  1952.     subresource:                                      TVkImageSubresource;

  1953.     offset:                                           TVkOffset3D;

  1954.     extent:                                           TVkExtent3D;

  1955.     memory:                                           VkDeviceMemory;

  1956.     memoryOffset:                                     VkDeviceSize;

  1957.     flags:                                            VkSparseMemoryBindFlags;

  1958.   end;

  1959.   PVkSparseImageMemoryBind = ^TVkSparseImageMemoryBind;

  1960.   PPVkSparseImageMemoryBind = ^PVkSparseImageMemoryBind;

  1961. 

  1962.   TVkSparseImageMemoryBindInfo = record

  1963.     image:                                            VkImage;

  1964.     bindCount:                                        VkUint32;

  1965.     pBinds:                                           PVkSparseImageMemoryBind;

  1966.   end;

  1967.   PVkSparseImageMemoryBindInfo = ^TVkSparseImageMemoryBindInfo;

  1968.   PPVkSparseImageMemoryBindInfo = ^PVkSparseImageMemoryBindInfo;

  1969. 

  1970.   TVkBindSparseInfo = record

  1971.     sType:                                            TVkStructureType;

  1972.     pNext:                                            PVkVoid;

  1973.     waitSemaphoreCount:                               VkUint32;

  1974.     pWaitSemaphores:                                  PVkSemaphore;

  1975.     bufferBindCount:                                  VkUint32;

  1976.     pBufferBinds:                                     PVkSparseBufferMemoryBindInfo;

  1977.     imageOpaqueBindCount:                             VkUint32;

  1978.     pImageOpaqueBinds:                                PVkSparseImageOpaqueMemoryBindInfo;

  1979.     imageBindCount:                                   VkUint32;

  1980.     pImageBinds:                                      PVkSparseImageMemoryBindInfo;

  1981.     signalSemaphoreCount:                             VkUint32;

  1982.     pSignalSemaphores:                                PVkSemaphore;

  1983.   end;

  1984.   PVkBindSparseInfo = ^TVkBindSparseInfo;

  1985.   PPVkBindSparseInfo = ^PVkBindSparseInfo;

  1986. 

  1987.   TVkFenceCreateInfo = record

  1988.     sType:                                            TVkStructureType;

  1989.     pNext:                                            PVkVoid;

  1990.     flags:                                            VkFenceCreateFlags;

  1991.   end;

  1992.   PVkFenceCreateInfo = ^TVkFenceCreateInfo;

  1993.   PPVkFenceCreateInfo = ^PVkFenceCreateInfo;

  1994. 

  1995.   TVkSemaphoreCreateInfo = record

  1996.     sType:                                            TVkStructureType;

  1997.     pNext:                                            PVkVoid;

  1998.     flags:                                            VkSemaphoreCreateFlags;

  1999.   end;

  2000.   PVkSemaphoreCreateInfo = ^TVkSemaphoreCreateInfo;

  2001.   PPVkSemaphoreCreateInfo = ^PVkSemaphoreCreateInfo;

  2002. 

  2003.   TVkEventCreateInfo = record

  2004.     sType:                                            TVkStructureType;

  2005.     pNext:                                            PVkVoid;

  2006.     flags:                                            VkEventCreateFlags;

  2007.   end;

  2008.   PVkEventCreateInfo = ^TVkEventCreateInfo;

  2009.   PPVkEventCreateInfo = ^PVkEventCreateInfo;

  2010. 

  2011.   TVkQueryPoolCreateInfo = record

  2012.     sType:                                            TVkStructureType;

  2013.     pNext:                                            PVkVoid;

  2014.     flags:                                            VkQueryPoolCreateFlags;

  2015.     queryType:                                        TVkQueryType;

  2016.     queryCount:                                       VkUint32;

  2017.     pipelineStatistics:                               VkQueryPipelineStatisticFlags;

  2018.   end;

  2019.   PVkQueryPoolCreateInfo = ^TVkQueryPoolCreateInfo;

  2020.   PPVkQueryPoolCreateInfo = ^PVkQueryPoolCreateInfo;

  2021. 

  2022.   TVkBufferCreateInfo = record

  2023.     sType:                                            TVkStructureType;

  2024.     pNext:                                            PVkVoid;

  2025.     flags:                                            VkBufferCreateFlags;

  2026.     size:                                             VkDeviceSize;

  2027.     usage:                                            VkBufferUsageFlags;

  2028.     sharingMode:                                      TVkSharingMode;

  2029.     queueFamilyIndexCount:                            VkUint32;

  2030.     pQueueFamilyIndices:                              PVkUint32;

  2031.   end;

  2032.   PVkBufferCreateInfo = ^TVkBufferCreateInfo;

  2033.   PPVkBufferCreateInfo = ^PVkBufferCreateInfo;

  2034. 

  2035.   TVkBufferViewCreateInfo = record

  2036.     sType:                                            TVkStructureType;

  2037.     pNext:                                            PVkVoid;

  2038.     flags:                                            VkBufferViewCreateFlags;

  2039.     buffer:                                           VkBuffer;

  2040.     format:                                           TVkFormat;

  2041.     offset:                                           VkDeviceSize;

  2042.     range:                                            VkDeviceSize;

  2043.   end;

  2044.   PVkBufferViewCreateInfo = ^TVkBufferViewCreateInfo;

  2045.   PPVkBufferViewCreateInfo = ^PVkBufferViewCreateInfo;

  2046. 

  2047.   TVkImageCreateInfo = record

  2048.     sType:                                            TVkStructureType;

  2049.     pNext:                                            PVkVoid;

  2050.     flags:                                            VkImageCreateFlags;

  2051.     imageType:                                        TVkImageType;

  2052.     format:                                           TVkFormat;

  2053.     extent:                                           TVkExtent3D;

  2054.     mipLevels:                                        VkUint32;

  2055.     arrayLayers:                                      VkUint32;

  2056.     samples:                                          TVkSampleCountFlagBits;

  2057.     tiling:                                           TVkImageTiling;

  2058.     usage:                                            VkImageUsageFlags;

  2059.     sharingMode:                                      TVkSharingMode;

  2060.     queueFamilyIndexCount:                            VkUint32;

  2061.     pQueueFamilyIndices:                              PVkUint32;

  2062.     initialLayout:                                    TVkImageLayout;

  2063.   end;

  2064.   PVkImageCreateInfo = ^TVkImageCreateInfo;

  2065.   PPVkImageCreateInfo = ^PVkImageCreateInfo;

  2066. 

  2067.   TVkSubresourceLayout = record

  2068.     offset:                                           VkDeviceSize;

  2069.     size:                                             VkDeviceSize;

  2070.     rowPitch:                                         VkDeviceSize;

  2071.     arrayPitch:                                       VkDeviceSize;

  2072.     depthPitch:                                       VkDeviceSize;

  2073.   end;

  2074.   PVkSubresourceLayout = ^TVkSubresourceLayout;

  2075.   PPVkSubresourceLayout = ^PVkSubresourceLayout;

  2076. 

  2077.   TVkComponentMapping = record

  2078.     r:                                                TVkComponentSwizzle;

  2079.     g:                                                TVkComponentSwizzle;

  2080.     b:                                                TVkComponentSwizzle;

  2081.     a:                                                TVkComponentSwizzle;

  2082.   end;

  2083.   PVkComponentMapping = ^TVkComponentMapping;

  2084.   PPVkComponentMapping = ^PVkComponentMapping;

  2085. 

  2086.   TVkImageSubresourceRange = record

  2087.     aspectMask:                                       VkImageAspectFlags;

  2088.     baseMipLevel:                                     VkUint32;

  2089.     levelCount:                                       VkUint32;

  2090.     baseArrayLayer:                                   VkUint32;

  2091.     layerCount:                                       VkUint32;

  2092.   end;

  2093.   PVkImageSubresourceRange = ^TVkImageSubresourceRange;

  2094.   PPVkImageSubresourceRange = ^PVkImageSubresourceRange;

  2095. 

  2096.   TVkImageViewCreateInfo = record

  2097.     sType:                                            TVkStructureType;

  2098.     pNext:                                            PVkVoid;

  2099.     flags:                                            VkImageViewCreateFlags;

  2100.     image:                                            VkImage;

  2101.     viewType:                                         TVkImageViewType;

  2102.     format:                                           TVkFormat;

  2103.     components:                                       TVkComponentMapping;

  2104.     subresourceRange:                                 TVkImageSubresourceRange;

  2105.   end;

  2106.   PVkImageViewCreateInfo = ^TVkImageViewCreateInfo;

  2107.   PPVkImageViewCreateInfo = ^PVkImageViewCreateInfo;

  2108. 

  2109.   TVkShaderModuleCreateInfo = record

  2110.     sType:                                            TVkStructureType;

  2111.     pNext:                                            PVkVoid;

  2112.     flags:                                            VkShaderModuleCreateFlags;

  2113.     codeSize:                                         VkSize;

  2114.     pCode:                                            PVkUint32;

  2115.   end;

  2116.   PVkShaderModuleCreateInfo = ^TVkShaderModuleCreateInfo;

  2117.   PPVkShaderModuleCreateInfo = ^PVkShaderModuleCreateInfo;

  2118. 

  2119.   TVkPipelineCacheCreateInfo = record

  2120.     sType:                                            TVkStructureType;

  2121.     pNext:                                            PVkVoid;

  2122.     flags:                                            VkPipelineCacheCreateFlags;

  2123.     initialDataSize:                                  VkSize;

  2124.     pInitialData:                                     PVkVoid;

  2125.   end;

  2126.   PVkPipelineCacheCreateInfo = ^TVkPipelineCacheCreateInfo;

  2127.   PPVkPipelineCacheCreateInfo = ^PVkPipelineCacheCreateInfo;

  2128. 

  2129.   TVkSpecializationMapEntry = record

  2130.     constantID:                                       VkUint32;

  2131.     offset:                                           VkUint32;

  2132.     size:                                             VkSize;

  2133.   end;

  2134.   PVkSpecializationMapEntry = ^TVkSpecializationMapEntry;

  2135.   PPVkSpecializationMapEntry = ^PVkSpecializationMapEntry;

  2136. 

  2137.   TVkSpecializationInfo = record

  2138.     mapEntryCount:                                    VkUint32;

  2139.     pMapEntries:                                      PVkSpecializationMapEntry;

  2140.     dataSize:                                         VkSize;

  2141.     pData:                                            PVkVoid;

  2142.   end;

  2143.   PVkSpecializationInfo = ^TVkSpecializationInfo;

  2144.   PPVkSpecializationInfo = ^PVkSpecializationInfo;

  2145. 

  2146.   TVkPipelineShaderStageCreateInfo = record

  2147.     sType:                                            TVkStructureType;

  2148.     pNext:                                            PVkVoid;

  2149.     flags:                                            VkPipelineShaderStageCreateFlags;

  2150.     stage:                                            TVkShaderStageFlagBits;

  2151.     module:                                           VkShaderModule;

  2152.     pName:                                            PVkChar;

  2153.     pSpecializationInfo:                              PVkSpecializationInfo;

  2154.   end;

  2155.   PVkPipelineShaderStageCreateInfo = ^TVkPipelineShaderStageCreateInfo;

  2156.   PPVkPipelineShaderStageCreateInfo = ^PVkPipelineShaderStageCreateInfo;

  2157. 

  2158.   TVkVertexInputBindingDescription = record

  2159.     binding:                                          VkUint32;

  2160.     stride:                                           VkUint32;

  2161.     inputRate:                                        TVkVertexInputRate;

  2162.   end;

  2163.   PVkVertexInputBindingDescription = ^TVkVertexInputBindingDescription;

  2164.   PPVkVertexInputBindingDescription = ^PVkVertexInputBindingDescription;

  2165. 

  2166.   TVkVertexInputAttributeDescription = record

  2167.     location:                                         VkUint32;

  2168.     binding:                                          VkUint32;

  2169.     format:                                           TVkFormat;

  2170.     offset:                                           VkUint32;

  2171.   end;

  2172.   PVkVertexInputAttributeDescription = ^TVkVertexInputAttributeDescription;

  2173.   PPVkVertexInputAttributeDescription = ^PVkVertexInputAttributeDescription;

  2174. 

  2175.   TVkPipelineVertexInputStateCreateInfo = record

  2176.     sType:                                            TVkStructureType;

  2177.     pNext:                                            PVkVoid;

  2178.     flags:                                            VkPipelineVertexInputStateCreateFlags;

  2179.     vertexBindingDescriptionCount:                    VkUint32;

  2180.     pVertexBindingDescriptions:                       PVkVertexInputBindingDescription;

  2181.     vertexAttributeDescriptionCount:                  VkUint32;

  2182.     pVertexAttributeDescriptions:                     PVkVertexInputAttributeDescription;

  2183.   end;

  2184.   PVkPipelineVertexInputStateCreateInfo = ^TVkPipelineVertexInputStateCreateInfo;

  2185.   PPVkPipelineVertexInputStateCreateInfo = ^PVkPipelineVertexInputStateCreateInfo;

  2186. 

  2187.   TVkPipelineInputAssemblyStateCreateInfo = record

  2188.     sType:                                            TVkStructureType;

  2189.     pNext:                                            PVkVoid;

  2190.     flags:                                            VkPipelineInputAssemblyStateCreateFlags;

  2191.     topology:                                         TVkPrimitiveTopology;

  2192.     primitiveRestartEnable:                           VkBool32;

  2193.   end;

  2194.   PVkPipelineInputAssemblyStateCreateInfo = ^TVkPipelineInputAssemblyStateCreateInfo;

  2195.   PPVkPipelineInputAssemblyStateCreateInfo = ^PVkPipelineInputAssemblyStateCreateInfo;

  2196. 

  2197.   TVkPipelineTessellationStateCreateInfo = record

  2198.     sType:                                            TVkStructureType;

  2199.     pNext:                                            PVkVoid;

  2200.     flags:                                            VkPipelineTessellationStateCreateFlags;

  2201.     patchControlPoints:                               VkUint32;

  2202.   end;

  2203.   PVkPipelineTessellationStateCreateInfo = ^TVkPipelineTessellationStateCreateInfo;

  2204.   PPVkPipelineTessellationStateCreateInfo = ^PVkPipelineTessellationStateCreateInfo;

  2205. 

  2206.   TVkViewport = record

  2207.     x:                                                VkFloat;

  2208.     y:                                                VkFloat;

  2209.     width:                                            VkFloat;

  2210.     height:                                           VkFloat;

  2211.     minDepth:                                         VkFloat;

  2212.     maxDepth:                                         VkFloat;

  2213.   end;

  2214.   PVkViewport = ^TVkViewport;

  2215.   PPVkViewport = ^PVkViewport;

  2216. 

  2217.   TVkOffset2D = record

  2218.     x:                                                VkInt32;

  2219.     y:                                                VkInt32;

  2220.   end;

  2221.   PVkOffset2D = ^TVkOffset2D;

  2222.   PPVkOffset2D = ^PVkOffset2D;

  2223. 

  2224.   TVkExtent2D = record

  2225.     width:                                            VkUint32;

  2226.     height:                                           VkUint32;

  2227.   end;

  2228.   PVkExtent2D = ^TVkExtent2D;

  2229.   PPVkExtent2D = ^PVkExtent2D;

  2230. 

  2231.   TVkRect2D = record

  2232.     offset:                                           TVkOffset2D;

  2233.     extent:                                           TVkExtent2D;

  2234.   end;

  2235.   PVkRect2D = ^TVkRect2D;

  2236.   PPVkRect2D = ^PVkRect2D;

  2237. 

  2238.   TVkPipelineViewportStateCreateInfo = record

  2239.     sType:                                            TVkStructureType;

  2240.     pNext:                                            PVkVoid;

  2241.     flags:                                            VkPipelineViewportStateCreateFlags;

  2242.     viewportCount:                                    VkUint32;

  2243.     pViewports:                                       PVkViewport;

  2244.     scissorCount:                                     VkUint32;

  2245.     pScissors:                                        PVkRect2D;

  2246.   end;

  2247.   PVkPipelineViewportStateCreateInfo = ^TVkPipelineViewportStateCreateInfo;

  2248.   PPVkPipelineViewportStateCreateInfo = ^PVkPipelineViewportStateCreateInfo;

  2249. 

  2250.   TVkPipelineRasterizationStateCreateInfo = record

  2251.     sType:                                            TVkStructureType;

  2252.     pNext:                                            PVkVoid;

  2253.     flags:                                            VkPipelineRasterizationStateCreateFlags;

  2254.     depthClampEnable:                                 VkBool32;

  2255.     rasterizerDiscardEnable:                          VkBool32;

  2256.     polygonMode:                                      TVkPolygonMode;

  2257.     cullMode:                                         VkCullModeFlags;

  2258.     frontFace:                                        TVkFrontFace;

  2259.     depthBiasEnable:                                  VkBool32;

  2260.     depthBiasConstantFactor:                          VkFloat;

  2261.     depthBiasClamp:                                   VkFloat;

  2262.     depthBiasSlopeFactor:                             VkFloat;

  2263.     lineWidth:                                        VkFloat;

  2264.   end;

  2265.   PVkPipelineRasterizationStateCreateInfo = ^TVkPipelineRasterizationStateCreateInfo;

  2266.   PPVkPipelineRasterizationStateCreateInfo = ^PVkPipelineRasterizationStateCreateInfo;

  2267. 

  2268.   TVkPipelineMultisampleStateCreateInfo = record

  2269.     sType:                                            TVkStructureType;

  2270.     pNext:                                            PVkVoid;

  2271.     flags:                                            VkPipelineMultisampleStateCreateFlags;

  2272.     rasterizationSamples:                             TVkSampleCountFlagBits;

  2273.     sampleShadingEnable:                              VkBool32;

  2274.     minSampleShading:                                 VkFloat;

  2275.     pSampleMask:                                      PVkSampleMask;

  2276.     alphaToCoverageEnable:                            VkBool32;

  2277.     alphaToOneEnable:                                 VkBool32;

  2278.   end;

  2279.   PVkPipelineMultisampleStateCreateInfo = ^TVkPipelineMultisampleStateCreateInfo;

  2280.   PPVkPipelineMultisampleStateCreateInfo = ^PVkPipelineMultisampleStateCreateInfo;

  2281. 

  2282.   TVkStencilOpState = record

  2283.     failOp:                                           TVkStencilOp;

  2284.     passOp:                                           TVkStencilOp;

  2285.     depthFailOp:                                      TVkStencilOp;

  2286.     compareOp:                                        TVkCompareOp;

  2287.     compareMask:                                      VkUint32;

  2288.     writeMask:                                        VkUint32;

  2289.     reference:                                        VkUint32;

  2290.   end;

  2291.   PVkStencilOpState = ^TVkStencilOpState;

  2292.   PPVkStencilOpState = ^PVkStencilOpState;

  2293. 

  2294.   TVkPipelineDepthStencilStateCreateInfo = record

  2295.     sType:                                            TVkStructureType;

  2296.     pNext:                                            PVkVoid;

  2297.     flags:                                            VkPipelineDepthStencilStateCreateFlags;

  2298.     depthTestEnable:                                  VkBool32;

  2299.     depthWriteEnable:                                 VkBool32;

  2300.     depthCompareOp:                                   TVkCompareOp;

  2301.     depthBoundsTestEnable:                            VkBool32;

  2302.     stencilTestEnable:                                VkBool32;

  2303.     front:                                            TVkStencilOpState;

  2304.     back:                                             TVkStencilOpState;

  2305.     minDepthBounds:                                   VkFloat;

  2306.     maxDepthBounds:                                   VkFloat;

  2307.   end;

  2308.   PVkPipelineDepthStencilStateCreateInfo = ^TVkPipelineDepthStencilStateCreateInfo;

  2309.   PPVkPipelineDepthStencilStateCreateInfo = ^PVkPipelineDepthStencilStateCreateInfo;

  2310. 

  2311.   TVkPipelineColorBlendAttachmentState = record

  2312.     blendEnable:                                      VkBool32;

  2313.     srcColorBlendFactor:                              TVkBlendFactor;

  2314.     dstColorBlendFactor:                              TVkBlendFactor;

  2315.     colorBlendOp:                                     TVkBlendOp;

  2316.     srcAlphaBlendFactor:                              TVkBlendFactor;

  2317.     dstAlphaBlendFactor:                              TVkBlendFactor;

  2318.     alphaBlendOp:                                     TVkBlendOp;

  2319.     colorWriteMask:                                   VkColorComponentFlags;

  2320.   end;

  2321.   PVkPipelineColorBlendAttachmentState = ^TVkPipelineColorBlendAttachmentState;

  2322.   PPVkPipelineColorBlendAttachmentState = ^PVkPipelineColorBlendAttachmentState;

  2323. 

  2324.   TVkPipelineColorBlendStateCreateInfo = record

  2325.     sType:                                            TVkStructureType;

  2326.     pNext:                                            PVkVoid;

  2327.     flags:                                            VkPipelineColorBlendStateCreateFlags;

  2328.     logicOpEnable:                                    VkBool32;

  2329.     logicOp:                                          TVkLogicOp;

  2330.     attachmentCount:                                  VkUint32;

  2331.     pAttachments:                                     PVkPipelineColorBlendAttachmentState;

  2332.     blendConstants:                                   array[0..4] of VkFloat;

  2333.   end;

  2334.   PVkPipelineColorBlendStateCreateInfo = ^TVkPipelineColorBlendStateCreateInfo;

  2335.   PPVkPipelineColorBlendStateCreateInfo = ^PVkPipelineColorBlendStateCreateInfo;

  2336. 

  2337.   TVkPipelineDynamicStateCreateInfo = record

  2338.     sType:                                            TVkStructureType;

  2339.     pNext:                                            PVkVoid;

  2340.     flags:                                            VkPipelineDynamicStateCreateFlags;

  2341.     dynamicStateCount:                                VkUint32;

  2342.     pDynamicStates:                                   PVkDynamicState;

  2343.   end;

  2344.   PVkPipelineDynamicStateCreateInfo = ^TVkPipelineDynamicStateCreateInfo;

  2345.   PPVkPipelineDynamicStateCreateInfo = ^PVkPipelineDynamicStateCreateInfo;

  2346. 

  2347.   TVkGraphicsPipelineCreateInfo = record

  2348.     sType:                                            TVkStructureType;

  2349.     pNext:                                            PVkVoid;

  2350.     flags:                                            VkPipelineCreateFlags;

  2351.     stageCount:                                       VkUint32;

  2352.     pStages:                                          PVkPipelineShaderStageCreateInfo;

  2353.     pVertexInputState:                                PVkPipelineVertexInputStateCreateInfo;

  2354.     pInputAssemblyState:                              PVkPipelineInputAssemblyStateCreateInfo;

  2355.     pTessellationState:                               PVkPipelineTessellationStateCreateInfo;

  2356.     pViewportState:                                   PVkPipelineViewportStateCreateInfo;

  2357.     pRasterizationState:                              PVkPipelineRasterizationStateCreateInfo;

  2358.     pMultisampleState:                                PVkPipelineMultisampleStateCreateInfo;

  2359.     pDepthStencilState:                               PVkPipelineDepthStencilStateCreateInfo;

  2360.     pColorBlendState:                                 PVkPipelineColorBlendStateCreateInfo;

  2361.     pDynamicState:                                    PVkPipelineDynamicStateCreateInfo;

  2362.     layout:                                           VkPipelineLayout;

  2363.     renderPass:                                       VkRenderPass;

  2364.     subpass:                                          VkUint32;

  2365.     basePipelineHandle:                               VkPipeline;

  2366.     basePipelineIndex:                                VkInt32;

  2367.   end;

  2368.   PVkGraphicsPipelineCreateInfo = ^TVkGraphicsPipelineCreateInfo;

  2369.   PPVkGraphicsPipelineCreateInfo = ^PVkGraphicsPipelineCreateInfo;

  2370. 

  2371.   TVkComputePipelineCreateInfo = record

  2372.     sType:                                            TVkStructureType;

  2373.     pNext:                                            PVkVoid;

  2374.     flags:                                            VkPipelineCreateFlags;

  2375.     stage:                                            TVkPipelineShaderStageCreateInfo;

  2376.     layout:                                           VkPipelineLayout;

  2377.     basePipelineHandle:                               VkPipeline;

  2378.     basePipelineIndex:                                VkInt32;

  2379.   end;

  2380.   PVkComputePipelineCreateInfo = ^TVkComputePipelineCreateInfo;

  2381.   PPVkComputePipelineCreateInfo = ^PVkComputePipelineCreateInfo;

  2382. 

  2383.   TVkPushConstantRange = record

  2384.     stageFlags:                                       VkShaderStageFlags;

  2385.     offset:                                           VkUint32;

  2386.     size:                                             VkUint32;

  2387.   end;

  2388.   PVkPushConstantRange = ^TVkPushConstantRange;

  2389.   PPVkPushConstantRange = ^PVkPushConstantRange;

  2390. 

  2391.   TVkPipelineLayoutCreateInfo = record

  2392.     sType:                                            TVkStructureType;

  2393.     pNext:                                            PVkVoid;

  2394.     flags:                                            VkPipelineLayoutCreateFlags;

  2395.     setLayoutCount:                                   VkUint32;

  2396.     pSetLayouts:                                      PVkDescriptorSetLayout;

  2397.     pushConstantRangeCount:                           VkUint32;

  2398.     pPushConstantRanges:                              PVkPushConstantRange;

  2399.   end;

  2400.   PVkPipelineLayoutCreateInfo = ^TVkPipelineLayoutCreateInfo;

  2401.   PPVkPipelineLayoutCreateInfo = ^PVkPipelineLayoutCreateInfo;

  2402. 

  2403.   TVkSamplerCreateInfo = record

  2404.     sType:                                            TVkStructureType;

  2405.     pNext:                                            PVkVoid;

  2406.     flags:                                            VkSamplerCreateFlags;

  2407.     magFilter:                                        TVkFilter;

  2408.     minFilter:                                        TVkFilter;

  2409.     mipmapMode:                                       TVkSamplerMipmapMode;

  2410.     addressModeU:                                     TVkSamplerAddressMode;

  2411.     addressModeV:                                     TVkSamplerAddressMode;

  2412.     addressModeW:                                     TVkSamplerAddressMode;

  2413.     mipLodBias:                                       VkFloat;

  2414.     anisotropyEnable:                                 VkBool32;

  2415.     maxAnisotropy:                                    VkFloat;

  2416.     compareEnable:                                    VkBool32;

  2417.     compareOp:                                        TVkCompareOp;

  2418.     minLod:                                           VkFloat;

  2419.     maxLod:                                           VkFloat;

  2420.     borderColor:                                      TVkBorderColor;

  2421.     unnormalizedCoordinates:                          VkBool32;

  2422.   end;

  2423.   PVkSamplerCreateInfo = ^TVkSamplerCreateInfo;

  2424.   PPVkSamplerCreateInfo = ^PVkSamplerCreateInfo;

  2425. 

  2426.   TVkDescriptorSetLayoutBinding = record

  2427.     binding:                                          VkUint32;

  2428.     descriptorType:                                   TVkDescriptorType;

  2429.     descriptorCount:                                  VkUint32;

  2430.     stageFlags:                                       VkShaderStageFlags;

  2431.     pImmutableSamplers:                               PVkSampler;

  2432.   end;

  2433.   PVkDescriptorSetLayoutBinding = ^TVkDescriptorSetLayoutBinding;

  2434.   PPVkDescriptorSetLayoutBinding = ^PVkDescriptorSetLayoutBinding;

  2435. 

  2436.   TVkDescriptorSetLayoutCreateInfo = record

  2437.     sType:                                            TVkStructureType;

  2438.     pNext:                                            PVkVoid;

  2439.     flags:                                            VkDescriptorSetLayoutCreateFlags;

  2440.     bindingCount:                                     VkUint32;

  2441.     pBindings:                                        PVkDescriptorSetLayoutBinding;

  2442.   end;

  2443.   PVkDescriptorSetLayoutCreateInfo = ^TVkDescriptorSetLayoutCreateInfo;

  2444.   PPVkDescriptorSetLayoutCreateInfo = ^PVkDescriptorSetLayoutCreateInfo;

  2445. 

  2446.   TVkDescriptorPoolSize = record

  2447.     dType:                                            TVkDescriptorType;

  2448.     descriptorCount:                                  VkUint32;

  2449.   end;

  2450.   PVkDescriptorPoolSize = ^TVkDescriptorPoolSize;

  2451.   PPVkDescriptorPoolSize = ^PVkDescriptorPoolSize;

  2452. 

  2453.   TVkDescriptorPoolCreateInfo = record

  2454.     sType:                                            TVkStructureType;

  2455.     pNext:                                            PVkVoid;

  2456.     flags:                                            VkDescriptorPoolCreateFlags;

  2457.     maxSets:                                          VkUint32;

  2458.     poolSizeCount:                                    VkUint32;

  2459.     pPoolSizes:                                       PVkDescriptorPoolSize;

  2460.   end;

  2461.   PVkDescriptorPoolCreateInfo = ^TVkDescriptorPoolCreateInfo;

  2462.   PPVkDescriptorPoolCreateInfo = ^PVkDescriptorPoolCreateInfo;

  2463. 

  2464.   TVkDescriptorSetAllocateInfo = record

  2465.     sType:                                            TVkStructureType;

  2466.     pNext:                                            PVkVoid;

  2467.     descriptorPool:                                   VkDescriptorPool;

  2468.     descriptorSetCount:                               VkUint32;

  2469.     pSetLayouts:                                      PVkDescriptorSetLayout;

  2470.   end;

  2471.   PVkDescriptorSetAllocateInfo = ^TVkDescriptorSetAllocateInfo;

  2472.   PPVkDescriptorSetAllocateInfo = ^PVkDescriptorSetAllocateInfo;

  2473. 

  2474.   TVkDescriptorImageInfo = record

  2475.     sampler:                                          VkSampler;

  2476.     imageView:                                        VkImageView;

  2477.     imageLayout:                                      TVkImageLayout;

  2478.   end;

  2479.   PVkDescriptorImageInfo = ^TVkDescriptorImageInfo;

  2480.   PPVkDescriptorImageInfo = ^PVkDescriptorImageInfo;

  2481. 

  2482.   TVkDescriptorBufferInfo = record

  2483.     buffer:                                           VkBuffer;

  2484.     offset:                                           VkDeviceSize;

  2485.     range:                                            VkDeviceSize;

  2486.   end;

  2487.   PVkDescriptorBufferInfo = ^TVkDescriptorBufferInfo;

  2488.   PPVkDescriptorBufferInfo = ^PVkDescriptorBufferInfo;

  2489. 

  2490.   TVkWriteDescriptorSet = record

  2491.     sType:                                            TVkStructureType;

  2492.     pNext:                                            PVkVoid;

  2493.     dstSet:                                           VkDescriptorSet;

  2494.     dstBinding:                                       VkUint32;

  2495.     dstArrayElement:                                  VkUint32;

  2496.     descriptorCount:                                  VkUint32;

  2497.     descriptorType:                                   TVkDescriptorType;

  2498.     pImageInfo:                                       PVkDescriptorImageInfo;

  2499.     pBufferInfo:                                      PVkDescriptorBufferInfo;

  2500.     pTexelBufferView:                                 PVkBufferView;

  2501.   end;

  2502.   PVkWriteDescriptorSet = ^TVkWriteDescriptorSet;

  2503.   PPVkWriteDescriptorSet = ^PVkWriteDescriptorSet;

  2504. 

  2505.   TVkCopyDescriptorSet = record

  2506.     sType:                                            TVkStructureType;

  2507.     pNext:                                            PVkVoid;

  2508.     srcSet:                                           VkDescriptorSet;

  2509.     srcBinding:                                       VkUint32;

  2510.     srcArrayElement:                                  VkUint32;

  2511.     dstSet:                                           VkDescriptorSet;

  2512.     dstBinding:                                       VkUint32;

  2513.     dstArrayElement:                                  VkUint32;

  2514.     descriptorCount:                                  VkUint32;

  2515.   end;

  2516.   PVkCopyDescriptorSet = ^TVkCopyDescriptorSet;

  2517.   PPVkCopyDescriptorSet = ^PVkCopyDescriptorSet;

  2518. 

  2519.   TVkFramebufferCreateInfo = record

  2520.     sType:                                            TVkStructureType;

  2521.     pNext:                                            PVkVoid;

  2522.     flags:                                            VkFramebufferCreateFlags;

  2523.     renderPass:                                       VkRenderPass;

  2524.     attachmentCount:                                  VkUint32;

  2525.     pAttachments:                                     PVkImageView;

  2526.     width:                                            VkUint32;

  2527.     height:                                           VkUint32;

  2528.     layers:                                           VkUint32;

  2529.   end;

  2530.   PVkFramebufferCreateInfo = ^TVkFramebufferCreateInfo;

  2531.   PPVkFramebufferCreateInfo = ^PVkFramebufferCreateInfo;

  2532. 

  2533.   TVkAttachmentDescription = record

  2534.     flags:                                            VkAttachmentDescriptionFlags;

  2535.     format:                                           TVkFormat;

  2536.     samples:                                          TVkSampleCountFlagBits;

  2537.     loadOp:                                           TVkAttachmentLoadOp;

  2538.     storeOp:                                          TVkAttachmentStoreOp;

  2539.     stencilLoadOp:                                    TVkAttachmentLoadOp;

  2540.     stencilStoreOp:                                   TVkAttachmentStoreOp;

  2541.     initialLayout:                                    TVkImageLayout;

  2542.     finalLayout:                                      TVkImageLayout;

  2543.   end;

  2544.   PVkAttachmentDescription = ^TVkAttachmentDescription;

  2545.   PPVkAttachmentDescription = ^PVkAttachmentDescription;

  2546. 

  2547.   TVkAttachmentReference = record

  2548.     attachment:                                       VkUint32;

  2549.     layout:                                           TVkImageLayout;

  2550.   end;

  2551.   PVkAttachmentReference = ^TVkAttachmentReference;

  2552.   PPVkAttachmentReference = ^PVkAttachmentReference;

  2553. 

  2554.   TVkSubpassDescription = record

  2555.     flags:                                            VkSubpassDescriptionFlags;

  2556.     pipelineBindPoint:                                TVkPipelineBindPoint;

  2557.     inputAttachmentCount:                             VkUint32;

  2558.     pInputAttachments:                                PVkAttachmentReference;

  2559.     colorAttachmentCount:                             VkUint32;

  2560.     pColorAttachments:                                PVkAttachmentReference;

  2561.     pResolveAttachments:                              PVkAttachmentReference;

  2562.     pDepthStencilAttachment:                          PVkAttachmentReference;

  2563.     preserveAttachmentCount:                          VkUint32;

  2564.     pPreserveAttachments:                             PVkUint32;

  2565.   end;

  2566.   PVkSubpassDescription = ^TVkSubpassDescription;

  2567.   PPVkSubpassDescription = ^PVkSubpassDescription;

  2568. 

  2569.   TVkSubpassDependency = record

  2570.     srcSubpass:                                       VkUint32;

  2571.     dstSubpass:                                       VkUint32;

  2572.     srcStageMask:                                     VkPipelineStageFlags;

  2573.     dstStageMask:                                     VkPipelineStageFlags;

  2574.     srcAccessMask:                                    VkAccessFlags;

  2575.     dstAccessMask:                                    VkAccessFlags;

  2576.     dependencyFlags:                                  VkDependencyFlags;

  2577.   end;

  2578.   PVkSubpassDependency = ^TVkSubpassDependency;

  2579.   PPVkSubpassDependency = ^PVkSubpassDependency;

  2580. 

  2581.   TVkRenderPassCreateInfo = record

  2582.     sType:                                            TVkStructureType;

  2583.     pNext:                                            PVkVoid;

  2584.     flags:                                            VkRenderPassCreateFlags;

  2585.     attachmentCount:                                  VkUint32;

  2586.     pAttachments:                                     PVkAttachmentDescription;

  2587.     subpassCount:                                     VkUint32;

  2588.     pSubpasses:                                       PVkSubpassDescription;

  2589.     dependencyCount:                                  VkUint32;

  2590.     pDependencies:                                    PVkSubpassDependency;

  2591.   end;

  2592.   PVkRenderPassCreateInfo = ^TVkRenderPassCreateInfo;

  2593.   PPVkRenderPassCreateInfo = ^PVkRenderPassCreateInfo;

  2594. 

  2595.   TVkCommandPoolCreateInfo = record

  2596.     sType:                                            TVkStructureType;

  2597.     pNext:                                            PVkVoid;

  2598.     flags:                                            VkCommandPoolCreateFlags;

  2599.     queueFamilyIndex:                                 VkUint32;

  2600.   end;

  2601.   PVkCommandPoolCreateInfo = ^TVkCommandPoolCreateInfo;

  2602.   PPVkCommandPoolCreateInfo = ^PVkCommandPoolCreateInfo;

  2603. 

  2604.   TVkCommandBufferAllocateInfo = record

  2605.     sType:                                            TVkStructureType;

  2606.     pNext:                                            PVkVoid;

  2607.     commandPool:                                      VkCommandPool;

  2608.     level:                                            TVkCommandBufferLevel;

  2609.     commandBufferCount:                               VkUint32;

  2610.   end;

  2611.   PVkCommandBufferAllocateInfo = ^TVkCommandBufferAllocateInfo;

  2612.   PPVkCommandBufferAllocateInfo = ^PVkCommandBufferAllocateInfo;

  2613. 

  2614.   TVkCommandBufferInheritanceInfo = record

  2615.     sType:                                            TVkStructureType;

  2616.     pNext:                                            PVkVoid;

  2617.     renderPass:                                       VkRenderPass;

  2618.     subpass:                                          VkUint32;

  2619.     framebuffer:                                      VkFramebuffer;

  2620.     occlusionQueryEnable:                             VkBool32;

  2621.     queryFlags:                                       VkQueryControlFlags;

  2622.     pipelineStatistics:                               VkQueryPipelineStatisticFlags;

  2623.   end;

  2624.   PVkCommandBufferInheritanceInfo = ^TVkCommandBufferInheritanceInfo;

  2625.   PPVkCommandBufferInheritanceInfo = ^PVkCommandBufferInheritanceInfo;

  2626. 

  2627.   TVkCommandBufferBeginInfo = record

  2628.     sType:                                            TVkStructureType;

  2629.     pNext:                                            PVkVoid;

  2630.     flags:                                            VkCommandBufferUsageFlags;

  2631.     pInheritanceInfo:                                 PVkCommandBufferInheritanceInfo;

  2632.   end;

  2633.   PVkCommandBufferBeginInfo = ^TVkCommandBufferBeginInfo;

  2634.   PPVkCommandBufferBeginInfo = ^PVkCommandBufferBeginInfo;

  2635. 

  2636.   TVkBufferCopy = record

  2637.     srcOffset:                                        VkDeviceSize;

  2638.     dstOffset:                                        VkDeviceSize;

  2639.     size:                                             VkDeviceSize;

  2640.   end;

  2641.   PVkBufferCopy = ^TVkBufferCopy;

  2642.   PPVkBufferCopy = ^PVkBufferCopy;

  2643. 

  2644.   TVkImageSubresourceLayers = record

  2645.     aspectMask:                                       VkImageAspectFlags;

  2646.     mipLevel:                                         VkUint32;

  2647.     baseArrayLayer:                                   VkUint32;

  2648.     layerCount:                                       VkUint32;

  2649.   end;

  2650.   PVkImageSubresourceLayers = ^TVkImageSubresourceLayers;

  2651.   PPVkImageSubresourceLayers = ^PVkImageSubresourceLayers;

  2652. 

  2653.   TVkImageCopy = record

  2654.     srcSubresource:                                   TVkImageSubresourceLayers;

  2655.     srcOffset:                                        TVkOffset3D;

  2656.     dstSubresource:                                   TVkImageSubresourceLayers;

  2657.     dstOffset:                                        TVkOffset3D;

  2658.     extent:                                           TVkExtent3D;

  2659.   end;

  2660.   PVkImageCopy = ^TVkImageCopy;

  2661.   PPVkImageCopy = ^PVkImageCopy;

  2662. 

  2663.   TVkImageBlit = record

  2664.     srcSubresource:                                   TVkImageSubresourceLayers;

  2665.     srcOffsets:                                       array[0..2] of TVkOffset3D;

  2666.     dstSubresource:                                   TVkImageSubresourceLayers;

  2667.     dstOffsets:                                       array[0..2] of TVkOffset3D;

  2668.   end;

  2669.   PVkImageBlit = ^TVkImageBlit;

  2670.   PPVkImageBlit = ^PVkImageBlit;

  2671. 

  2672.   TVkBufferImageCopy = record

  2673.     bufferOffset:                                     VkDeviceSize;

  2674.     bufferRowLength:                                  VkUint32;

  2675.     bufferImageHeight:                                VkUint32;

  2676.     imageSubresource:                                 TVkImageSubresourceLayers;

  2677.     imageOffset:                                      TVkOffset3D;

  2678.     imageExtent:                                      TVkExtent3D;

  2679.   end;

  2680.   PVkBufferImageCopy = ^TVkBufferImageCopy;

  2681.   PPVkBufferImageCopy = ^PVkBufferImageCopy;

  2682. 

  2683.   TVkClearColorValue = record

  2684.     case Integer of

  2685.       000: (float32:                                  array[0..4] of VkFloat);

  2686.       001: (int32:                                    array[0..4] of VkInt32);

  2687.       002: (uint32:                                   array[0..4] of VkUint32);

  2688.   end;

  2689.   PVkClearColorValue = ^TVkClearColorValue;

  2690.   PPVkClearColorValue = ^PVkClearColorValue;

  2691. 

  2692.   TVkClearDepthStencilValue = record

  2693.     depth:                                            VkFloat;

  2694.     stencil:                                          VkUint32;

  2695.   end;

  2696.   PVkClearDepthStencilValue = ^TVkClearDepthStencilValue;

  2697.   PPVkClearDepthStencilValue = ^PVkClearDepthStencilValue;

  2698. 

  2699.   TVkClearValue = record

  2700.     case Integer of

  2701.       000: (color:                                    TVkClearColorValue);

  2702.       001: (depthStencil:                             TVkClearDepthStencilValue);

  2703.   end;

  2704.   PVkClearValue = ^TVkClearValue;

  2705.   PPVkClearValue = ^PVkClearValue;

  2706. 

  2707.   TVkClearAttachment = record

  2708.     aspectMask:                                       VkImageAspectFlags;

  2709.     colorAttachment:                                  VkUint32;

  2710.     clearValue:                                       TVkClearValue;

  2711.   end;

  2712.   PVkClearAttachment = ^TVkClearAttachment;

  2713.   PPVkClearAttachment = ^PVkClearAttachment;

  2714. 

  2715.   TVkClearRect = record

  2716.     rect:                                             TVkRect2D;

  2717.     baseArrayLayer:                                   VkUint32;

  2718.     layerCount:                                       VkUint32;

  2719.   end;

  2720.   PVkClearRect = ^TVkClearRect;

  2721.   PPVkClearRect = ^PVkClearRect;

  2722. 

  2723.   TVkImageResolve = record

  2724.     srcSubresource:                                   TVkImageSubresourceLayers;

  2725.     srcOffset:                                        TVkOffset3D;

  2726.     dstSubresource:                                   TVkImageSubresourceLayers;

  2727.     dstOffset:                                        TVkOffset3D;

  2728.     extent:                                           TVkExtent3D;

  2729.   end;

  2730.   PVkImageResolve = ^TVkImageResolve;

  2731.   PPVkImageResolve = ^PVkImageResolve;

  2732. 

  2733.   TVkMemoryBarrier = record

  2734.     sType:                                            TVkStructureType;

  2735.     pNext:                                            PVkVoid;

  2736.     srcAccessMask:                                    VkAccessFlags;

  2737.     dstAccessMask:                                    VkAccessFlags;

  2738.   end;

  2739.   PVkMemoryBarrier = ^TVkMemoryBarrier;

  2740.   PPVkMemoryBarrier = ^PVkMemoryBarrier;

  2741. 

  2742.   TVkBufferMemoryBarrier = record

  2743.     sType:                                            TVkStructureType;

  2744.     pNext:                                            PVkVoid;

  2745.     srcAccessMask:                                    VkAccessFlags;

  2746.     dstAccessMask:                                    VkAccessFlags;

  2747.     srcQueueFamilyIndex:                              VkUint32;

  2748.     dstQueueFamilyIndex:                              VkUint32;

  2749.     buffer:                                           VkBuffer;

  2750.     offset:                                           VkDeviceSize;

  2751.     size:                                             VkDeviceSize;

  2752.   end;

  2753.   PVkBufferMemoryBarrier = ^TVkBufferMemoryBarrier;

  2754.   PPVkBufferMemoryBarrier = ^PVkBufferMemoryBarrier;

  2755. 

  2756.   TVkImageMemoryBarrier = record

  2757.     sType:                                            TVkStructureType;

  2758.     pNext:                                            PVkVoid;

  2759.     srcAccessMask:                                    VkAccessFlags;

  2760.     dstAccessMask:                                    VkAccessFlags;

  2761.     oldLayout:                                        TVkImageLayout;

  2762.     newLayout:                                        TVkImageLayout;

  2763.     srcQueueFamilyIndex:                              VkUint32;

  2764.     dstQueueFamilyIndex:                              VkUint32;

  2765.     image:                                            VkImage;

  2766.     subresourceRange:                                 TVkImageSubresourceRange;

  2767.   end;

  2768.   PVkImageMemoryBarrier = ^TVkImageMemoryBarrier;

  2769.   PPVkImageMemoryBarrier = ^PVkImageMemoryBarrier;

  2770. 

  2771.   TVkRenderPassBeginInfo = record

  2772.     sType:                                            TVkStructureType;

  2773.     pNext:                                            PVkVoid;

  2774.     renderPass:                                       VkRenderPass;

  2775.     framebuffer:                                      VkFramebuffer;

  2776.     renderArea:                                       TVkRect2D;

  2777.     clearValueCount:                                  VkUint32;

  2778.     pClearValues:                                     PVkClearValue;

  2779.   end;

  2780.   PVkRenderPassBeginInfo = ^TVkRenderPassBeginInfo;

  2781.   PPVkRenderPassBeginInfo = ^PVkRenderPassBeginInfo;

  2782. 

  2783.   TVkDispatchIndirectCommand = record

  2784.     x:                                                VkUint32;

  2785.     y:                                                VkUint32;

  2786.     z:                                                VkUint32;

  2787.   end;

  2788.   PVkDispatchIndirectCommand = ^TVkDispatchIndirectCommand;

  2789.   PPVkDispatchIndirectCommand = ^PVkDispatchIndirectCommand;

  2790. 

  2791.   TVkDrawIndexedIndirectCommand = record

  2792.     indexCount:                                       VkUint32;

  2793.     instanceCount:                                    VkUint32;

  2794.     firstIndex:                                       VkUint32;

  2795.     vertexOffset:                                     VkInt32;

  2796.     firstInstance:                                    VkUint32;

  2797.   end;

  2798.   PVkDrawIndexedIndirectCommand = ^TVkDrawIndexedIndirectCommand;

  2799.   PPVkDrawIndexedIndirectCommand = ^PVkDrawIndexedIndirectCommand;

  2800. 

  2801.   TVkDrawIndirectCommand = record

  2802.     vertexCount:                                      VkUint32;

  2803.     instanceCount:                                    VkUint32;

  2804.     firstVertex:                                      VkUint32;

  2805.     firstInstance:                                    VkUint32;

  2806.   end;

  2807.   PVkDrawIndirectCommand = ^TVkDrawIndirectCommand;

  2808.   PPVkDrawIndirectCommand = ^PVkDrawIndirectCommand;

  2809. 

  2810. { ========================================== VK_KHR_surface ========================================== }

  2811.   TVkSurfaceCapabilitiesKHR = record

  2812.     minImageCount:                                    VkUint32;

  2813.     maxImageCount:                                    VkUint32;

  2814.     currentExtent:                                    TVkExtent2D;

  2815.     minImageExtent:                                   TVkExtent2D;

  2816.     maxImageExtent:                                   TVkExtent2D;

  2817.     maxImageArrayLayers:                              VkUint32;

  2818.     supportedTransforms:                              VkSurfaceTransformFlagsKHR;

  2819.     currentTransform:                                 TVkSurfaceTransformFlagBitsKHR;

  2820.     supportedCompositeAlpha:                          VkCompositeAlphaFlagsKHR;

  2821.     supportedUsageFlags:                              VkImageUsageFlags;

  2822.   end;

  2823.   PVkSurfaceCapabilitiesKHR = ^TVkSurfaceCapabilitiesKHR;

  2824.   PPVkSurfaceCapabilitiesKHR = ^PVkSurfaceCapabilitiesKHR;

  2825. 

  2826.   TVkSurfaceFormatKHR = record

  2827.     format:                                           TVkFormat;

  2828.     colorSpace:                                       TVkColorSpaceKHR;

  2829.   end;

  2830.   PVkSurfaceFormatKHR = ^TVkSurfaceFormatKHR;

  2831.   PPVkSurfaceFormatKHR = ^PVkSurfaceFormatKHR;

  2832. 

  2833. { ========================================= VK_KHR_swapchain ========================================= }

  2834.   TVkSwapchainCreateInfoKHR = record

  2835.     sType:                                            TVkStructureType;

  2836.     pNext:                                            PVkVoid;

  2837.     flags:                                            VkSwapchainCreateFlagsKHR;

  2838.     surface:                                          VkSurfaceKHR;

  2839.     minImageCount:                                    VkUint32;

  2840.     imageFormat:                                      TVkFormat;

  2841.     imageColorSpace:                                  TVkColorSpaceKHR;

  2842.     imageExtent:                                      TVkExtent2D;

  2843.     imageArrayLayers:                                 VkUint32;

  2844.     imageUsage:                                       VkImageUsageFlags;

  2845.     imageSharingMode:                                 TVkSharingMode;

  2846.     queueFamilyIndexCount:                            VkUint32;

  2847.     pQueueFamilyIndices:                              PVkUint32;

  2848.     preTransform:                                     TVkSurfaceTransformFlagBitsKHR;

  2849.     compositeAlpha:                                   TVkCompositeAlphaFlagBitsKHR;

  2850.     presentMode:                                      TVkPresentModeKHR;

  2851.     clipped:                                          VkBool32;

  2852.     oldSwapchain:                                     VkSwapchainKHR;

  2853.   end;

  2854.   PVkSwapchainCreateInfoKHR = ^TVkSwapchainCreateInfoKHR;

  2855.   PPVkSwapchainCreateInfoKHR = ^PVkSwapchainCreateInfoKHR;

  2856. 

  2857.   TVkPresentInfoKHR = record

  2858.     sType:                                            TVkStructureType;

  2859.     pNext:                                            PVkVoid;

  2860.     waitSemaphoreCount:                               VkUint32;

  2861.     pWaitSemaphores:                                  PVkSemaphore;

  2862.     swapchainCount:                                   VkUint32;

  2863.     pSwapchains:                                      PVkSwapchainKHR;

  2864.     pImageIndices:                                    PVkUint32;

  2865.     pResults:                                         PVkResult;

  2866.   end;

  2867.   PVkPresentInfoKHR = ^TVkPresentInfoKHR;

  2868.   PPVkPresentInfoKHR = ^PVkPresentInfoKHR;

  2869. 

  2870. { ========================================== VK_KHR_display ========================================== }

  2871.   TVkDisplayPropertiesKHR = record

  2872.     display:                                          VkDisplayKHR;

  2873.     displayName:                                      PVkChar;

  2874.     physicalDimensions:                               TVkExtent2D;

  2875.     physicalResolution:                               TVkExtent2D;

  2876.     supportedTransforms:                              VkSurfaceTransformFlagsKHR;

  2877.     planeReorderPossible:                             VkBool32;

  2878.     persistentContent:                                VkBool32;

  2879.   end;

  2880.   PVkDisplayPropertiesKHR = ^TVkDisplayPropertiesKHR;

  2881.   PPVkDisplayPropertiesKHR = ^PVkDisplayPropertiesKHR;

  2882. 

  2883.   TVkDisplayModeParametersKHR = record

  2884.     visibleRegion:                                    TVkExtent2D;

  2885.     refreshRate:                                      VkUint32;

  2886.   end;

  2887.   PVkDisplayModeParametersKHR = ^TVkDisplayModeParametersKHR;

  2888.   PPVkDisplayModeParametersKHR = ^PVkDisplayModeParametersKHR;

  2889. 

  2890.   TVkDisplayModePropertiesKHR = record

  2891.     displayMode:                                      VkDisplayModeKHR;

  2892.     parameters:                                       TVkDisplayModeParametersKHR;

  2893.   end;

  2894.   PVkDisplayModePropertiesKHR = ^TVkDisplayModePropertiesKHR;

  2895.   PPVkDisplayModePropertiesKHR = ^PVkDisplayModePropertiesKHR;

  2896. 

  2897.   TVkDisplayModeCreateInfoKHR = record

  2898.     sType:                                            TVkStructureType;

  2899.     pNext:                                            PVkVoid;

  2900.     flags:                                            VkDisplayModeCreateFlagsKHR;

  2901.     parameters:                                       TVkDisplayModeParametersKHR;

  2902.   end;

  2903.   PVkDisplayModeCreateInfoKHR = ^TVkDisplayModeCreateInfoKHR;

  2904.   PPVkDisplayModeCreateInfoKHR = ^PVkDisplayModeCreateInfoKHR;

  2905. 

  2906.   TVkDisplayPlaneCapabilitiesKHR = record

  2907.     supportedAlpha:                                   VkDisplayPlaneAlphaFlagsKHR;

  2908.     minSrcPosition:                                   TVkOffset2D;

  2909.     maxSrcPosition:                                   TVkOffset2D;

  2910.     minSrcExtent:                                     TVkExtent2D;

  2911.     maxSrcExtent:                                     TVkExtent2D;

  2912.     minDstPosition:                                   TVkOffset2D;

  2913.     maxDstPosition:                                   TVkOffset2D;

  2914.     minDstExtent:                                     TVkExtent2D;

  2915.     maxDstExtent:                                     TVkExtent2D;

  2916.   end;

  2917.   PVkDisplayPlaneCapabilitiesKHR = ^TVkDisplayPlaneCapabilitiesKHR;

  2918.   PPVkDisplayPlaneCapabilitiesKHR = ^PVkDisplayPlaneCapabilitiesKHR;

  2919. 

  2920.   TVkDisplayPlanePropertiesKHR = record

  2921.     currentDisplay:                                   VkDisplayKHR;

  2922.     currentStackIndex:                                VkUint32;

  2923.   end;

  2924.   PVkDisplayPlanePropertiesKHR = ^TVkDisplayPlanePropertiesKHR;

  2925.   PPVkDisplayPlanePropertiesKHR = ^PVkDisplayPlanePropertiesKHR;

  2926. 

  2927.   TVkDisplaySurfaceCreateInfoKHR = record

  2928.     sType:                                            TVkStructureType;

  2929.     pNext:                                            PVkVoid;

  2930.     flags:                                            VkDisplaySurfaceCreateFlagsKHR;

  2931.     displayMode:                                      VkDisplayModeKHR;

  2932.     planeIndex:                                       VkUint32;

  2933.     planeStackIndex:                                  VkUint32;

  2934.     transform:                                        TVkSurfaceTransformFlagBitsKHR;

  2935.     globalAlpha:                                      VkFloat;

  2936.     alphaMode:                                        TVkDisplayPlaneAlphaFlagBitsKHR;

  2937.     imageExtent:                                      TVkExtent2D;

  2938.   end;

  2939.   PVkDisplaySurfaceCreateInfoKHR = ^TVkDisplaySurfaceCreateInfoKHR;

  2940.   PPVkDisplaySurfaceCreateInfoKHR = ^PVkDisplaySurfaceCreateInfoKHR;

  2941. 

  2942. { ===================================== VK_KHR_display_swapchain ===================================== }

  2943.   TVkDisplayPresentInfoKHR = record

  2944.     sType:                                            TVkStructureType;

  2945.     pNext:                                            PVkVoid;

  2946.     srcRect:                                          TVkRect2D;

  2947.     dstRect:                                          TVkRect2D;

  2948.     persistent:                                       VkBool32;

  2949.   end;

  2950.   PVkDisplayPresentInfoKHR = ^TVkDisplayPresentInfoKHR;

  2951.   PPVkDisplayPresentInfoKHR = ^PVkDisplayPresentInfoKHR;

  2952. 

  2953. { ======================================= VK_KHR_xlib_surface ======================================== }

  2954. {$IFDEF VK_USE_PLATFORM_XLIB_KHR}

  2955.   TVkXlibSurfaceCreateInfoKHR = record

  2956.     sType:                                            TVkStructureType;

  2957.     pNext:                                            PVkVoid;

  2958.     flags:                                            VkXlibSurfaceCreateFlagsKHR;

  2959.     dpy:                                              Display;

  2960.     window:                                           Window;

  2961.   end;

  2962.   PVkXlibSurfaceCreateInfoKHR = ^TVkXlibSurfaceCreateInfoKHR;

  2963.   PPVkXlibSurfaceCreateInfoKHR = ^PVkXlibSurfaceCreateInfoKHR;

  2964. {$ENDIF}

  2965. 

  2966. { ======================================== VK_KHR_xcb_surface ======================================== }

  2967. {$IFDEF VK_USE_PLATFORM_XCB_KHR}

  2968.   TVkXcbSurfaceCreateInfoKHR = record

  2969.     sType:                                            TVkStructureType;

  2970.     pNext:                                            PVkVoid;

  2971.     flags:                                            VkXcbSurfaceCreateFlagsKHR;

  2972.     connection:                                       xcb_connection_t;

  2973.     window:                                           xcb_window_t;

  2974.   end;

  2975.   PVkXcbSurfaceCreateInfoKHR = ^TVkXcbSurfaceCreateInfoKHR;

  2976.   PPVkXcbSurfaceCreateInfoKHR = ^PVkXcbSurfaceCreateInfoKHR;

  2977. {$ENDIF}

  2978. 

  2979. { ====================================== VK_KHR_wayland_surface ====================================== }

  2980. {$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}

  2981.   TVkWaylandSurfaceCreateInfoKHR = record

  2982.     sType:                                            TVkStructureType;

  2983.     pNext:                                            PVkVoid;

  2984.     flags:                                            VkWaylandSurfaceCreateFlagsKHR;

  2985.     display:                                          wl_display;

  2986.     surface:                                          wl_surface;

  2987.   end;

  2988.   PVkWaylandSurfaceCreateInfoKHR = ^TVkWaylandSurfaceCreateInfoKHR;

  2989.   PPVkWaylandSurfaceCreateInfoKHR = ^PVkWaylandSurfaceCreateInfoKHR;

  2990. {$ENDIF}

  2991. 

  2992. { ======================================== VK_KHR_mir_surface ======================================== }

  2993. {$IFDEF VK_USE_PLATFORM_MIR_KHR}

  2994.   TVkMirSurfaceCreateInfoKHR = record

  2995.     sType:                                            TVkStructureType;

  2996.     pNext:                                            PVkVoid;

  2997.     flags:                                            VkMirSurfaceCreateFlagsKHR;

  2998.     connection:                                       MirConnection;

  2999.     mirSurface:                                       MirSurface;

  3000.   end;

  3001.   PVkMirSurfaceCreateInfoKHR = ^TVkMirSurfaceCreateInfoKHR;

  3002.   PPVkMirSurfaceCreateInfoKHR = ^PVkMirSurfaceCreateInfoKHR;

  3003. {$ENDIF}

  3004. 

  3005. { ====================================== VK_KHR_android_surface ====================================== }

  3006. {$IFDEF VK_USE_PLATFORM_ANDROID_KHR}

  3007.   TVkAndroidSurfaceCreateInfoKHR = record

  3008.     sType:                                            TVkStructureType;

  3009.     pNext:                                            PVkVoid;

  3010.     flags:                                            VkAndroidSurfaceCreateFlagsKHR;

  3011.     window:                                           ANativeWindow;

  3012.   end;

  3013.   PVkAndroidSurfaceCreateInfoKHR = ^TVkAndroidSurfaceCreateInfoKHR;

  3014.   PPVkAndroidSurfaceCreateInfoKHR = ^PVkAndroidSurfaceCreateInfoKHR;

  3015. {$ENDIF}

  3016. 

  3017. { ======================================= VK_KHR_win32_surface ======================================= }

  3018. {$IFDEF VK_USE_PLATFORM_WIN32_KHR}

  3019.   TVkWin32SurfaceCreateInfoKHR = record

  3020.     sType:                                            TVkStructureType;

  3021.     pNext:                                            PVkVoid;

  3022.     flags:                                            VkWin32SurfaceCreateFlagsKHR;

  3023.     hinstance:                                        HINSTANCE;

  3024.     hwnd:                                             HWND;

  3025.   end;

  3026.   PVkWin32SurfaceCreateInfoKHR = ^TVkWin32SurfaceCreateInfoKHR;

  3027.   PPVkWin32SurfaceCreateInfoKHR = ^PVkWin32SurfaceCreateInfoKHR;

  3028. {$ENDIF}

  3029. 

  3030. { ======================================= VK_EXT_debug_report ======================================== }

  3031.   TVkDebugReportCallbackCreateInfoEXT = record

  3032.     sType:                                            TVkStructureType;

  3033.     pNext:                                            PVkVoid;

  3034.     flags:                                            VkDebugReportFlagsEXT;

  3035.     pfnCallback:                                      TvkDebugReportCallbackEXT;

  3036.     pUserData:                                        PVkVoid;

  3037.   end;

  3038.   PVkDebugReportCallbackCreateInfoEXT = ^TVkDebugReportCallbackCreateInfoEXT;

  3039.   PPVkDebugReportCallbackCreateInfoEXT = ^PVkDebugReportCallbackCreateInfoEXT;

  3040. 

  3041. type { commands }

  3042. 

  3043. { ========================================== VK_VERSION_1_0 ========================================== }

  3044.   TvkCreateInstance = function (

  3045.     const pCreateInfo:                  PVkInstanceCreateInfo; 

  3046.     const pAllocator:                   PVkAllocationCallbacks; 

  3047.           pInstance:                    PVkInstance

  3048.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3049. 

  3050.   TvkDestroyInstance = procedure(

  3051.           instance:                     VkInstance; 

  3052.     const pAllocator:                   PVkAllocationCallbacks

  3053.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3054. 

  3055.   TvkEnumeratePhysicalDevices = function (

  3056.           instance:                     VkInstance; 

  3057.           pPhysicalDeviceCount:         PVkUint32; 

  3058.           pPhysicalDevices:             PVkPhysicalDevice

  3059.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3060. 

  3061.   TvkGetPhysicalDeviceFeatures = procedure(

  3062.           physicalDevice:               VkPhysicalDevice; 

  3063.           pFeatures:                    PVkPhysicalDeviceFeatures

  3064.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3065. 

  3066.   TvkGetPhysicalDeviceFormatProperties = procedure(

  3067.           physicalDevice:               VkPhysicalDevice; 

  3068.           format:                       TVkFormat; 

  3069.           pFormatProperties:            PVkFormatProperties

  3070.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3071. 

  3072.   TvkGetPhysicalDeviceImageFormatProperties = function (

  3073.           physicalDevice:               VkPhysicalDevice; 

  3074.           format:                       TVkFormat; 

  3075.           iType:                        TVkImageType; 

  3076.           tiling:                       TVkImageTiling; 

  3077.           usage:                        VkImageUsageFlags; 

  3078.           flags:                        VkImageCreateFlags; 

  3079.           pImageFormatProperties:       PVkImageFormatProperties

  3080.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3081. 

  3082.   TvkGetPhysicalDeviceProperties = procedure(

  3083.           physicalDevice:               VkPhysicalDevice; 

  3084.           pProperties:                  PVkPhysicalDeviceProperties

  3085.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3086. 

  3087.   TvkGetPhysicalDeviceQueueFamilyProperties = procedure(

  3088.           physicalDevice:               VkPhysicalDevice; 

  3089.           pQueueFamilyPropertyCount:    PVkUint32; 

  3090.           pQueueFamilyProperties:       PVkQueueFamilyProperties

  3091.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3092. 

  3093.   TvkGetPhysicalDeviceMemoryProperties = procedure(

  3094.           physicalDevice:               VkPhysicalDevice; 

  3095.           pMemoryProperties:            PVkPhysicalDeviceMemoryProperties

  3096.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3097. 

  3098.   TvkGetInstanceProcAddr = function (

  3099.           instance:                     VkInstance; 

  3100.     const pName:                        PVkChar

  3101.   ): TvkVoidFunction; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3102. 

  3103.   TvkGetDeviceProcAddr = function (

  3104.           device:                       VkDevice; 

  3105.     const pName:                        PVkChar

  3106.   ): TvkVoidFunction; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3107. 

  3108.   TvkCreateDevice = function (

  3109.           physicalDevice:               VkPhysicalDevice; 

  3110.     const pCreateInfo:                  PVkDeviceCreateInfo; 

  3111.     const pAllocator:                   PVkAllocationCallbacks; 

  3112.           pDevice:                      PVkDevice

  3113.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3114. 

  3115.   TvkDestroyDevice = procedure(

  3116.           device:                       VkDevice; 

  3117.     const pAllocator:                   PVkAllocationCallbacks

  3118.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3119. 

  3120.   TvkEnumerateInstanceExtensionProperties = function (

  3121.     const pLayerName:                   PVkChar; 

  3122.           pPropertyCount:               PVkUint32; 

  3123.           pProperties:                  PVkExtensionProperties

  3124.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3125. 

  3126.   TvkEnumerateDeviceExtensionProperties = function (

  3127.           physicalDevice:               VkPhysicalDevice; 

  3128.     const pLayerName:                   PVkChar; 

  3129.           pPropertyCount:               PVkUint32; 

  3130.           pProperties:                  PVkExtensionProperties

  3131.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3132. 

  3133.   TvkEnumerateInstanceLayerProperties = function (

  3134.           pPropertyCount:               PVkUint32; 

  3135.           pProperties:                  PVkLayerProperties

  3136.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3137. 

  3138.   TvkEnumerateDeviceLayerProperties = function (

  3139.           physicalDevice:               VkPhysicalDevice; 

  3140.           pPropertyCount:               PVkUint32; 

  3141.           pProperties:                  PVkLayerProperties

  3142.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3143. 

  3144.   TvkGetDeviceQueue = procedure(

  3145.           device:                       VkDevice; 

  3146.           queueFamilyIndex:             VkUint32; 

  3147.           queueIndex:                   VkUint32; 

  3148.           pQueue:                       PVkQueue

  3149.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3150. 

  3151.   TvkQueueSubmit = function (

  3152.           queue:                        VkQueue; 

  3153.           submitCount:                  VkUint32; 

  3154.     const pSubmits:                     PVkSubmitInfo; 

  3155.           fence:                        VkFence

  3156.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3157. 

  3158.   TvkQueueWaitIdle = function (

  3159.           queue:                        VkQueue

  3160.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3161. 

  3162.   TvkDeviceWaitIdle = function (

  3163.           device:                       VkDevice

  3164.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3165. 

  3166.   TvkAllocateMemory = function (

  3167.           device:                       VkDevice; 

  3168.     const pAllocateInfo:                PVkMemoryAllocateInfo; 

  3169.     const pAllocator:                   PVkAllocationCallbacks; 

  3170.           pMemory:                      PVkDeviceMemory

  3171.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3172. 

  3173.   TvkFreeMemory = procedure(

  3174.           device:                       VkDevice; 

  3175.           memory:                       VkDeviceMemory; 

  3176.     const pAllocator:                   PVkAllocationCallbacks

  3177.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3178. 

  3179.   TvkMapMemory = function (

  3180.           device:                       VkDevice; 

  3181.           memory:                       VkDeviceMemory; 

  3182.           offset:                       VkDeviceSize; 

  3183.           size:                         VkDeviceSize; 

  3184.           flags:                        VkMemoryMapFlags; 

  3185.           ppData:                       PPVkVoid

  3186.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3187. 

  3188.   TvkUnmapMemory = procedure(

  3189.           device:                       VkDevice; 

  3190.           memory:                       VkDeviceMemory

  3191.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3192. 

  3193.   TvkFlushMappedMemoryRanges = function (

  3194.           device:                       VkDevice; 

  3195.           memoryRangeCount:             VkUint32; 

  3196.     const pMemoryRanges:                PVkMappedMemoryRange

  3197.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3198. 

  3199.   TvkInvalidateMappedMemoryRanges = function (

  3200.           device:                       VkDevice; 

  3201.           memoryRangeCount:             VkUint32; 

  3202.     const pMemoryRanges:                PVkMappedMemoryRange

  3203.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3204. 

  3205.   TvkGetDeviceMemoryCommitment = procedure(

  3206.           device:                       VkDevice; 

  3207.           memory:                       VkDeviceMemory; 

  3208.           pCommittedMemoryInBytes:      PVkDeviceSize

  3209.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3210. 

  3211.   TvkBindBufferMemory = function (

  3212.           device:                       VkDevice; 

  3213.           buffer:                       VkBuffer; 

  3214.           memory:                       VkDeviceMemory; 

  3215.           memoryOffset:                 VkDeviceSize

  3216.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3217. 

  3218.   TvkBindImageMemory = function (

  3219.           device:                       VkDevice; 

  3220.           image:                        VkImage; 

  3221.           memory:                       VkDeviceMemory; 

  3222.           memoryOffset:                 VkDeviceSize

  3223.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3224. 

  3225.   TvkGetBufferMemoryRequirements = procedure(

  3226.           device:                       VkDevice; 

  3227.           buffer:                       VkBuffer; 

  3228.           pMemoryRequirements:          PVkMemoryRequirements

  3229.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3230. 

  3231.   TvkGetImageMemoryRequirements = procedure(

  3232.           device:                       VkDevice; 

  3233.           image:                        VkImage; 

  3234.           pMemoryRequirements:          PVkMemoryRequirements

  3235.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3236. 

  3237.   TvkGetImageSparseMemoryRequirements = procedure(

  3238.           device:                       VkDevice; 

  3239.           image:                        VkImage; 

  3240.           pSparseMemoryRequirementCount:PVkUint32; 

  3241.           pSparseMemoryRequirements:    PVkSparseImageMemoryRequirements

  3242.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3243. 

  3244.   TvkGetPhysicalDeviceSparseImageFormatProperties = procedure(

  3245.           physicalDevice:               VkPhysicalDevice; 

  3246.           format:                       TVkFormat; 

  3247.           iType:                        TVkImageType; 

  3248.           samples:                      TVkSampleCountFlagBits; 

  3249.           usage:                        VkImageUsageFlags; 

  3250.           tiling:                       TVkImageTiling; 

  3251.           pPropertyCount:               PVkUint32; 

  3252.           pProperties:                  PVkSparseImageFormatProperties

  3253.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3254. 

  3255.   TvkQueueBindSparse = function (

  3256.           queue:                        VkQueue; 

  3257.           bindInfoCount:                VkUint32; 

  3258.     const pBindInfo:                    PVkBindSparseInfo; 

  3259.           fence:                        VkFence

  3260.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3261. 

  3262.   TvkCreateFence = function (

  3263.           device:                       VkDevice; 

  3264.     const pCreateInfo:                  PVkFenceCreateInfo; 

  3265.     const pAllocator:                   PVkAllocationCallbacks; 

  3266.           pFence:                       PVkFence

  3267.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3268. 

  3269.   TvkDestroyFence = procedure(

  3270.           device:                       VkDevice; 

  3271.           fence:                        VkFence; 

  3272.     const pAllocator:                   PVkAllocationCallbacks

  3273.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3274. 

  3275.   TvkResetFences = function (

  3276.           device:                       VkDevice; 

  3277.           fenceCount:                   VkUint32; 

  3278.     const pFences:                      PVkFence

  3279.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3280. 

  3281.   TvkGetFenceStatus = function (

  3282.           device:                       VkDevice; 

  3283.           fence:                        VkFence

  3284.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3285. 

  3286.   TvkWaitForFences = function (

  3287.           device:                       VkDevice; 

  3288.           fenceCount:                   VkUint32; 

  3289.     const pFences:                      PVkFence; 

  3290.           waitAll:                      VkBool32; 

  3291.           timeout:                      VkUint64

  3292.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3293. 

  3294.   TvkCreateSemaphore = function (

  3295.           device:                       VkDevice; 

  3296.     const pCreateInfo:                  PVkSemaphoreCreateInfo; 

  3297.     const pAllocator:                   PVkAllocationCallbacks; 

  3298.           pSemaphore:                   PVkSemaphore

  3299.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3300. 

  3301.   TvkDestroySemaphore = procedure(

  3302.           device:                       VkDevice; 

  3303.           semaphore:                    VkSemaphore; 

  3304.     const pAllocator:                   PVkAllocationCallbacks

  3305.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3306. 

  3307.   TvkCreateEvent = function (

  3308.           device:                       VkDevice; 

  3309.     const pCreateInfo:                  PVkEventCreateInfo; 

  3310.     const pAllocator:                   PVkAllocationCallbacks; 

  3311.           pEvent:                       PVkEvent

  3312.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3313. 

  3314.   TvkDestroyEvent = procedure(

  3315.           device:                       VkDevice; 

  3316.           event:                        VkEvent; 

  3317.     const pAllocator:                   PVkAllocationCallbacks

  3318.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3319. 

  3320.   TvkGetEventStatus = function (

  3321.           device:                       VkDevice; 

  3322.           event:                        VkEvent

  3323.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3324. 

  3325.   TvkSetEvent = function (

  3326.           device:                       VkDevice; 

  3327.           event:                        VkEvent

  3328.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3329. 

  3330.   TvkResetEvent = function (

  3331.           device:                       VkDevice; 

  3332.           event:                        VkEvent

  3333.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3334. 

  3335.   TvkCreateQueryPool = function (

  3336.           device:                       VkDevice; 

  3337.     const pCreateInfo:                  PVkQueryPoolCreateInfo; 

  3338.     const pAllocator:                   PVkAllocationCallbacks; 

  3339.           pQueryPool:                   PVkQueryPool

  3340.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3341. 

  3342.   TvkDestroyQueryPool = procedure(

  3343.           device:                       VkDevice; 

  3344.           queryPool:                    VkQueryPool; 

  3345.     const pAllocator:                   PVkAllocationCallbacks

  3346.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3347. 

  3348.   TvkGetQueryPoolResults = function (

  3349.           device:                       VkDevice; 

  3350.           queryPool:                    VkQueryPool; 

  3351.           firstQuery:                   VkUint32; 

  3352.           queryCount:                   VkUint32; 

  3353.           dataSize:                     VkSize; 

  3354.           pData:                        PVkVoid; 

  3355.           stride:                       VkDeviceSize; 

  3356.           flags:                        VkQueryResultFlags

  3357.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3358. 

  3359.   TvkCreateBuffer = function (

  3360.           device:                       VkDevice; 

  3361.     const pCreateInfo:                  PVkBufferCreateInfo; 

  3362.     const pAllocator:                   PVkAllocationCallbacks; 

  3363.           pBuffer:                      PVkBuffer

  3364.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3365. 

  3366.   TvkDestroyBuffer = procedure(

  3367.           device:                       VkDevice; 

  3368.           buffer:                       VkBuffer; 

  3369.     const pAllocator:                   PVkAllocationCallbacks

  3370.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3371. 

  3372.   TvkCreateBufferView = function (

  3373.           device:                       VkDevice; 

  3374.     const pCreateInfo:                  PVkBufferViewCreateInfo; 

  3375.     const pAllocator:                   PVkAllocationCallbacks; 

  3376.           pView:                        PVkBufferView

  3377.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3378. 

  3379.   TvkDestroyBufferView = procedure(

  3380.           device:                       VkDevice; 

  3381.           bufferView:                   VkBufferView; 

  3382.     const pAllocator:                   PVkAllocationCallbacks

  3383.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3384. 

  3385.   TvkCreateImage = function (

  3386.           device:                       VkDevice; 

  3387.     const pCreateInfo:                  PVkImageCreateInfo; 

  3388.     const pAllocator:                   PVkAllocationCallbacks; 

  3389.           pImage:                       PVkImage

  3390.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3391. 

  3392.   TvkDestroyImage = procedure(

  3393.           device:                       VkDevice; 

  3394.           image:                        VkImage; 

  3395.     const pAllocator:                   PVkAllocationCallbacks

  3396.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3397. 

  3398.   TvkGetImageSubresourceLayout = procedure(

  3399.           device:                       VkDevice; 

  3400.           image:                        VkImage; 

  3401.     const pSubresource:                 PVkImageSubresource; 

  3402.           pLayout:                      PVkSubresourceLayout

  3403.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3404. 

  3405.   TvkCreateImageView = function (

  3406.           device:                       VkDevice; 

  3407.     const pCreateInfo:                  PVkImageViewCreateInfo; 

  3408.     const pAllocator:                   PVkAllocationCallbacks; 

  3409.           pView:                        PVkImageView

  3410.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3411. 

  3412.   TvkDestroyImageView = procedure(

  3413.           device:                       VkDevice; 

  3414.           imageView:                    VkImageView; 

  3415.     const pAllocator:                   PVkAllocationCallbacks

  3416.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3417. 

  3418.   TvkCreateShaderModule = function (

  3419.           device:                       VkDevice; 

  3420.     const pCreateInfo:                  PVkShaderModuleCreateInfo; 

  3421.     const pAllocator:                   PVkAllocationCallbacks; 

  3422.           pShaderModule:                PVkShaderModule

  3423.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3424. 

  3425.   TvkDestroyShaderModule = procedure(

  3426.           device:                       VkDevice; 

  3427.           shaderModule:                 VkShaderModule; 

  3428.     const pAllocator:                   PVkAllocationCallbacks

  3429.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3430. 

  3431.   TvkCreatePipelineCache = function (

  3432.           device:                       VkDevice; 

  3433.     const pCreateInfo:                  PVkPipelineCacheCreateInfo; 

  3434.     const pAllocator:                   PVkAllocationCallbacks; 

  3435.           pPipelineCache:               PVkPipelineCache

  3436.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3437. 

  3438.   TvkDestroyPipelineCache = procedure(

  3439.           device:                       VkDevice; 

  3440.           pipelineCache:                VkPipelineCache; 

  3441.     const pAllocator:                   PVkAllocationCallbacks

  3442.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3443. 

  3444.   TvkGetPipelineCacheData = function (

  3445.           device:                       VkDevice; 

  3446.           pipelineCache:                VkPipelineCache; 

  3447.           pDataSize:                    PVkSize; 

  3448.           pData:                        PVkVoid

  3449.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3450. 

  3451.   TvkMergePipelineCaches = function (

  3452.           device:                       VkDevice; 

  3453.           dstCache:                     VkPipelineCache; 

  3454.           srcCacheCount:                VkUint32; 

  3455.     const pSrcCaches:                   PVkPipelineCache

  3456.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3457. 

  3458.   TvkCreateGraphicsPipelines = function (

  3459.           device:                       VkDevice; 

  3460.           pipelineCache:                VkPipelineCache; 

  3461.           createInfoCount:              VkUint32; 

  3462.     const pCreateInfos:                 PVkGraphicsPipelineCreateInfo; 

  3463.     const pAllocator:                   PVkAllocationCallbacks; 

  3464.           pPipelines:                   PVkPipeline

  3465.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3466. 

  3467.   TvkCreateComputePipelines = function (

  3468.           device:                       VkDevice; 

  3469.           pipelineCache:                VkPipelineCache; 

  3470.           createInfoCount:              VkUint32; 

  3471.     const pCreateInfos:                 PVkComputePipelineCreateInfo; 

  3472.     const pAllocator:                   PVkAllocationCallbacks; 

  3473.           pPipelines:                   PVkPipeline

  3474.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3475. 

  3476.   TvkDestroyPipeline = procedure(

  3477.           device:                       VkDevice; 

  3478.           pipeline:                     VkPipeline; 

  3479.     const pAllocator:                   PVkAllocationCallbacks

  3480.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3481. 

  3482.   TvkCreatePipelineLayout = function (

  3483.           device:                       VkDevice; 

  3484.     const pCreateInfo:                  PVkPipelineLayoutCreateInfo; 

  3485.     const pAllocator:                   PVkAllocationCallbacks; 

  3486.           pPipelineLayout:              PVkPipelineLayout

  3487.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3488. 

  3489.   TvkDestroyPipelineLayout = procedure(

  3490.           device:                       VkDevice; 

  3491.           pipelineLayout:               VkPipelineLayout; 

  3492.     const pAllocator:                   PVkAllocationCallbacks

  3493.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3494. 

  3495.   TvkCreateSampler = function (

  3496.           device:                       VkDevice; 

  3497.     const pCreateInfo:                  PVkSamplerCreateInfo; 

  3498.     const pAllocator:                   PVkAllocationCallbacks; 

  3499.           pSampler:                     PVkSampler

  3500.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3501. 

  3502.   TvkDestroySampler = procedure(

  3503.           device:                       VkDevice; 

  3504.           sampler:                      VkSampler; 

  3505.     const pAllocator:                   PVkAllocationCallbacks

  3506.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3507. 

  3508.   TvkCreateDescriptorSetLayout = function (

  3509.           device:                       VkDevice; 

  3510.     const pCreateInfo:                  PVkDescriptorSetLayoutCreateInfo; 

  3511.     const pAllocator:                   PVkAllocationCallbacks; 

  3512.           pSetLayout:                   PVkDescriptorSetLayout

  3513.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3514. 

  3515.   TvkDestroyDescriptorSetLayout = procedure(

  3516.           device:                       VkDevice; 

  3517.           descriptorSetLayout:          VkDescriptorSetLayout; 

  3518.     const pAllocator:                   PVkAllocationCallbacks

  3519.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3520. 

  3521.   TvkCreateDescriptorPool = function (

  3522.           device:                       VkDevice; 

  3523.     const pCreateInfo:                  PVkDescriptorPoolCreateInfo; 

  3524.     const pAllocator:                   PVkAllocationCallbacks; 

  3525.           pDescriptorPool:              PVkDescriptorPool

  3526.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3527. 

  3528.   TvkDestroyDescriptorPool = procedure(

  3529.           device:                       VkDevice; 

  3530.           descriptorPool:               VkDescriptorPool; 

  3531.     const pAllocator:                   PVkAllocationCallbacks

  3532.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3533. 

  3534.   TvkResetDescriptorPool = function (

  3535.           device:                       VkDevice; 

  3536.           descriptorPool:               VkDescriptorPool; 

  3537.           flags:                        VkDescriptorPoolResetFlags

  3538.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3539. 

  3540.   TvkAllocateDescriptorSets = function (

  3541.           device:                       VkDevice; 

  3542.     const pAllocateInfo:                PVkDescriptorSetAllocateInfo; 

  3543.           pDescriptorSets:              PVkDescriptorSet

  3544.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3545. 

  3546.   TvkFreeDescriptorSets = function (

  3547.           device:                       VkDevice; 

  3548.           descriptorPool:               VkDescriptorPool; 

  3549.           descriptorSetCount:           VkUint32; 

  3550.     const pDescriptorSets:              PVkDescriptorSet

  3551.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3552. 

  3553.   TvkUpdateDescriptorSets = procedure(

  3554.           device:                       VkDevice; 

  3555.           descriptorWriteCount:         VkUint32; 

  3556.     const pDescriptorWrites:            PVkWriteDescriptorSet; 

  3557.           descriptorCopyCount:          VkUint32; 

  3558.     const pDescriptorCopies:            PVkCopyDescriptorSet

  3559.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3560. 

  3561.   TvkCreateFramebuffer = function (

  3562.           device:                       VkDevice; 

  3563.     const pCreateInfo:                  PVkFramebufferCreateInfo; 

  3564.     const pAllocator:                   PVkAllocationCallbacks; 

  3565.           pFramebuffer:                 PVkFramebuffer

  3566.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3567. 

  3568.   TvkDestroyFramebuffer = procedure(

  3569.           device:                       VkDevice; 

  3570.           framebuffer:                  VkFramebuffer; 

  3571.     const pAllocator:                   PVkAllocationCallbacks

  3572.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3573. 

  3574.   TvkCreateRenderPass = function (

  3575.           device:                       VkDevice; 

  3576.     const pCreateInfo:                  PVkRenderPassCreateInfo; 

  3577.     const pAllocator:                   PVkAllocationCallbacks; 

  3578.           pRenderPass:                  PVkRenderPass

  3579.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3580. 

  3581.   TvkDestroyRenderPass = procedure(

  3582.           device:                       VkDevice; 

  3583.           renderPass:                   VkRenderPass; 

  3584.     const pAllocator:                   PVkAllocationCallbacks

  3585.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3586. 

  3587.   TvkGetRenderAreaGranularity = procedure(

  3588.           device:                       VkDevice; 

  3589.           renderPass:                   VkRenderPass; 

  3590.           pGranularity:                 PVkExtent2D

  3591.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3592. 

  3593.   TvkCreateCommandPool = function (

  3594.           device:                       VkDevice; 

  3595.     const pCreateInfo:                  PVkCommandPoolCreateInfo; 

  3596.     const pAllocator:                   PVkAllocationCallbacks; 

  3597.           pCommandPool:                 PVkCommandPool

  3598.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3599. 

  3600.   TvkDestroyCommandPool = procedure(

  3601.           device:                       VkDevice; 

  3602.           commandPool:                  VkCommandPool; 

  3603.     const pAllocator:                   PVkAllocationCallbacks

  3604.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3605. 

  3606.   TvkResetCommandPool = function (

  3607.           device:                       VkDevice; 

  3608.           commandPool:                  VkCommandPool; 

  3609.           flags:                        VkCommandPoolResetFlags

  3610.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3611. 

  3612.   TvkAllocateCommandBuffers = function (

  3613.           device:                       VkDevice; 

  3614.     const pAllocateInfo:                PVkCommandBufferAllocateInfo; 

  3615.           pCommandBuffers:              PVkCommandBuffer

  3616.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3617. 

  3618.   TvkFreeCommandBuffers = procedure(

  3619.           device:                       VkDevice; 

  3620.           commandPool:                  VkCommandPool; 

  3621.           commandBufferCount:           VkUint32; 

  3622.     const pCommandBuffers:              PVkCommandBuffer

  3623.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3624. 

  3625.   TvkBeginCommandBuffer = function (

  3626.           commandBuffer:                VkCommandBuffer; 

  3627.     const pBeginInfo:                   PVkCommandBufferBeginInfo

  3628.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3629. 

  3630.   TvkEndCommandBuffer = function (

  3631.           commandBuffer:                VkCommandBuffer

  3632.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3633. 

  3634.   TvkResetCommandBuffer = function (

  3635.           commandBuffer:                VkCommandBuffer; 

  3636.           flags:                        VkCommandBufferResetFlags

  3637.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3638. 

  3639.   TvkCmdBindPipeline = procedure(

  3640.           commandBuffer:                VkCommandBuffer; 

  3641.           pipelineBindPoint:            TVkPipelineBindPoint; 

  3642.           pipeline:                     VkPipeline

  3643.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3644. 

  3645.   TvkCmdSetViewport = procedure(

  3646.           commandBuffer:                VkCommandBuffer; 

  3647.           firstViewport:                VkUint32; 

  3648.           viewportCount:                VkUint32; 

  3649.     const pViewports:                   PVkViewport

  3650.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3651. 

  3652.   TvkCmdSetScissor = procedure(

  3653.           commandBuffer:                VkCommandBuffer; 

  3654.           firstScissor:                 VkUint32; 

  3655.           scissorCount:                 VkUint32; 

  3656.     const pScissors:                    PVkRect2D

  3657.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3658. 

  3659.   TvkCmdSetLineWidth = procedure(

  3660.           commandBuffer:                VkCommandBuffer; 

  3661.           lineWidth:                    VkFloat

  3662.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3663. 

  3664.   TvkCmdSetDepthBias = procedure(

  3665.           commandBuffer:                VkCommandBuffer; 

  3666.           depthBiasConstantFactor:      VkFloat; 

  3667.           depthBiasClamp:               VkFloat; 

  3668.           depthBiasSlopeFactor:         VkFloat

  3669.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3670. 

  3671.   TvkCmdSetBlendConstants = procedure(

  3672.           commandBuffer:                VkCommandBuffer; 

  3673.     const blendConstants:               VkFloat

  3674.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3675. 

  3676.   TvkCmdSetDepthBounds = procedure(

  3677.           commandBuffer:                VkCommandBuffer; 

  3678.           minDepthBounds:               VkFloat; 

  3679.           maxDepthBounds:               VkFloat

  3680.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3681. 

  3682.   TvkCmdSetStencilCompareMask = procedure(

  3683.           commandBuffer:                VkCommandBuffer; 

  3684.           faceMask:                     VkStencilFaceFlags; 

  3685.           compareMask:                  VkUint32

  3686.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3687. 

  3688.   TvkCmdSetStencilWriteMask = procedure(

  3689.           commandBuffer:                VkCommandBuffer; 

  3690.           faceMask:                     VkStencilFaceFlags; 

  3691.           writeMask:                    VkUint32

  3692.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3693. 

  3694.   TvkCmdSetStencilReference = procedure(

  3695.           commandBuffer:                VkCommandBuffer; 

  3696.           faceMask:                     VkStencilFaceFlags; 

  3697.           reference:                    VkUint32

  3698.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3699. 

  3700.   TvkCmdBindDescriptorSets = procedure(

  3701.           commandBuffer:                VkCommandBuffer; 

  3702.           pipelineBindPoint:            TVkPipelineBindPoint; 

  3703.           layout:                       VkPipelineLayout; 

  3704.           firstSet:                     VkUint32; 

  3705.           descriptorSetCount:           VkUint32; 

  3706.     const pDescriptorSets:              PVkDescriptorSet; 

  3707.           dynamicOffsetCount:           VkUint32; 

  3708.     const pDynamicOffsets:              PVkUint32

  3709.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3710. 

  3711.   TvkCmdBindIndexBuffer = procedure(

  3712.           commandBuffer:                VkCommandBuffer; 

  3713.           buffer:                       VkBuffer; 

  3714.           offset:                       VkDeviceSize; 

  3715.           indexType:                    TVkIndexType

  3716.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3717. 

  3718.   TvkCmdBindVertexBuffers = procedure(

  3719.           commandBuffer:                VkCommandBuffer; 

  3720.           firstBinding:                 VkUint32; 

  3721.           bindingCount:                 VkUint32; 

  3722.     const pBuffers:                     PVkBuffer; 

  3723.     const pOffsets:                     PVkDeviceSize

  3724.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3725. 

  3726.   TvkCmdDraw = procedure(

  3727.           commandBuffer:                VkCommandBuffer; 

  3728.           vertexCount:                  VkUint32; 

  3729.           instanceCount:                VkUint32; 

  3730.           firstVertex:                  VkUint32; 

  3731.           firstInstance:                VkUint32

  3732.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3733. 

  3734.   TvkCmdDrawIndexed = procedure(

  3735.           commandBuffer:                VkCommandBuffer; 

  3736.           indexCount:                   VkUint32; 

  3737.           instanceCount:                VkUint32; 

  3738.           firstIndex:                   VkUint32; 

  3739.           vertexOffset:                 VkInt32; 

  3740.           firstInstance:                VkUint32

  3741.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3742. 

  3743.   TvkCmdDrawIndirect = procedure(

  3744.           commandBuffer:                VkCommandBuffer; 

  3745.           buffer:                       VkBuffer; 

  3746.           offset:                       VkDeviceSize; 

  3747.           drawCount:                    VkUint32; 

  3748.           stride:                       VkUint32

  3749.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3750. 

  3751.   TvkCmdDrawIndexedIndirect = procedure(

  3752.           commandBuffer:                VkCommandBuffer; 

  3753.           buffer:                       VkBuffer; 

  3754.           offset:                       VkDeviceSize; 

  3755.           drawCount:                    VkUint32; 

  3756.           stride:                       VkUint32

  3757.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3758. 

  3759.   TvkCmdDispatch = procedure(

  3760.           commandBuffer:                VkCommandBuffer; 

  3761.           x:                            VkUint32; 

  3762.           y:                            VkUint32; 

  3763.           z:                            VkUint32

  3764.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3765. 

  3766.   TvkCmdDispatchIndirect = procedure(

  3767.           commandBuffer:                VkCommandBuffer; 

  3768.           buffer:                       VkBuffer; 

  3769.           offset:                       VkDeviceSize

  3770.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3771. 

  3772.   TvkCmdCopyBuffer = procedure(

  3773.           commandBuffer:                VkCommandBuffer; 

  3774.           srcBuffer:                    VkBuffer; 

  3775.           dstBuffer:                    VkBuffer; 

  3776.           regionCount:                  VkUint32; 

  3777.     const pRegions:                     PVkBufferCopy

  3778.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3779. 

  3780.   TvkCmdCopyImage = procedure(

  3781.           commandBuffer:                VkCommandBuffer; 

  3782.           srcImage:                     VkImage; 

  3783.           srcImageLayout:               TVkImageLayout; 

  3784.           dstImage:                     VkImage; 

  3785.           dstImageLayout:               TVkImageLayout; 

  3786.           regionCount:                  VkUint32; 

  3787.     const pRegions:                     PVkImageCopy

  3788.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3789. 

  3790.   TvkCmdBlitImage = procedure(

  3791.           commandBuffer:                VkCommandBuffer; 

  3792.           srcImage:                     VkImage; 

  3793.           srcImageLayout:               TVkImageLayout; 

  3794.           dstImage:                     VkImage; 

  3795.           dstImageLayout:               TVkImageLayout; 

  3796.           regionCount:                  VkUint32; 

  3797.     const pRegions:                     PVkImageBlit; 

  3798.           filter:                       TVkFilter

  3799.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3800. 

  3801.   TvkCmdCopyBufferToImage = procedure(

  3802.           commandBuffer:                VkCommandBuffer; 

  3803.           srcBuffer:                    VkBuffer; 

  3804.           dstImage:                     VkImage; 

  3805.           dstImageLayout:               TVkImageLayout; 

  3806.           regionCount:                  VkUint32; 

  3807.     const pRegions:                     PVkBufferImageCopy

  3808.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3809. 

  3810.   TvkCmdCopyImageToBuffer = procedure(

  3811.           commandBuffer:                VkCommandBuffer; 

  3812.           srcImage:                     VkImage; 

  3813.           srcImageLayout:               TVkImageLayout; 

  3814.           dstBuffer:                    VkBuffer; 

  3815.           regionCount:                  VkUint32; 

  3816.     const pRegions:                     PVkBufferImageCopy

  3817.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3818. 

  3819.   TvkCmdUpdateBuffer = procedure(

  3820.           commandBuffer:                VkCommandBuffer; 

  3821.           dstBuffer:                    VkBuffer; 

  3822.           dstOffset:                    VkDeviceSize; 

  3823.           dataSize:                     VkDeviceSize; 

  3824.     const pData:                        PVkUint32

  3825.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3826. 

  3827.   TvkCmdFillBuffer = procedure(

  3828.           commandBuffer:                VkCommandBuffer; 

  3829.           dstBuffer:                    VkBuffer; 

  3830.           dstOffset:                    VkDeviceSize; 

  3831.           size:                         VkDeviceSize; 

  3832.           data:                         VkUint32

  3833.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3834. 

  3835.   TvkCmdClearColorImage = procedure(

  3836.           commandBuffer:                VkCommandBuffer; 

  3837.           image:                        VkImage; 

  3838.           imageLayout:                  TVkImageLayout; 

  3839.     const pColor:                       PVkClearColorValue; 

  3840.           rangeCount:                   VkUint32; 

  3841.     const pRanges:                      PVkImageSubresourceRange

  3842.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3843. 

  3844.   TvkCmdClearDepthStencilImage = procedure(

  3845.           commandBuffer:                VkCommandBuffer; 

  3846.           image:                        VkImage; 

  3847.           imageLayout:                  TVkImageLayout; 

  3848.     const pDepthStencil:                PVkClearDepthStencilValue; 

  3849.           rangeCount:                   VkUint32; 

  3850.     const pRanges:                      PVkImageSubresourceRange

  3851.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3852. 

  3853.   TvkCmdClearAttachments = procedure(

  3854.           commandBuffer:                VkCommandBuffer; 

  3855.           attachmentCount:              VkUint32; 

  3856.     const pAttachments:                 PVkClearAttachment; 

  3857.           rectCount:                    VkUint32; 

  3858.     const pRects:                       PVkClearRect

  3859.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3860. 

  3861.   TvkCmdResolveImage = procedure(

  3862.           commandBuffer:                VkCommandBuffer; 

  3863.           srcImage:                     VkImage; 

  3864.           srcImageLayout:               TVkImageLayout; 

  3865.           dstImage:                     VkImage; 

  3866.           dstImageLayout:               TVkImageLayout; 

  3867.           regionCount:                  VkUint32; 

  3868.     const pRegions:                     PVkImageResolve

  3869.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3870. 

  3871.   TvkCmdSetEvent = procedure(

  3872.           commandBuffer:                VkCommandBuffer; 

  3873.           event:                        VkEvent; 

  3874.           stageMask:                    VkPipelineStageFlags

  3875.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3876. 

  3877.   TvkCmdResetEvent = procedure(

  3878.           commandBuffer:                VkCommandBuffer; 

  3879.           event:                        VkEvent; 

  3880.           stageMask:                    VkPipelineStageFlags

  3881.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3882. 

  3883.   TvkCmdWaitEvents = procedure(

  3884.           commandBuffer:                VkCommandBuffer; 

  3885.           eventCount:                   VkUint32; 

  3886.     const pEvents:                      PVkEvent; 

  3887.           srcStageMask:                 VkPipelineStageFlags; 

  3888.           dstStageMask:                 VkPipelineStageFlags; 

  3889.           memoryBarrierCount:           VkUint32; 

  3890.     const pMemoryBarriers:              PVkMemoryBarrier; 

  3891.           bufferMemoryBarrierCount:     VkUint32; 

  3892.     const pBufferMemoryBarriers:        PVkBufferMemoryBarrier; 

  3893.           imageMemoryBarrierCount:      VkUint32; 

  3894.     const pImageMemoryBarriers:         PVkImageMemoryBarrier

  3895.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3896. 

  3897.   TvkCmdPipelineBarrier = procedure(

  3898.           commandBuffer:                VkCommandBuffer; 

  3899.           srcStageMask:                 VkPipelineStageFlags; 

  3900.           dstStageMask:                 VkPipelineStageFlags; 

  3901.           dependencyFlags:              VkDependencyFlags; 

  3902.           memoryBarrierCount:           VkUint32; 

  3903.     const pMemoryBarriers:              PVkMemoryBarrier; 

  3904.           bufferMemoryBarrierCount:     VkUint32; 

  3905.     const pBufferMemoryBarriers:        PVkBufferMemoryBarrier; 

  3906.           imageMemoryBarrierCount:      VkUint32; 

  3907.     const pImageMemoryBarriers:         PVkImageMemoryBarrier

  3908.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3909. 

  3910.   TvkCmdBeginQuery = procedure(

  3911.           commandBuffer:                VkCommandBuffer; 

  3912.           queryPool:                    VkQueryPool; 

  3913.           query:                        VkUint32; 

  3914.           flags:                        VkQueryControlFlags

  3915.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3916. 

  3917.   TvkCmdEndQuery = procedure(

  3918.           commandBuffer:                VkCommandBuffer; 

  3919.           queryPool:                    VkQueryPool; 

  3920.           query:                        VkUint32

  3921.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3922. 

  3923.   TvkCmdResetQueryPool = procedure(

  3924.           commandBuffer:                VkCommandBuffer; 

  3925.           queryPool:                    VkQueryPool; 

  3926.           firstQuery:                   VkUint32; 

  3927.           queryCount:                   VkUint32

  3928.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3929. 

  3930.   TvkCmdWriteTimestamp = procedure(

  3931.           commandBuffer:                VkCommandBuffer; 

  3932.           pipelineStage:                TVkPipelineStageFlagBits; 

  3933.           queryPool:                    VkQueryPool; 

  3934.           query:                        VkUint32

  3935.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3936. 

  3937.   TvkCmdCopyQueryPoolResults = procedure(

  3938.           commandBuffer:                VkCommandBuffer; 

  3939.           queryPool:                    VkQueryPool; 

  3940.           firstQuery:                   VkUint32; 

  3941.           queryCount:                   VkUint32; 

  3942.           dstBuffer:                    VkBuffer; 

  3943.           dstOffset:                    VkDeviceSize; 

  3944.           stride:                       VkDeviceSize; 

  3945.           flags:                        VkQueryResultFlags

  3946.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3947. 

  3948.   TvkCmdPushConstants = procedure(

  3949.           commandBuffer:                VkCommandBuffer; 

  3950.           layout:                       VkPipelineLayout; 

  3951.           stageFlags:                   VkShaderStageFlags; 

  3952.           offset:                       VkUint32; 

  3953.           size:                         VkUint32; 

  3954.     const pValues:                      PVkVoid

  3955.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3956. 

  3957.   TvkCmdBeginRenderPass = procedure(

  3958.           commandBuffer:                VkCommandBuffer; 

  3959.     const pRenderPassBegin:             PVkRenderPassBeginInfo; 

  3960.           contents:                     TVkSubpassContents

  3961.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3962. 

  3963.   TvkCmdNextSubpass = procedure(

  3964.           commandBuffer:                VkCommandBuffer; 

  3965.           contents:                     TVkSubpassContents

  3966.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3967. 

  3968.   TvkCmdEndRenderPass = procedure(

  3969.           commandBuffer:                VkCommandBuffer

  3970.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3971. 

  3972.   TvkCmdExecuteCommands = procedure(

  3973.           commandBuffer:                VkCommandBuffer; 

  3974.           commandBufferCount:           VkUint32; 

  3975.     const pCommandBuffers:              PVkCommandBuffer

  3976.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3977. 

  3978. { ========================================== VK_KHR_surface ========================================== }

  3979.   TvkDestroySurfaceKHR = procedure(

  3980.           instance:                     VkInstance; 

  3981.           surface:                      VkSurfaceKHR; 

  3982.     const pAllocator:                   PVkAllocationCallbacks

  3983.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3984. 

  3985.   TvkGetPhysicalDeviceSurfaceSupportKHR = function (

  3986.           physicalDevice:               VkPhysicalDevice; 

  3987.           queueFamilyIndex:             VkUint32; 

  3988.           surface:                      VkSurfaceKHR; 

  3989.           pSupported:                   PVkBool32

  3990.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3991. 

  3992.   TvkGetPhysicalDeviceSurfaceCapabilitiesKHR = function (

  3993.           physicalDevice:               VkPhysicalDevice; 

  3994.           surface:                      VkSurfaceKHR; 

  3995.           pSurfaceCapabilities:         PVkSurfaceCapabilitiesKHR

  3996.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  3997. 

  3998.   TvkGetPhysicalDeviceSurfaceFormatsKHR = function (

  3999.           physicalDevice:               VkPhysicalDevice; 

  4000.           surface:                      VkSurfaceKHR; 

  4001.           pSurfaceFormatCount:          PVkUint32; 

  4002.           pSurfaceFormats:              PVkSurfaceFormatKHR

  4003.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4004. 

  4005.   TvkGetPhysicalDeviceSurfacePresentModesKHR = function (

  4006.           physicalDevice:               VkPhysicalDevice; 

  4007.           surface:                      VkSurfaceKHR; 

  4008.           pPresentModeCount:            PVkUint32; 

  4009.           pPresentModes:                PVkPresentModeKHR

  4010.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4011. 

  4012. { ========================================= VK_KHR_swapchain ========================================= }

  4013.   TvkCreateSwapchainKHR = function (

  4014.           device:                       VkDevice; 

  4015.     const pCreateInfo:                  PVkSwapchainCreateInfoKHR; 

  4016.     const pAllocator:                   PVkAllocationCallbacks; 

  4017.           pSwapchain:                   PVkSwapchainKHR

  4018.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4019. 

  4020.   TvkDestroySwapchainKHR = procedure(

  4021.           device:                       VkDevice; 

  4022.           swapchain:                    VkSwapchainKHR; 

  4023.     const pAllocator:                   PVkAllocationCallbacks

  4024.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4025. 

  4026.   TvkGetSwapchainImagesKHR = function (

  4027.           device:                       VkDevice; 

  4028.           swapchain:                    VkSwapchainKHR; 

  4029.           pSwapchainImageCount:         PVkUint32; 

  4030.           pSwapchainImages:             PVkImage

  4031.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4032. 

  4033.   TvkAcquireNextImageKHR = function (

  4034.           device:                       VkDevice; 

  4035.           swapchain:                    VkSwapchainKHR; 

  4036.           timeout:                      VkUint64; 

  4037.           semaphore:                    VkSemaphore; 

  4038.           fence:                        VkFence; 

  4039.           pImageIndex:                  PVkUint32

  4040.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4041. 

  4042.   TvkQueuePresentKHR = function (

  4043.           queue:                        VkQueue; 

  4044.     const pPresentInfo:                 PVkPresentInfoKHR

  4045.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4046. 

  4047. { ========================================== VK_KHR_display ========================================== }

  4048.   TvkGetPhysicalDeviceDisplayPropertiesKHR = function (

  4049.           physicalDevice:               VkPhysicalDevice; 

  4050.           pPropertyCount:               PVkUint32; 

  4051.           pProperties:                  PVkDisplayPropertiesKHR

  4052.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4053. 

  4054.   TvkGetPhysicalDeviceDisplayPlanePropertiesKHR = function (

  4055.           physicalDevice:               VkPhysicalDevice; 

  4056.           pPropertyCount:               PVkUint32; 

  4057.           pProperties:                  PVkDisplayPlanePropertiesKHR

  4058.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4059. 

  4060.   TvkGetDisplayPlaneSupportedDisplaysKHR = function (

  4061.           physicalDevice:               VkPhysicalDevice; 

  4062.           planeIndex:                   VkUint32; 

  4063.           pDisplayCount:                PVkUint32; 

  4064.           pDisplays:                    PVkDisplayKHR

  4065.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4066. 

  4067.   TvkGetDisplayModePropertiesKHR = function (

  4068.           physicalDevice:               VkPhysicalDevice; 

  4069.           display:                      VkDisplayKHR; 

  4070.           pPropertyCount:               PVkUint32; 

  4071.           pProperties:                  PVkDisplayModePropertiesKHR

  4072.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4073. 

  4074.   TvkCreateDisplayModeKHR = function (

  4075.           physicalDevice:               VkPhysicalDevice; 

  4076.           display:                      VkDisplayKHR; 

  4077.     const pCreateInfo:                  PVkDisplayModeCreateInfoKHR; 

  4078.     const pAllocator:                   PVkAllocationCallbacks; 

  4079.           pMode:                        PVkDisplayModeKHR

  4080.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4081. 

  4082.   TvkGetDisplayPlaneCapabilitiesKHR = function (

  4083.           physicalDevice:               VkPhysicalDevice; 

  4084.           mode:                         VkDisplayModeKHR; 

  4085.           planeIndex:                   VkUint32; 

  4086.           pCapabilities:                PVkDisplayPlaneCapabilitiesKHR

  4087.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4088. 

  4089.   TvkCreateDisplayPlaneSurfaceKHR = function (

  4090.           instance:                     VkInstance; 

  4091.     const pCreateInfo:                  PVkDisplaySurfaceCreateInfoKHR; 

  4092.     const pAllocator:                   PVkAllocationCallbacks; 

  4093.           pSurface:                     PVkSurfaceKHR

  4094.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4095. 

  4096. { ===================================== VK_KHR_display_swapchain ===================================== }

  4097.   TvkCreateSharedSwapchainsKHR = function (

  4098.           device:                       VkDevice; 

  4099.           swapchainCount:               VkUint32; 

  4100.     const pCreateInfos:                 PVkSwapchainCreateInfoKHR; 

  4101.     const pAllocator:                   PVkAllocationCallbacks; 

  4102.           pSwapchains:                  PVkSwapchainKHR

  4103.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4104. 

  4105. { ======================================= VK_KHR_xlib_surface ======================================== }

  4106. {$IFDEF VK_USE_PLATFORM_XLIB_KHR}

  4107.   TvkCreateXlibSurfaceKHR = function (

  4108.           instance:                     VkInstance; 

  4109.     const pCreateInfo:                  PVkXlibSurfaceCreateInfoKHR; 

  4110.     const pAllocator:                   PVkAllocationCallbacks; 

  4111.           pSurface:                     PVkSurfaceKHR

  4112.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4113. 

  4114.   TvkGetPhysicalDeviceXlibPresentationSupportKHR = function (

  4115.           physicalDevice:               VkPhysicalDevice; 

  4116.           queueFamilyIndex:             VkUint32; 

  4117.           dpy:                          Display; 

  4118.           visualID:                     VisualID

  4119.   ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4120. {$ENDIF}

  4121. 

  4122. { ======================================== VK_KHR_xcb_surface ======================================== }

  4123. {$IFDEF VK_USE_PLATFORM_XCB_KHR}

  4124.   TvkCreateXcbSurfaceKHR = function (

  4125.           instance:                     VkInstance; 

  4126.     const pCreateInfo:                  PVkXcbSurfaceCreateInfoKHR; 

  4127.     const pAllocator:                   PVkAllocationCallbacks; 

  4128.           pSurface:                     PVkSurfaceKHR

  4129.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4130. 

  4131.   TvkGetPhysicalDeviceXcbPresentationSupportKHR = function (

  4132.           physicalDevice:               VkPhysicalDevice; 

  4133.           queueFamilyIndex:             VkUint32; 

  4134.           connection:                   xcb_connection_t; 

  4135.           visual_id:                    xcb_visualid_t

  4136.   ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4137. {$ENDIF}

  4138. 

  4139. { ====================================== VK_KHR_wayland_surface ====================================== }

  4140. {$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}

  4141.   TvkCreateWaylandSurfaceKHR = function (

  4142.           instance:                     VkInstance; 

  4143.     const pCreateInfo:                  PVkWaylandSurfaceCreateInfoKHR; 

  4144.     const pAllocator:                   PVkAllocationCallbacks; 

  4145.           pSurface:                     PVkSurfaceKHR

  4146.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4147. 

  4148.   TvkGetPhysicalDeviceWaylandPresentationSupportKHR = function (

  4149.           physicalDevice:               VkPhysicalDevice; 

  4150.           queueFamilyIndex:             VkUint32; 

  4151.           display:                      wl_display

  4152.   ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4153. {$ENDIF}

  4154. 

  4155. { ======================================== VK_KHR_mir_surface ======================================== }

  4156. {$IFDEF VK_USE_PLATFORM_MIR_KHR}

  4157.   TvkCreateMirSurfaceKHR = function (

  4158.           instance:                     VkInstance; 

  4159.     const pCreateInfo:                  PVkMirSurfaceCreateInfoKHR; 

  4160.     const pAllocator:                   PVkAllocationCallbacks; 

  4161.           pSurface:                     PVkSurfaceKHR

  4162.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4163. 

  4164.   TvkGetPhysicalDeviceMirPresentationSupportKHR = function (

  4165.           physicalDevice:               VkPhysicalDevice; 

  4166.           queueFamilyIndex:             VkUint32; 

  4167.           connection:                   MirConnection

  4168.   ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4169. {$ENDIF}

  4170. 

  4171. { ====================================== VK_KHR_android_surface ====================================== }

  4172. {$IFDEF VK_USE_PLATFORM_ANDROID_KHR}

  4173.   TvkCreateAndroidSurfaceKHR = function (

  4174.           instance:                     VkInstance; 

  4175.     const pCreateInfo:                  PVkAndroidSurfaceCreateInfoKHR; 

  4176.     const pAllocator:                   PVkAllocationCallbacks; 

  4177.           pSurface:                     PVkSurfaceKHR

  4178.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4179. {$ENDIF}

  4180. 

  4181. { ======================================= VK_KHR_win32_surface ======================================= }

  4182. {$IFDEF VK_USE_PLATFORM_WIN32_KHR}

  4183.   TvkCreateWin32SurfaceKHR = function (

  4184.           instance:                     VkInstance; 

  4185.     const pCreateInfo:                  PVkWin32SurfaceCreateInfoKHR; 

  4186.     const pAllocator:                   PVkAllocationCallbacks; 

  4187.           pSurface:                     PVkSurfaceKHR

  4188.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4189. 

  4190.   TvkGetPhysicalDeviceWin32PresentationSupportKHR = function (

  4191.           physicalDevice:               VkPhysicalDevice; 

  4192.           queueFamilyIndex:             VkUint32

  4193.   ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4194. {$ENDIF}

  4195. 

  4196. { ======================================= VK_EXT_debug_report ======================================== }

  4197.   TvkCreateDebugReportCallbackEXT = function (

  4198.           instance:                     VkInstance; 

  4199.     const pCreateInfo:                  PVkDebugReportCallbackCreateInfoEXT; 

  4200.     const pAllocator:                   PVkAllocationCallbacks; 

  4201.           pCallback:                    PVkDebugReportCallbackEXT

  4202.   ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4203. 

  4204.   TvkDestroyDebugReportCallbackEXT = procedure(

  4205.           instance:                     VkInstance; 

  4206.           callback:                     VkDebugReportCallbackEXT; 

  4207.     const pAllocator:                   PVkAllocationCallbacks

  4208.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4209. 

  4210.   TvkDebugReportMessageEXT = procedure(

  4211.           instance:                     VkInstance; 

  4212.           flags:                        VkDebugReportFlagsEXT; 

  4213.           objectType:                   TVkDebugReportObjectTypeEXT; 

  4214.           uObject:                      VkUint64; 

  4215.           location:                     VkSize; 

  4216.           messageCode:                  VkInt32; 

  4217.     const pLayerPrefix:                 PVkChar; 

  4218.     const pMessage:                     PVkChar

  4219.   ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  4220. 

  4221. var

  4222. 

  4223. { ========================================== VK_VERSION_1_0 ========================================== }

  4224.   vkCreateInstance:                                 TvkCreateInstance;

  4225.   vkGetInstanceProcAddr:                            TvkGetInstanceProcAddr;

  4226.   vkEnumerateInstanceExtensionProperties:           TvkEnumerateInstanceExtensionProperties;

  4227.   vkEnumerateInstanceLayerProperties:               TvkEnumerateInstanceLayerProperties;

  4228. 

  4229. type

  4230.   TVkInstanceCommands = packed record

  4231.     Instance: VkInstance;

  4232.     

  4233.     { ========================================== VK_VERSION_1_0 ========================================== }

  4234.     vkDestroyInstance:                                TvkDestroyInstance;

  4235.     vkEnumeratePhysicalDevices:                       TvkEnumeratePhysicalDevices;

  4236.     vkGetPhysicalDeviceFeatures:                      TvkGetPhysicalDeviceFeatures;

  4237.     vkGetPhysicalDeviceFormatProperties:              TvkGetPhysicalDeviceFormatProperties;

  4238.     vkGetPhysicalDeviceImageFormatProperties:         TvkGetPhysicalDeviceImageFormatProperties;

  4239.     vkGetPhysicalDeviceProperties:                    TvkGetPhysicalDeviceProperties;

  4240.     vkGetPhysicalDeviceQueueFamilyProperties:         TvkGetPhysicalDeviceQueueFamilyProperties;

  4241.     vkGetPhysicalDeviceMemoryProperties:              TvkGetPhysicalDeviceMemoryProperties;

  4242.     vkGetDeviceProcAddr:                              TvkGetDeviceProcAddr;

  4243.     vkCreateDevice:                                   TvkCreateDevice;

  4244.     vkEnumerateDeviceExtensionProperties:             TvkEnumerateDeviceExtensionProperties;

  4245.     vkEnumerateDeviceLayerProperties:                 TvkEnumerateDeviceLayerProperties;

  4246.     vkGetPhysicalDeviceSparseImageFormatProperties:   TvkGetPhysicalDeviceSparseImageFormatProperties;

  4247.     

  4248.     { ========================================== VK_KHR_surface ========================================== }

  4249.     vkDestroySurfaceKHR:                              TvkDestroySurfaceKHR;

  4250.     vkGetPhysicalDeviceSurfaceSupportKHR:             TvkGetPhysicalDeviceSurfaceSupportKHR;

  4251.     vkGetPhysicalDeviceSurfaceCapabilitiesKHR:        TvkGetPhysicalDeviceSurfaceCapabilitiesKHR;

  4252.     vkGetPhysicalDeviceSurfaceFormatsKHR:             TvkGetPhysicalDeviceSurfaceFormatsKHR;

  4253.     vkGetPhysicalDeviceSurfacePresentModesKHR:        TvkGetPhysicalDeviceSurfacePresentModesKHR;

  4254.     

  4255.     { ========================================== VK_KHR_display ========================================== }

  4256.     vkGetPhysicalDeviceDisplayPropertiesKHR:          TvkGetPhysicalDeviceDisplayPropertiesKHR;

  4257.     vkGetPhysicalDeviceDisplayPlanePropertiesKHR:     TvkGetPhysicalDeviceDisplayPlanePropertiesKHR;

  4258.     vkGetDisplayPlaneSupportedDisplaysKHR:            TvkGetDisplayPlaneSupportedDisplaysKHR;

  4259.     vkGetDisplayModePropertiesKHR:                    TvkGetDisplayModePropertiesKHR;

  4260.     vkCreateDisplayModeKHR:                           TvkCreateDisplayModeKHR;

  4261.     vkGetDisplayPlaneCapabilitiesKHR:                 TvkGetDisplayPlaneCapabilitiesKHR;

  4262.     vkCreateDisplayPlaneSurfaceKHR:                   TvkCreateDisplayPlaneSurfaceKHR;

  4263.     

  4264.     { ======================================= VK_KHR_xlib_surface ======================================== }

  4265.     {$IFDEF VK_USE_PLATFORM_XLIB_KHR}

  4266.     vkCreateXlibSurfaceKHR:                           TvkCreateXlibSurfaceKHR;

  4267.     vkGetPhysicalDeviceXlibPresentationSupportKHR:    TvkGetPhysicalDeviceXlibPresentationSupportKHR;

  4268.     {$ENDIF}

  4269.     

  4270.     { ======================================== VK_KHR_xcb_surface ======================================== }

  4271.     {$IFDEF VK_USE_PLATFORM_XCB_KHR}

  4272.     vkCreateXcbSurfaceKHR:                            TvkCreateXcbSurfaceKHR;

  4273.     vkGetPhysicalDeviceXcbPresentationSupportKHR:     TvkGetPhysicalDeviceXcbPresentationSupportKHR;

  4274.     {$ENDIF}

  4275.     

  4276.     { ====================================== VK_KHR_wayland_surface ====================================== }

  4277.     {$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}

  4278.     vkCreateWaylandSurfaceKHR:                        TvkCreateWaylandSurfaceKHR;

  4279.     vkGetPhysicalDeviceWaylandPresentationSupportKHR: TvkGetPhysicalDeviceWaylandPresentationSupportKHR;

  4280.     {$ENDIF}

  4281.     

  4282.     { ======================================== VK_KHR_mir_surface ======================================== }

  4283.     {$IFDEF VK_USE_PLATFORM_MIR_KHR}

  4284.     vkCreateMirSurfaceKHR:                            TvkCreateMirSurfaceKHR;

  4285.     vkGetPhysicalDeviceMirPresentationSupportKHR:     TvkGetPhysicalDeviceMirPresentationSupportKHR;

  4286.     {$ENDIF}

  4287.     

  4288.     { ====================================== VK_KHR_android_surface ====================================== }

  4289.     {$IFDEF VK_USE_PLATFORM_ANDROID_KHR}

  4290.     vkCreateAndroidSurfaceKHR:                        TvkCreateAndroidSurfaceKHR;

  4291.     {$ENDIF}

  4292.     

  4293.     { ======================================= VK_KHR_win32_surface ======================================= }

  4294.     {$IFDEF VK_USE_PLATFORM_WIN32_KHR}

  4295.     vkCreateWin32SurfaceKHR:                          TvkCreateWin32SurfaceKHR;

  4296.     vkGetPhysicalDeviceWin32PresentationSupportKHR:   TvkGetPhysicalDeviceWin32PresentationSupportKHR;

  4297.     {$ENDIF}

  4298.     

  4299.     { ======================================= VK_EXT_debug_report ======================================== }

  4300.     vkCreateDebugReportCallbackEXT:                   TvkCreateDebugReportCallbackEXT;

  4301.     vkDestroyDebugReportCallbackEXT:                  TvkDestroyDebugReportCallbackEXT;

  4302.     vkDebugReportMessageEXT:                          TvkDebugReportMessageEXT;

  4303. 

  4304.   end;

  4305. 

  4306.   TVkDeviceCommands = packed record

  4307.     Device: VkDevice;

  4308.     

  4309.     { ========================================== VK_VERSION_1_0 ========================================== }

  4310.     vkDestroyDevice:                                  TvkDestroyDevice;

  4311.     vkGetDeviceQueue:                                 TvkGetDeviceQueue;

  4312.     vkQueueSubmit:                                    TvkQueueSubmit;

  4313.     vkQueueWaitIdle:                                  TvkQueueWaitIdle;

  4314.     vkDeviceWaitIdle:                                 TvkDeviceWaitIdle;

  4315.     vkAllocateMemory:                                 TvkAllocateMemory;

  4316.     vkFreeMemory:                                     TvkFreeMemory;

  4317.     vkMapMemory:                                      TvkMapMemory;

  4318.     vkUnmapMemory:                                    TvkUnmapMemory;

  4319.     vkFlushMappedMemoryRanges:                        TvkFlushMappedMemoryRanges;

  4320.     vkInvalidateMappedMemoryRanges:                   TvkInvalidateMappedMemoryRanges;

  4321.     vkGetDeviceMemoryCommitment:                      TvkGetDeviceMemoryCommitment;

  4322.     vkBindBufferMemory:                               TvkBindBufferMemory;

  4323.     vkBindImageMemory:                                TvkBindImageMemory;

  4324.     vkGetBufferMemoryRequirements:                    TvkGetBufferMemoryRequirements;

  4325.     vkGetImageMemoryRequirements:                     TvkGetImageMemoryRequirements;

  4326.     vkGetImageSparseMemoryRequirements:               TvkGetImageSparseMemoryRequirements;

  4327.     vkQueueBindSparse:                                TvkQueueBindSparse;

  4328.     vkCreateFence:                                    TvkCreateFence;

  4329.     vkDestroyFence:                                   TvkDestroyFence;

  4330.     vkResetFences:                                    TvkResetFences;

  4331.     vkGetFenceStatus:                                 TvkGetFenceStatus;

  4332.     vkWaitForFences:                                  TvkWaitForFences;

  4333.     vkCreateSemaphore:                                TvkCreateSemaphore;

  4334.     vkDestroySemaphore:                               TvkDestroySemaphore;

  4335.     vkCreateEvent:                                    TvkCreateEvent;

  4336.     vkDestroyEvent:                                   TvkDestroyEvent;

  4337.     vkGetEventStatus:                                 TvkGetEventStatus;

  4338.     vkSetEvent:                                       TvkSetEvent;

  4339.     vkResetEvent:                                     TvkResetEvent;

  4340.     vkCreateQueryPool:                                TvkCreateQueryPool;

  4341.     vkDestroyQueryPool:                               TvkDestroyQueryPool;

  4342.     vkGetQueryPoolResults:                            TvkGetQueryPoolResults;

  4343.     vkCreateBuffer:                                   TvkCreateBuffer;

  4344.     vkDestroyBuffer:                                  TvkDestroyBuffer;

  4345.     vkCreateBufferView:                               TvkCreateBufferView;

  4346.     vkDestroyBufferView:                              TvkDestroyBufferView;

  4347.     vkCreateImage:                                    TvkCreateImage;

  4348.     vkDestroyImage:                                   TvkDestroyImage;

  4349.     vkGetImageSubresourceLayout:                      TvkGetImageSubresourceLayout;

  4350.     vkCreateImageView:                                TvkCreateImageView;

  4351.     vkDestroyImageView:                               TvkDestroyImageView;

  4352.     vkCreateShaderModule:                             TvkCreateShaderModule;

  4353.     vkDestroyShaderModule:                            TvkDestroyShaderModule;

  4354.     vkCreatePipelineCache:                            TvkCreatePipelineCache;

  4355.     vkDestroyPipelineCache:                           TvkDestroyPipelineCache;

  4356.     vkGetPipelineCacheData:                           TvkGetPipelineCacheData;

  4357.     vkMergePipelineCaches:                            TvkMergePipelineCaches;

  4358.     vkCreateGraphicsPipelines:                        TvkCreateGraphicsPipelines;

  4359.     vkCreateComputePipelines:                         TvkCreateComputePipelines;

  4360.     vkDestroyPipeline:                                TvkDestroyPipeline;

  4361.     vkCreatePipelineLayout:                           TvkCreatePipelineLayout;

  4362.     vkDestroyPipelineLayout:                          TvkDestroyPipelineLayout;

  4363.     vkCreateSampler:                                  TvkCreateSampler;

  4364.     vkDestroySampler:                                 TvkDestroySampler;

  4365.     vkCreateDescriptorSetLayout:                      TvkCreateDescriptorSetLayout;

  4366.     vkDestroyDescriptorSetLayout:                     TvkDestroyDescriptorSetLayout;

  4367.     vkCreateDescriptorPool:                           TvkCreateDescriptorPool;

  4368.     vkDestroyDescriptorPool:                          TvkDestroyDescriptorPool;

  4369.     vkResetDescriptorPool:                            TvkResetDescriptorPool;

  4370.     vkAllocateDescriptorSets:                         TvkAllocateDescriptorSets;

  4371.     vkFreeDescriptorSets:                             TvkFreeDescriptorSets;

  4372.     vkUpdateDescriptorSets:                           TvkUpdateDescriptorSets;

  4373.     vkCreateFramebuffer:                              TvkCreateFramebuffer;

  4374.     vkDestroyFramebuffer:                             TvkDestroyFramebuffer;

  4375.     vkCreateRenderPass:                               TvkCreateRenderPass;

  4376.     vkDestroyRenderPass:                              TvkDestroyRenderPass;

  4377.     vkGetRenderAreaGranularity:                       TvkGetRenderAreaGranularity;

  4378.     vkCreateCommandPool:                              TvkCreateCommandPool;

  4379.     vkDestroyCommandPool:                             TvkDestroyCommandPool;

  4380.     vkResetCommandPool:                               TvkResetCommandPool;

  4381.     vkAllocateCommandBuffers:                         TvkAllocateCommandBuffers;

  4382.     vkFreeCommandBuffers:                             TvkFreeCommandBuffers;

  4383.     vkBeginCommandBuffer:                             TvkBeginCommandBuffer;

  4384.     vkEndCommandBuffer:                               TvkEndCommandBuffer;

  4385.     vkResetCommandBuffer:                             TvkResetCommandBuffer;

  4386.     vkCmdBindPipeline:                                TvkCmdBindPipeline;

  4387.     vkCmdSetViewport:                                 TvkCmdSetViewport;

  4388.     vkCmdSetScissor:                                  TvkCmdSetScissor;

  4389.     vkCmdSetLineWidth:                                TvkCmdSetLineWidth;

  4390.     vkCmdSetDepthBias:                                TvkCmdSetDepthBias;

  4391.     vkCmdSetBlendConstants:                           TvkCmdSetBlendConstants;

  4392.     vkCmdSetDepthBounds:                              TvkCmdSetDepthBounds;

  4393.     vkCmdSetStencilCompareMask:                       TvkCmdSetStencilCompareMask;

  4394.     vkCmdSetStencilWriteMask:                         TvkCmdSetStencilWriteMask;

  4395.     vkCmdSetStencilReference:                         TvkCmdSetStencilReference;

  4396.     vkCmdBindDescriptorSets:                          TvkCmdBindDescriptorSets;

  4397.     vkCmdBindIndexBuffer:                             TvkCmdBindIndexBuffer;

  4398.     vkCmdBindVertexBuffers:                           TvkCmdBindVertexBuffers;

  4399.     vkCmdDraw:                                        TvkCmdDraw;

  4400.     vkCmdDrawIndexed:                                 TvkCmdDrawIndexed;

  4401.     vkCmdDrawIndirect:                                TvkCmdDrawIndirect;

  4402.     vkCmdDrawIndexedIndirect:                         TvkCmdDrawIndexedIndirect;

  4403.     vkCmdDispatch:                                    TvkCmdDispatch;

  4404.     vkCmdDispatchIndirect:                            TvkCmdDispatchIndirect;

  4405.     vkCmdCopyBuffer:                                  TvkCmdCopyBuffer;

  4406.     vkCmdCopyImage:                                   TvkCmdCopyImage;

  4407.     vkCmdBlitImage:                                   TvkCmdBlitImage;

  4408.     vkCmdCopyBufferToImage:                           TvkCmdCopyBufferToImage;

  4409.     vkCmdCopyImageToBuffer:                           TvkCmdCopyImageToBuffer;

  4410.     vkCmdUpdateBuffer:                                TvkCmdUpdateBuffer;

  4411.     vkCmdFillBuffer:                                  TvkCmdFillBuffer;

  4412.     vkCmdClearColorImage:                             TvkCmdClearColorImage;

  4413.     vkCmdClearDepthStencilImage:                      TvkCmdClearDepthStencilImage;

  4414.     vkCmdClearAttachments:                            TvkCmdClearAttachments;

  4415.     vkCmdResolveImage:                                TvkCmdResolveImage;

  4416.     vkCmdSetEvent:                                    TvkCmdSetEvent;

  4417.     vkCmdResetEvent:                                  TvkCmdResetEvent;

  4418.     vkCmdWaitEvents:                                  TvkCmdWaitEvents;

  4419.     vkCmdPipelineBarrier:                             TvkCmdPipelineBarrier;

  4420.     vkCmdBeginQuery:                                  TvkCmdBeginQuery;

  4421.     vkCmdEndQuery:                                    TvkCmdEndQuery;

  4422.     vkCmdResetQueryPool:                              TvkCmdResetQueryPool;

  4423.     vkCmdWriteTimestamp:                              TvkCmdWriteTimestamp;

  4424.     vkCmdCopyQueryPoolResults:                        TvkCmdCopyQueryPoolResults;

  4425.     vkCmdPushConstants:                               TvkCmdPushConstants;

  4426.     vkCmdBeginRenderPass:                             TvkCmdBeginRenderPass;

  4427.     vkCmdNextSubpass:                                 TvkCmdNextSubpass;

  4428.     vkCmdEndRenderPass:                               TvkCmdEndRenderPass;

  4429.     vkCmdExecuteCommands:                             TvkCmdExecuteCommands;

  4430.     

  4431.     { ========================================= VK_KHR_swapchain ========================================= }

  4432.     vkCreateSwapchainKHR:                             TvkCreateSwapchainKHR;

  4433.     vkDestroySwapchainKHR:                            TvkDestroySwapchainKHR;

  4434.     vkGetSwapchainImagesKHR:                          TvkGetSwapchainImagesKHR;

  4435.     vkAcquireNextImageKHR:                            TvkAcquireNextImageKHR;

  4436.     vkQueuePresentKHR:                                TvkQueuePresentKHR;

  4437.     

  4438.     { ===================================== VK_KHR_display_swapchain ===================================== }

  4439.     vkCreateSharedSwapchainsKHR:                      TvkCreateSharedSwapchainsKHR;

  4440. 

  4441.   end;

  4442. 

  4443. const

  4444.   VULKAN_LIBNAME = 'vulkan-1.dll';

  4445. 

  4446. type

  4447.   VkVersion = VkInt32;

  4448. 

  4449. function vkMakeVersion(const aMajor, aMinor, aPatch: Integer): VkVersion; inline;

  4450. function vkGetVersionMajor(const aVersion: VkVersion): Integer; inline;

  4451. function vkGetVersionMinor(const aVersion: VkVersion): Integer; inline;

  4452. function vkGetVersionPatch(const aVersion: VkVersion): Integer; inline;

  4453. 

  4454. function  InitializeVulkan(const aLibName: String = VULKAN_LIBNAME): Boolean;

  4455. function  LoadInstanceCommands(const aInstance: VkInstance; out aCommands: TVkInstanceCommands): Boolean;

  4456. function  LoadDeviceCommands(const aInstance: VkInstance; const aDevice: VkDevice; out aCommands: TVkDeviceCommands): Boolean;

  4457. procedure FinalizeVulkan;

  4458. 

  4459. implementation

  4460. 

  4461. type

  4462. {$IF DEFINED(VK_WIN)}

  4463.   TvkLibHandle = TLibHandle;

  4464. {$ELSE}

  4465.   TvkLibHandle = Pointer;

  4466. {$ENDIF}

  4467. 

  4468. const

  4469. {$IF DEFINED(VK_WIN)}

  4470.   InvalidLibHandle = 0;

  4471. {$ELSE}

  4472.   InvalidLibHandle = nil;

  4473. {$ENDIF}

  4474. 

  4475. var

  4476.   vkLibHandle: TvkLibHandle = InvalidLibHandle;

  4477. 

  4478. { ===================================== Library Handling ============================================= }

  4479. function vkLoadLibrary(const aLibName: String): TvkLibHandle;

  4480. begin

  4481.   {$IF DEFINED(VK_WIN)}

  4482.   result := LoadLibrary(aLibName);

  4483.   {$ELSE}

  4484.   result := InvalidLibHandle;

  4485.   {$ENDIF}

  4486. end;

  4487. 

  4488. function vkGetProcAddress(const aProcName: String; aLibHandle: TvkLibHandle = InvalidLibHandle): TvkVoidFunction;

  4489. begin

  4490.   result := nil;

  4491.   if (aLibHandle = InvalidLibHandle) then

  4492.     aLibHandle := vkLibHandle;

  4493.   {$IF DEFINED(VK_WIN)}

  4494.   result := TvkVoidFunction(GetProcAddress(aLibHandle, AnsiString(aProcName)));

  4495.   {$ELSE}

  4496.   result := nil;

  4497.   {$ENDIF}

  4498. end;

  4499. 

  4500. procedure vkFreeLibrary(var aLibHandle: TvkLibHandle);

  4501. begin

  4502.   if (aLibHandle <> InvalidLibHandle) then begin

  4503.     {$IF DEFINED(VK_WIN)}

  4504.     FreeLibrary(aLibHandle);

  4505.     {$ENDIF}

  4506.     aLibHandle := InvalidLibHandle;

  4507.   end;

  4508. end;

  4509. 

  4510. { ===================================== Vulkan Version Helpers ======================================= }

  4511. function vkMakeVersion(const aMajor, aMinor, aPatch: Integer): VkVersion;

  4512. begin

  4513.   result := (aMajor shl 22) or (aMinor shl 12) or aPatch;

  4514. end;

  4515. 

  4516. function vkGetVersionMajor(const aVersion: VkVersion): Integer;

  4517. begin

  4518.   result := (aVersion shr 22);

  4519. end;

  4520. 

  4521. function vkGetVersionMinor(const aVersion: VkVersion): Integer;

  4522. begin

  4523.   result := (aVersion shr 12) and $3FF;

  4524. end;

  4525. 

  4526. function vkGetVersionPatch(const aVersion: VkVersion): Integer;

  4527. begin

  4528.   result := (aVersion and $FFF);

  4529. end;

  4530. 

  4531. { ===================================== Initialize Routines ========================================== }

  4532. function InitializeVulkan(const aLibName: String = VULKAN_LIBNAME): Boolean;

  4533. var success: Boolean;

  4534. 

  4535.   function GetProcAddress(const aName: String): TvkVoidFunction;

  4536.   begin

  4537.     result := vkGetProcAddress(aName);

  4538.     if not Assigned(result) then

  4539.       success := false;

  4540.   end;

  4541. 

  4542. begin

  4543.   FinalizeVulkan;

  4544.   vkLibHandle := vkLoadLibrary(aLibName);

  4545.   success := (vkLibHandle <> InvalidLibHandle);

  4546.   if not success then

  4547.     exit;

  4548.   

  4549.   vkCreateInstance                                   := TvkCreateInstance                                  (GetProcAddress('vkCreateInstance'));

  4550.   vkGetInstanceProcAddr                              := TvkGetInstanceProcAddr                             (GetProcAddress('vkGetInstanceProcAddr'));

  4551.   vkEnumerateInstanceExtensionProperties             := TvkEnumerateInstanceExtensionProperties            (GetProcAddress('vkEnumerateInstanceExtensionProperties'));

  4552.   vkEnumerateInstanceLayerProperties                 := TvkEnumerateInstanceLayerProperties                (GetProcAddress('vkEnumerateInstanceLayerProperties'));

  4553. 

  4554.   result := success;

  4555. end;

  4556. 

  4557. function LoadInstanceCommands(const aInstance: VkInstance; out aCommands: TVkInstanceCommands): Boolean;

  4558. var 

  4559.   success: Boolean;

  4560. 

  4561.   function GetProcAddress(const aName: String): TvkVoidFunction;

  4562.   begin

  4563.     result := vkGetInstanceProcAddr(aInstance, PVkChar(aName));

  4564.     if not Assigned(result) then

  4565.       success := false;

  4566.   end;

  4567. 

  4568. begin

  4569.   FillByte(aCommands, SizeOf(aCommands), 0);

  4570.   success := true;

  4571.   with aCommands do begin

  4572.     

  4573.     { ========================================== VK_VERSION_1_0 ========================================== }

  4574.     vkDestroyInstance                                  := TvkDestroyInstance                                 (GetProcAddress('vkDestroyInstance'));

  4575.     vkEnumeratePhysicalDevices                         := TvkEnumeratePhysicalDevices                        (GetProcAddress('vkEnumeratePhysicalDevices'));

  4576.     vkGetPhysicalDeviceFeatures                        := TvkGetPhysicalDeviceFeatures                       (GetProcAddress('vkGetPhysicalDeviceFeatures'));

  4577.     vkGetPhysicalDeviceFormatProperties                := TvkGetPhysicalDeviceFormatProperties               (GetProcAddress('vkGetPhysicalDeviceFormatProperties'));

  4578.     vkGetPhysicalDeviceImageFormatProperties           := TvkGetPhysicalDeviceImageFormatProperties          (GetProcAddress('vkGetPhysicalDeviceImageFormatProperties'));

  4579.     vkGetPhysicalDeviceProperties                      := TvkGetPhysicalDeviceProperties                     (GetProcAddress('vkGetPhysicalDeviceProperties'));

  4580.     vkGetPhysicalDeviceQueueFamilyProperties           := TvkGetPhysicalDeviceQueueFamilyProperties          (GetProcAddress('vkGetPhysicalDeviceQueueFamilyProperties'));

  4581.     vkGetPhysicalDeviceMemoryProperties                := TvkGetPhysicalDeviceMemoryProperties               (GetProcAddress('vkGetPhysicalDeviceMemoryProperties'));

  4582.     vkGetDeviceProcAddr                                := TvkGetDeviceProcAddr                               (GetProcAddress('vkGetDeviceProcAddr'));

  4583.     vkCreateDevice                                     := TvkCreateDevice                                    (GetProcAddress('vkCreateDevice'));

  4584.     vkEnumerateDeviceExtensionProperties               := TvkEnumerateDeviceExtensionProperties              (GetProcAddress('vkEnumerateDeviceExtensionProperties'));

  4585.     vkEnumerateDeviceLayerProperties                   := TvkEnumerateDeviceLayerProperties                  (GetProcAddress('vkEnumerateDeviceLayerProperties'));

  4586.     vkGetPhysicalDeviceSparseImageFormatProperties     := TvkGetPhysicalDeviceSparseImageFormatProperties    (GetProcAddress('vkGetPhysicalDeviceSparseImageFormatProperties'));

  4587.     

  4588.     { ========================================== VK_KHR_surface ========================================== }

  4589.     vkDestroySurfaceKHR                                := TvkDestroySurfaceKHR                               (GetProcAddress('vkDestroySurfaceKHR'));

  4590.     vkGetPhysicalDeviceSurfaceSupportKHR               := TvkGetPhysicalDeviceSurfaceSupportKHR              (GetProcAddress('vkGetPhysicalDeviceSurfaceSupportKHR'));

  4591.     vkGetPhysicalDeviceSurfaceCapabilitiesKHR          := TvkGetPhysicalDeviceSurfaceCapabilitiesKHR         (GetProcAddress('vkGetPhysicalDeviceSurfaceCapabilitiesKHR'));

  4592.     vkGetPhysicalDeviceSurfaceFormatsKHR               := TvkGetPhysicalDeviceSurfaceFormatsKHR              (GetProcAddress('vkGetPhysicalDeviceSurfaceFormatsKHR'));

  4593.     vkGetPhysicalDeviceSurfacePresentModesKHR          := TvkGetPhysicalDeviceSurfacePresentModesKHR         (GetProcAddress('vkGetPhysicalDeviceSurfacePresentModesKHR'));

  4594.     

  4595.     { ========================================== VK_KHR_display ========================================== }

  4596.     vkGetPhysicalDeviceDisplayPropertiesKHR            := TvkGetPhysicalDeviceDisplayPropertiesKHR           (GetProcAddress('vkGetPhysicalDeviceDisplayPropertiesKHR'));

  4597.     vkGetPhysicalDeviceDisplayPlanePropertiesKHR       := TvkGetPhysicalDeviceDisplayPlanePropertiesKHR      (GetProcAddress('vkGetPhysicalDeviceDisplayPlanePropertiesKHR'));

  4598.     vkGetDisplayPlaneSupportedDisplaysKHR              := TvkGetDisplayPlaneSupportedDisplaysKHR             (GetProcAddress('vkGetDisplayPlaneSupportedDisplaysKHR'));

  4599.     vkGetDisplayModePropertiesKHR                      := TvkGetDisplayModePropertiesKHR                     (GetProcAddress('vkGetDisplayModePropertiesKHR'));

  4600.     vkCreateDisplayModeKHR                             := TvkCreateDisplayModeKHR                            (GetProcAddress('vkCreateDisplayModeKHR'));

  4601.     vkGetDisplayPlaneCapabilitiesKHR                   := TvkGetDisplayPlaneCapabilitiesKHR                  (GetProcAddress('vkGetDisplayPlaneCapabilitiesKHR'));

  4602.     vkCreateDisplayPlaneSurfaceKHR                     := TvkCreateDisplayPlaneSurfaceKHR                    (GetProcAddress('vkCreateDisplayPlaneSurfaceKHR'));

  4603.     

  4604.     { ======================================= VK_KHR_xlib_surface ======================================== }

  4605.     {$IFDEF VK_USE_PLATFORM_XLIB_KHR}

  4606.     vkCreateXlibSurfaceKHR                             := TvkCreateXlibSurfaceKHR                            (GetProcAddress('vkCreateXlibSurfaceKHR'));

  4607.     vkGetPhysicalDeviceXlibPresentationSupportKHR      := TvkGetPhysicalDeviceXlibPresentationSupportKHR     (GetProcAddress('vkGetPhysicalDeviceXlibPresentationSupportKHR'));

  4608.     {$ENDIF}

  4609.     

  4610.     { ======================================== VK_KHR_xcb_surface ======================================== }

  4611.     {$IFDEF VK_USE_PLATFORM_XCB_KHR}

  4612.     vkCreateXcbSurfaceKHR                              := TvkCreateXcbSurfaceKHR                             (GetProcAddress('vkCreateXcbSurfaceKHR'));

  4613.     vkGetPhysicalDeviceXcbPresentationSupportKHR       := TvkGetPhysicalDeviceXcbPresentationSupportKHR      (GetProcAddress('vkGetPhysicalDeviceXcbPresentationSupportKHR'));

  4614.     {$ENDIF}

  4615.     

  4616.     { ====================================== VK_KHR_wayland_surface ====================================== }

  4617.     {$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}

  4618.     vkCreateWaylandSurfaceKHR                          := TvkCreateWaylandSurfaceKHR                         (GetProcAddress('vkCreateWaylandSurfaceKHR'));

  4619.     vkGetPhysicalDeviceWaylandPresentationSupportKHR   := TvkGetPhysicalDeviceWaylandPresentationSupportKHR  (GetProcAddress('vkGetPhysicalDeviceWaylandPresentationSupportKHR'));

  4620.     {$ENDIF}

  4621.     

  4622.     { ======================================== VK_KHR_mir_surface ======================================== }

  4623.     {$IFDEF VK_USE_PLATFORM_MIR_KHR}

  4624.     vkCreateMirSurfaceKHR                              := TvkCreateMirSurfaceKHR                             (GetProcAddress('vkCreateMirSurfaceKHR'));

  4625.     vkGetPhysicalDeviceMirPresentationSupportKHR       := TvkGetPhysicalDeviceMirPresentationSupportKHR      (GetProcAddress('vkGetPhysicalDeviceMirPresentationSupportKHR'));

  4626.     {$ENDIF}

  4627.     

  4628.     { ====================================== VK_KHR_android_surface ====================================== }

  4629.     {$IFDEF VK_USE_PLATFORM_ANDROID_KHR}

  4630.     vkCreateAndroidSurfaceKHR                          := TvkCreateAndroidSurfaceKHR                         (GetProcAddress('vkCreateAndroidSurfaceKHR'));

  4631.     {$ENDIF}

  4632.     

  4633.     { ======================================= VK_KHR_win32_surface ======================================= }

  4634.     {$IFDEF VK_USE_PLATFORM_WIN32_KHR}

  4635.     vkCreateWin32SurfaceKHR                            := TvkCreateWin32SurfaceKHR                           (GetProcAddress('vkCreateWin32SurfaceKHR'));

  4636.     vkGetPhysicalDeviceWin32PresentationSupportKHR     := TvkGetPhysicalDeviceWin32PresentationSupportKHR    (GetProcAddress('vkGetPhysicalDeviceWin32PresentationSupportKHR'));

  4637.     {$ENDIF}

  4638.     

  4639.     { ======================================= VK_EXT_debug_report ======================================== }

  4640.     vkCreateDebugReportCallbackEXT                     := TvkCreateDebugReportCallbackEXT                    (GetProcAddress('vkCreateDebugReportCallbackEXT'));

  4641.     vkDestroyDebugReportCallbackEXT                    := TvkDestroyDebugReportCallbackEXT                   (GetProcAddress('vkDestroyDebugReportCallbackEXT'));

  4642.     vkDebugReportMessageEXT                            := TvkDebugReportMessageEXT                           (GetProcAddress('vkDebugReportMessageEXT'));

  4643. 

  4644.   end;

  4645.   result := success;

  4646. end;

  4647. 

  4648. function LoadDeviceCommands(const aInstance: VkInstance; const aDevice: VkDevice; out aCommands: TVkDeviceCommands): Boolean;

  4649. var

  4650.   vkGetDeviceProcAddr: TvkGetDeviceProcAddr;

  4651.   success: Boolean;  

  4652. 

  4653.   function GetProcAddress(const aName: String): TvkVoidFunction;

  4654.   begin

  4655.     result := vkGetDeviceProcAddr(aDevice, PVkChar(aName));

  4656.     if not Assigned(result) then

  4657.       success := false;

  4658.   end;

  4659. 

  4660. begin

  4661.   FillByte(aCommands, SizeOf(aCommands), 0);

  4662.   vkGetDeviceProcAddr := TvkGetDeviceProcAddr(vkGetInstanceProcAddr(aInstance, 'vkGetDeviceProcAddr'));

  4663.   success := true;

  4664.   with aCommands do begin

  4665.     

  4666.     { ========================================== VK_VERSION_1_0 ========================================== }

  4667.     vkDestroyDevice                                    := TvkDestroyDevice                                   (GetProcAddress('vkDestroyDevice'));

  4668.     vkGetDeviceQueue                                   := TvkGetDeviceQueue                                  (GetProcAddress('vkGetDeviceQueue'));

  4669.     vkQueueSubmit                                      := TvkQueueSubmit                                     (GetProcAddress('vkQueueSubmit'));

  4670.     vkQueueWaitIdle                                    := TvkQueueWaitIdle                                   (GetProcAddress('vkQueueWaitIdle'));

  4671.     vkDeviceWaitIdle                                   := TvkDeviceWaitIdle                                  (GetProcAddress('vkDeviceWaitIdle'));

  4672.     vkAllocateMemory                                   := TvkAllocateMemory                                  (GetProcAddress('vkAllocateMemory'));

  4673.     vkFreeMemory                                       := TvkFreeMemory                                      (GetProcAddress('vkFreeMemory'));

  4674.     vkMapMemory                                        := TvkMapMemory                                       (GetProcAddress('vkMapMemory'));

  4675.     vkUnmapMemory                                      := TvkUnmapMemory                                     (GetProcAddress('vkUnmapMemory'));

  4676.     vkFlushMappedMemoryRanges                          := TvkFlushMappedMemoryRanges                         (GetProcAddress('vkFlushMappedMemoryRanges'));

  4677.     vkInvalidateMappedMemoryRanges                     := TvkInvalidateMappedMemoryRanges                    (GetProcAddress('vkInvalidateMappedMemoryRanges'));

  4678.     vkGetDeviceMemoryCommitment                        := TvkGetDeviceMemoryCommitment                       (GetProcAddress('vkGetDeviceMemoryCommitment'));

  4679.     vkBindBufferMemory                                 := TvkBindBufferMemory                                (GetProcAddress('vkBindBufferMemory'));

  4680.     vkBindImageMemory                                  := TvkBindImageMemory                                 (GetProcAddress('vkBindImageMemory'));

  4681.     vkGetBufferMemoryRequirements                      := TvkGetBufferMemoryRequirements                     (GetProcAddress('vkGetBufferMemoryRequirements'));

  4682.     vkGetImageMemoryRequirements                       := TvkGetImageMemoryRequirements                      (GetProcAddress('vkGetImageMemoryRequirements'));

  4683.     vkGetImageSparseMemoryRequirements                 := TvkGetImageSparseMemoryRequirements                (GetProcAddress('vkGetImageSparseMemoryRequirements'));

  4684.     vkQueueBindSparse                                  := TvkQueueBindSparse                                 (GetProcAddress('vkQueueBindSparse'));

  4685.     vkCreateFence                                      := TvkCreateFence                                     (GetProcAddress('vkCreateFence'));

  4686.     vkDestroyFence                                     := TvkDestroyFence                                    (GetProcAddress('vkDestroyFence'));

  4687.     vkResetFences                                      := TvkResetFences                                     (GetProcAddress('vkResetFences'));

  4688.     vkGetFenceStatus                                   := TvkGetFenceStatus                                  (GetProcAddress('vkGetFenceStatus'));

  4689.     vkWaitForFences                                    := TvkWaitForFences                                   (GetProcAddress('vkWaitForFences'));

  4690.     vkCreateSemaphore                                  := TvkCreateSemaphore                                 (GetProcAddress('vkCreateSemaphore'));

  4691.     vkDestroySemaphore                                 := TvkDestroySemaphore                                (GetProcAddress('vkDestroySemaphore'));

  4692.     vkCreateEvent                                      := TvkCreateEvent                                     (GetProcAddress('vkCreateEvent'));

  4693.     vkDestroyEvent                                     := TvkDestroyEvent                                    (GetProcAddress('vkDestroyEvent'));

  4694.     vkGetEventStatus                                   := TvkGetEventStatus                                  (GetProcAddress('vkGetEventStatus'));

  4695.     vkSetEvent                                         := TvkSetEvent                                        (GetProcAddress('vkSetEvent'));

  4696.     vkResetEvent                                       := TvkResetEvent                                      (GetProcAddress('vkResetEvent'));

  4697.     vkCreateQueryPool                                  := TvkCreateQueryPool                                 (GetProcAddress('vkCreateQueryPool'));

  4698.     vkDestroyQueryPool                                 := TvkDestroyQueryPool                                (GetProcAddress('vkDestroyQueryPool'));

  4699.     vkGetQueryPoolResults                              := TvkGetQueryPoolResults                             (GetProcAddress('vkGetQueryPoolResults'));

  4700.     vkCreateBuffer                                     := TvkCreateBuffer                                    (GetProcAddress('vkCreateBuffer'));

  4701.     vkDestroyBuffer                                    := TvkDestroyBuffer                                   (GetProcAddress('vkDestroyBuffer'));

  4702.     vkCreateBufferView                                 := TvkCreateBufferView                                (GetProcAddress('vkCreateBufferView'));

  4703.     vkDestroyBufferView                                := TvkDestroyBufferView                               (GetProcAddress('vkDestroyBufferView'));

  4704.     vkCreateImage                                      := TvkCreateImage                                     (GetProcAddress('vkCreateImage'));

  4705.     vkDestroyImage                                     := TvkDestroyImage                                    (GetProcAddress('vkDestroyImage'));

  4706.     vkGetImageSubresourceLayout                        := TvkGetImageSubresourceLayout                       (GetProcAddress('vkGetImageSubresourceLayout'));

  4707.     vkCreateImageView                                  := TvkCreateImageView                                 (GetProcAddress('vkCreateImageView'));

  4708.     vkDestroyImageView                                 := TvkDestroyImageView                                (GetProcAddress('vkDestroyImageView'));

  4709.     vkCreateShaderModule                               := TvkCreateShaderModule                              (GetProcAddress('vkCreateShaderModule'));

  4710.     vkDestroyShaderModule                              := TvkDestroyShaderModule                             (GetProcAddress('vkDestroyShaderModule'));

  4711.     vkCreatePipelineCache                              := TvkCreatePipelineCache                             (GetProcAddress('vkCreatePipelineCache'));

  4712.     vkDestroyPipelineCache                             := TvkDestroyPipelineCache                            (GetProcAddress('vkDestroyPipelineCache'));

  4713.     vkGetPipelineCacheData                             := TvkGetPipelineCacheData                            (GetProcAddress('vkGetPipelineCacheData'));

  4714.     vkMergePipelineCaches                              := TvkMergePipelineCaches                             (GetProcAddress('vkMergePipelineCaches'));

  4715.     vkCreateGraphicsPipelines                          := TvkCreateGraphicsPipelines                         (GetProcAddress('vkCreateGraphicsPipelines'));

  4716.     vkCreateComputePipelines                           := TvkCreateComputePipelines                          (GetProcAddress('vkCreateComputePipelines'));

  4717.     vkDestroyPipeline                                  := TvkDestroyPipeline                                 (GetProcAddress('vkDestroyPipeline'));

  4718.     vkCreatePipelineLayout                             := TvkCreatePipelineLayout                            (GetProcAddress('vkCreatePipelineLayout'));

  4719.     vkDestroyPipelineLayout                            := TvkDestroyPipelineLayout                           (GetProcAddress('vkDestroyPipelineLayout'));

  4720.     vkCreateSampler                                    := TvkCreateSampler                                   (GetProcAddress('vkCreateSampler'));

  4721.     vkDestroySampler                                   := TvkDestroySampler                                  (GetProcAddress('vkDestroySampler'));

  4722.     vkCreateDescriptorSetLayout                        := TvkCreateDescriptorSetLayout                       (GetProcAddress('vkCreateDescriptorSetLayout'));

  4723.     vkDestroyDescriptorSetLayout                       := TvkDestroyDescriptorSetLayout                      (GetProcAddress('vkDestroyDescriptorSetLayout'));

  4724.     vkCreateDescriptorPool                             := TvkCreateDescriptorPool                            (GetProcAddress('vkCreateDescriptorPool'));

  4725.     vkDestroyDescriptorPool                            := TvkDestroyDescriptorPool                           (GetProcAddress('vkDestroyDescriptorPool'));

  4726.     vkResetDescriptorPool                              := TvkResetDescriptorPool                             (GetProcAddress('vkResetDescriptorPool'));

  4727.     vkAllocateDescriptorSets                           := TvkAllocateDescriptorSets                          (GetProcAddress('vkAllocateDescriptorSets'));

  4728.     vkFreeDescriptorSets                               := TvkFreeDescriptorSets                              (GetProcAddress('vkFreeDescriptorSets'));

  4729.     vkUpdateDescriptorSets                             := TvkUpdateDescriptorSets                            (GetProcAddress('vkUpdateDescriptorSets'));

  4730.     vkCreateFramebuffer                                := TvkCreateFramebuffer                               (GetProcAddress('vkCreateFramebuffer'));

  4731.     vkDestroyFramebuffer                               := TvkDestroyFramebuffer                              (GetProcAddress('vkDestroyFramebuffer'));

  4732.     vkCreateRenderPass                                 := TvkCreateRenderPass                                (GetProcAddress('vkCreateRenderPass'));

  4733.     vkDestroyRenderPass                                := TvkDestroyRenderPass                               (GetProcAddress('vkDestroyRenderPass'));

  4734.     vkGetRenderAreaGranularity                         := TvkGetRenderAreaGranularity                        (GetProcAddress('vkGetRenderAreaGranularity'));

  4735.     vkCreateCommandPool                                := TvkCreateCommandPool                               (GetProcAddress('vkCreateCommandPool'));

  4736.     vkDestroyCommandPool                               := TvkDestroyCommandPool                              (GetProcAddress('vkDestroyCommandPool'));

  4737.     vkResetCommandPool                                 := TvkResetCommandPool                                (GetProcAddress('vkResetCommandPool'));

  4738.     vkAllocateCommandBuffers                           := TvkAllocateCommandBuffers                          (GetProcAddress('vkAllocateCommandBuffers'));

  4739.     vkFreeCommandBuffers                               := TvkFreeCommandBuffers                              (GetProcAddress('vkFreeCommandBuffers'));

  4740.     vkBeginCommandBuffer                               := TvkBeginCommandBuffer                              (GetProcAddress('vkBeginCommandBuffer'));

  4741.     vkEndCommandBuffer                                 := TvkEndCommandBuffer                                (GetProcAddress('vkEndCommandBuffer'));

  4742.     vkResetCommandBuffer                               := TvkResetCommandBuffer                              (GetProcAddress('vkResetCommandBuffer'));

  4743.     vkCmdBindPipeline                                  := TvkCmdBindPipeline                                 (GetProcAddress('vkCmdBindPipeline'));

  4744.     vkCmdSetViewport                                   := TvkCmdSetViewport                                  (GetProcAddress('vkCmdSetViewport'));

  4745.     vkCmdSetScissor                                    := TvkCmdSetScissor                                   (GetProcAddress('vkCmdSetScissor'));

  4746.     vkCmdSetLineWidth                                  := TvkCmdSetLineWidth                                 (GetProcAddress('vkCmdSetLineWidth'));

  4747.     vkCmdSetDepthBias                                  := TvkCmdSetDepthBias                                 (GetProcAddress('vkCmdSetDepthBias'));

  4748.     vkCmdSetBlendConstants                             := TvkCmdSetBlendConstants                            (GetProcAddress('vkCmdSetBlendConstants'));

  4749.     vkCmdSetDepthBounds                                := TvkCmdSetDepthBounds                               (GetProcAddress('vkCmdSetDepthBounds'));

  4750.     vkCmdSetStencilCompareMask                         := TvkCmdSetStencilCompareMask                        (GetProcAddress('vkCmdSetStencilCompareMask'));

  4751.     vkCmdSetStencilWriteMask                           := TvkCmdSetStencilWriteMask                          (GetProcAddress('vkCmdSetStencilWriteMask'));

  4752.     vkCmdSetStencilReference                           := TvkCmdSetStencilReference                          (GetProcAddress('vkCmdSetStencilReference'));

  4753.     vkCmdBindDescriptorSets                            := TvkCmdBindDescriptorSets                           (GetProcAddress('vkCmdBindDescriptorSets'));

  4754.     vkCmdBindIndexBuffer                               := TvkCmdBindIndexBuffer                              (GetProcAddress('vkCmdBindIndexBuffer'));

  4755.     vkCmdBindVertexBuffers                             := TvkCmdBindVertexBuffers                            (GetProcAddress('vkCmdBindVertexBuffers'));

  4756.     vkCmdDraw                                          := TvkCmdDraw                                         (GetProcAddress('vkCmdDraw'));

  4757.     vkCmdDrawIndexed                                   := TvkCmdDrawIndexed                                  (GetProcAddress('vkCmdDrawIndexed'));

  4758.     vkCmdDrawIndirect                                  := TvkCmdDrawIndirect                                 (GetProcAddress('vkCmdDrawIndirect'));

  4759.     vkCmdDrawIndexedIndirect                           := TvkCmdDrawIndexedIndirect                          (GetProcAddress('vkCmdDrawIndexedIndirect'));

  4760.     vkCmdDispatch                                      := TvkCmdDispatch                                     (GetProcAddress('vkCmdDispatch'));

  4761.     vkCmdDispatchIndirect                              := TvkCmdDispatchIndirect                             (GetProcAddress('vkCmdDispatchIndirect'));

  4762.     vkCmdCopyBuffer                                    := TvkCmdCopyBuffer                                   (GetProcAddress('vkCmdCopyBuffer'));

  4763.     vkCmdCopyImage                                     := TvkCmdCopyImage                                    (GetProcAddress('vkCmdCopyImage'));

  4764.     vkCmdBlitImage                                     := TvkCmdBlitImage                                    (GetProcAddress('vkCmdBlitImage'));

  4765.     vkCmdCopyBufferToImage                             := TvkCmdCopyBufferToImage                            (GetProcAddress('vkCmdCopyBufferToImage'));

  4766.     vkCmdCopyImageToBuffer                             := TvkCmdCopyImageToBuffer                            (GetProcAddress('vkCmdCopyImageToBuffer'));

  4767.     vkCmdUpdateBuffer                                  := TvkCmdUpdateBuffer                                 (GetProcAddress('vkCmdUpdateBuffer'));

  4768.     vkCmdFillBuffer                                    := TvkCmdFillBuffer                                   (GetProcAddress('vkCmdFillBuffer'));

  4769.     vkCmdClearColorImage                               := TvkCmdClearColorImage                              (GetProcAddress('vkCmdClearColorImage'));

  4770.     vkCmdClearDepthStencilImage                        := TvkCmdClearDepthStencilImage                       (GetProcAddress('vkCmdClearDepthStencilImage'));

  4771.     vkCmdClearAttachments                              := TvkCmdClearAttachments                             (GetProcAddress('vkCmdClearAttachments'));

  4772.     vkCmdResolveImage                                  := TvkCmdResolveImage                                 (GetProcAddress('vkCmdResolveImage'));

  4773.     vkCmdSetEvent                                      := TvkCmdSetEvent                                     (GetProcAddress('vkCmdSetEvent'));

  4774.     vkCmdResetEvent                                    := TvkCmdResetEvent                                   (GetProcAddress('vkCmdResetEvent'));

  4775.     vkCmdWaitEvents                                    := TvkCmdWaitEvents                                   (GetProcAddress('vkCmdWaitEvents'));

  4776.     vkCmdPipelineBarrier                               := TvkCmdPipelineBarrier                              (GetProcAddress('vkCmdPipelineBarrier'));

  4777.     vkCmdBeginQuery                                    := TvkCmdBeginQuery                                   (GetProcAddress('vkCmdBeginQuery'));

  4778.     vkCmdEndQuery                                      := TvkCmdEndQuery                                     (GetProcAddress('vkCmdEndQuery'));

  4779.     vkCmdResetQueryPool                                := TvkCmdResetQueryPool                               (GetProcAddress('vkCmdResetQueryPool'));

  4780.     vkCmdWriteTimestamp                                := TvkCmdWriteTimestamp                               (GetProcAddress('vkCmdWriteTimestamp'));

  4781.     vkCmdCopyQueryPoolResults                          := TvkCmdCopyQueryPoolResults                         (GetProcAddress('vkCmdCopyQueryPoolResults'));

  4782.     vkCmdPushConstants                                 := TvkCmdPushConstants                                (GetProcAddress('vkCmdPushConstants'));

  4783.     vkCmdBeginRenderPass                               := TvkCmdBeginRenderPass                              (GetProcAddress('vkCmdBeginRenderPass'));

  4784.     vkCmdNextSubpass                                   := TvkCmdNextSubpass                                  (GetProcAddress('vkCmdNextSubpass'));

  4785.     vkCmdEndRenderPass                                 := TvkCmdEndRenderPass                                (GetProcAddress('vkCmdEndRenderPass'));

  4786.     vkCmdExecuteCommands                               := TvkCmdExecuteCommands                              (GetProcAddress('vkCmdExecuteCommands'));

  4787.     

  4788.     { ========================================= VK_KHR_swapchain ========================================= }

  4789.     vkCreateSwapchainKHR                               := TvkCreateSwapchainKHR                              (GetProcAddress('vkCreateSwapchainKHR'));

  4790.     vkDestroySwapchainKHR                              := TvkDestroySwapchainKHR                             (GetProcAddress('vkDestroySwapchainKHR'));

  4791.     vkGetSwapchainImagesKHR                            := TvkGetSwapchainImagesKHR                           (GetProcAddress('vkGetSwapchainImagesKHR'));

  4792.     vkAcquireNextImageKHR                              := TvkAcquireNextImageKHR                             (GetProcAddress('vkAcquireNextImageKHR'));

  4793.     vkQueuePresentKHR                                  := TvkQueuePresentKHR                                 (GetProcAddress('vkQueuePresentKHR'));

  4794.     

  4795.     { ===================================== VK_KHR_display_swapchain ===================================== }

  4796.     vkCreateSharedSwapchainsKHR                        := TvkCreateSharedSwapchainsKHR                       (GetProcAddress('vkCreateSharedSwapchainsKHR'));

  4797. 

  4798.   end;

  4799.   result := success;

  4800. end;

  4801. 

  4802. procedure FinalizeVulkan;

  4803. begin

  4804.   vkFreeLibrary(vkLibHandle);

  4805. end;

  4806. 

  4807. initialization

  4808. 

  4809. finalization

  4810.   FinalizeVulkan;

  4811. 

  4812. end.