opengl
/
Vulkan
1
0
Разклонения 0
Код Задачи 0 Заявки за сливане 0 Версии 0 Уики Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Ревизии
1 Клон
458 KiB
 
 
ИН на ревизия: 97425e0bb2
Клонове Маркери
${ item.name }
Create branch ${ searchTerm }
от '97425e0bb2'
${ noResults }
Vulkan/projects/Vulkan.pas

2833 lines
188 KiB
Директен файл Blame История 

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

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

  3. 

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

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

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

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

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

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

  10. the following conditions:

  11. 

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

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

  14. 

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

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

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

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

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

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

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

  22. 

  23. ------------------------------------------------------------------------

  24. 

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

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

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

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

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

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

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

  32. 

  33. ==============================================================================

  34. 

  35. This file is autogenerated from vk.xml

  36. 

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

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

  39. 

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

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

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

  43. obtain a copy of the License at

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

  45. 

  46. Software distributed under the License is distributed on an

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

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

  49. rights and limitations under the License.

  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. {$IFDEF Win32}

  63.   {$DEFINE VK_WIN}

  64. {$ENDIF}

  65. 

  66. {$IFDEF Win64}

  67.   {$DEFINE VK_WIN}

  68. {$ENDIF}

  69. 

  70. {$IFDEF linux}

  71.   {$DEFINE VK_LINUX}

  72.   {$DEFINE VK_CDECL}

  73. {$ENDIF}

  74. 

  75. {$IFDEF DARWIN}

  76.   {$DEFINE VK_MAC}

  77.   {$DEFINE VK_CDECL}

  78. {$ENDIF}

  79. 

  80. interface

  81. 

  82. {********************************* VK_VERSION_1_0 *********************************}

  83. const { constants }

  84.   VK_MAX_PHYSICAL_DEVICE_NAME_SIZE                               = 256;

  85.   VK_UUID_SIZE                                                   = 16;

  86.   VK_MAX_EXTENSION_NAME_SIZE                                     = 256;

  87.   VK_MAX_DESCRIPTION_SIZE                                        = 256;

  88.   VK_MAX_MEMORY_TYPES                                            = 32;

  89.   VK_MAX_MEMORY_HEAPS                                            = 16;

  90.   VK_LOD_CLAMP_NONE                                              = 1000;

  91.   VK_REMAINING_MIP_LEVELS                                        = $FFFFFFFF;

  92.   VK_REMAINING_ARRAY_LAYERS                                      = $FFFFFFFF;

  93.   VK_WHOLE_SIZE                                                  = $FFFFFFFF;

  94.   VK_ATTACHMENT_UNUSED                                           = $FFFFFFFF;

  95.   VK_TRUE                                                        = 1;

  96.   VK_FALSE                                                       = 0;

  97.   VK_QUEUE_FAMILY_IGNORED                                        = $FFFFFFFF;

  98.   VK_SUBPASS_EXTERNAL                                            = $FFFFFFFF;

  99. 

  100. type { types }

  101.   PVkVoid                                                        = Pointer;

  102.   VkChar                                                         = AnsiChar;

  103.   VkDouble                                                       = Double;

  104.   VkFloat                                                        = Single;

  105.   VkHandle                                                       = Pointer;

  106.   VkInt16                                                        = SmallInt;

  107.   VkInt32                                                        = Integer;

  108.   VkInt64                                                        = Int64;

  109.   VkSize                                                         = SizeUInt;

  110.   VkUint16                                                       = Word;

  111.   VkUint32                                                       = Cardinal;

  112.   VkUint64                                                       = QWord;

  113.   VkUint8                                                        = Byte;

  114.   VkBool32                                                       = VkUint32;

  115.   VkFlags                                                        = VkUint32;

  116.   VkSampleMask                                                   = VkUint32;

  117.   VkDeviceSize                                                   = VkUint64;

  118.   VkAccessFlags                                                  = VkFlags;

  119.   VkAttachmentDescriptionFlags                                   = VkFlags;

  120.   VkBufferCreateFlags                                            = VkFlags;

  121.   VkBufferUsageFlags                                             = VkFlags;

  122.   VkBufferViewCreateFlags                                        = VkFlags;

  123.   VkColorComponentFlags                                          = VkFlags;

  124.   VkCommandBufferResetFlags                                      = VkFlags;

  125.   VkCommandBufferUsageFlags                                      = VkFlags;

  126.   VkCommandPoolCreateFlags                                       = VkFlags;

  127.   VkCommandPoolResetFlags                                        = VkFlags;

  128.   VkCullModeFlags                                                = VkFlags;

  129.   VkDependencyFlags                                              = VkFlags;

  130.   VkDescriptorPoolCreateFlags                                    = VkFlags;

  131.   VkDescriptorPoolResetFlags                                     = VkFlags;

  132.   VkDescriptorSetLayoutCreateFlags                               = VkFlags;

  133.   VkDeviceCreateFlags                                            = VkFlags;

  134.   VkDeviceQueueCreateFlags                                       = VkFlags;

  135.   VkEventCreateFlags                                             = VkFlags;

  136.   VkFenceCreateFlags                                             = VkFlags;

  137.   VkFormatFeatureFlags                                           = VkFlags;

  138.   VkFramebufferCreateFlags                                       = VkFlags;

  139.   VkImageAspectFlags                                             = VkFlags;

  140.   VkImageCreateFlags                                             = VkFlags;

  141.   VkImageUsageFlags                                              = VkFlags;

  142.   VkImageViewCreateFlags                                         = VkFlags;

  143.   VkInstanceCreateFlags                                          = VkFlags;

  144.   VkMemoryHeapFlags                                              = VkFlags;

  145.   VkMemoryMapFlags                                               = VkFlags;

  146.   VkMemoryPropertyFlags                                          = VkFlags;

  147.   VkPipelineCacheCreateFlags                                     = VkFlags;

  148.   VkPipelineColorBlendStateCreateFlags                           = VkFlags;

  149.   VkPipelineCreateFlags                                          = VkFlags;

  150.   VkPipelineDepthStencilStateCreateFlags                         = VkFlags;

  151.   VkPipelineDynamicStateCreateFlags                              = VkFlags;

  152.   VkPipelineInputAssemblyStateCreateFlags                        = VkFlags;

  153.   VkPipelineLayoutCreateFlags                                    = VkFlags;

  154.   VkPipelineMultisampleStateCreateFlags                          = VkFlags;

  155.   VkPipelineRasterizationStateCreateFlags                        = VkFlags;

  156.   VkPipelineShaderStageCreateFlags                               = VkFlags;

  157.   VkPipelineStageFlags                                           = VkFlags;

  158.   VkPipelineTessellationStateCreateFlags                         = VkFlags;

  159.   VkPipelineVertexInputStateCreateFlags                          = VkFlags;

  160.   VkPipelineViewportStateCreateFlags                             = VkFlags;

  161.   VkQueryControlFlags                                            = VkFlags;

  162.   VkQueryPipelineStatisticFlags                                  = VkFlags;

  163.   VkQueryPoolCreateFlags                                         = VkFlags;

  164.   VkQueryResultFlags                                             = VkFlags;

  165.   VkQueueFlags                                                   = VkFlags;

  166.   VkRenderPassCreateFlags                                        = VkFlags;

  167.   VkSampleCountFlags                                             = VkFlags;

  168.   VkSamplerCreateFlags                                           = VkFlags;

  169.   VkSemaphoreCreateFlags                                         = VkFlags;

  170.   VkShaderModuleCreateFlags                                      = VkFlags;

  171.   VkShaderStageFlags                                             = VkFlags;

  172.   VkSparseImageFormatFlags                                       = VkFlags;

  173.   VkSparseMemoryBindFlags                                        = VkFlags;

  174.   VkStencilFaceFlags                                             = VkFlags;

  175.   VkSubpassDescriptionFlags                                      = VkFlags;

  176. 

  177. type { type pointers }

  178.   PPVkVoid                                                       = ^PVkVoid;

  179.   PPPVkVoid                                                      = ^PPVkVoid;

  180.   PVkChar                                                        = ^VkChar;

  181.   PPVkChar                                                       = ^PVkChar;

  182.   PVkDouble                                                      = ^VkDouble;

  183.   PPVkDouble                                                     = ^PVkDouble;

  184.   PVkFloat                                                       = ^VkFloat;

  185.   PPVkFloat                                                      = ^PVkFloat;

  186.   PVkHandle                                                      = ^VkHandle;

  187.   PPVkHandle                                                     = ^PVkHandle;

  188.   PVkInt16                                                       = ^VkInt16;

  189.   PPVkInt16                                                      = ^PVkInt16;

  190.   PVkInt32                                                       = ^VkInt32;

  191.   PPVkInt32                                                      = ^PVkInt32;

  192.   PVkInt64                                                       = ^VkInt64;

  193.   PPVkInt64                                                      = ^PVkInt64;

  194.   PVkSize                                                        = ^VkSize;

  195.   PPVkSize                                                       = ^PVkSize;

  196.   PVkUint16                                                      = ^VkUint16;

  197.   PPVkUint16                                                     = ^PVkUint16;

  198.   PVkUint32                                                      = ^VkUint32;

  199.   PPVkUint32                                                     = ^PVkUint32;

  200.   PVkUint64                                                      = ^VkUint64;

  201.   PPVkUint64                                                     = ^PVkUint64;

  202.   PVkUint8                                                       = ^VkUint8;

  203.   PPVkUint8                                                      = ^PVkUint8;

  204.   PVkBool32                                                      = ^VkBool32;

  205.   PPVkBool32                                                     = ^PVkBool32;

  206.   PVkFlags                                                       = ^VkFlags;

  207.   PPVkFlags                                                      = ^PVkFlags;

  208.   PVkSampleMask                                                  = ^VkSampleMask;

  209.   PPVkSampleMask                                                 = ^PVkSampleMask;

  210.   PVkDeviceSize                                                  = ^VkDeviceSize;

  211.   PPVkDeviceSize                                                 = ^PVkDeviceSize;

  212.   PVkAccessFlags                                                 = ^VkAccessFlags;

  213.   PPVkAccessFlags                                                = ^PVkAccessFlags;

  214.   PVkAttachmentDescriptionFlags                                  = ^VkAttachmentDescriptionFlags;

  215.   PPVkAttachmentDescriptionFlags                                 = ^PVkAttachmentDescriptionFlags;

  216.   PVkBufferCreateFlags                                           = ^VkBufferCreateFlags;

  217.   PPVkBufferCreateFlags                                          = ^PVkBufferCreateFlags;

  218.   PVkBufferUsageFlags                                            = ^VkBufferUsageFlags;

  219.   PPVkBufferUsageFlags                                           = ^PVkBufferUsageFlags;

  220.   PVkBufferViewCreateFlags                                       = ^VkBufferViewCreateFlags;

  221.   PPVkBufferViewCreateFlags                                      = ^PVkBufferViewCreateFlags;

  222.   PVkColorComponentFlags                                         = ^VkColorComponentFlags;

  223.   PPVkColorComponentFlags                                        = ^PVkColorComponentFlags;

  224.   PVkCommandBufferResetFlags                                     = ^VkCommandBufferResetFlags;

  225.   PPVkCommandBufferResetFlags                                    = ^PVkCommandBufferResetFlags;

  226.   PVkCommandBufferUsageFlags                                     = ^VkCommandBufferUsageFlags;

  227.   PPVkCommandBufferUsageFlags                                    = ^PVkCommandBufferUsageFlags;

  228.   PVkCommandPoolCreateFlags                                      = ^VkCommandPoolCreateFlags;

  229.   PPVkCommandPoolCreateFlags                                     = ^PVkCommandPoolCreateFlags;

  230.   PVkCommandPoolResetFlags                                       = ^VkCommandPoolResetFlags;

  231.   PPVkCommandPoolResetFlags                                      = ^PVkCommandPoolResetFlags;

  232.   PVkCullModeFlags                                               = ^VkCullModeFlags;

  233.   PPVkCullModeFlags                                              = ^PVkCullModeFlags;

  234.   PVkDependencyFlags                                             = ^VkDependencyFlags;

  235.   PPVkDependencyFlags                                            = ^PVkDependencyFlags;

  236.   PVkDescriptorPoolCreateFlags                                   = ^VkDescriptorPoolCreateFlags;

  237.   PPVkDescriptorPoolCreateFlags                                  = ^PVkDescriptorPoolCreateFlags;

  238.   PVkDescriptorPoolResetFlags                                    = ^VkDescriptorPoolResetFlags;

  239.   PPVkDescriptorPoolResetFlags                                   = ^PVkDescriptorPoolResetFlags;

  240.   PVkDescriptorSetLayoutCreateFlags                              = ^VkDescriptorSetLayoutCreateFlags;

  241.   PPVkDescriptorSetLayoutCreateFlags                             = ^PVkDescriptorSetLayoutCreateFlags;

  242.   PVkDeviceCreateFlags                                           = ^VkDeviceCreateFlags;

  243.   PPVkDeviceCreateFlags                                          = ^PVkDeviceCreateFlags;

  244.   PVkDeviceQueueCreateFlags                                      = ^VkDeviceQueueCreateFlags;

  245.   PPVkDeviceQueueCreateFlags                                     = ^PVkDeviceQueueCreateFlags;

  246.   PVkEventCreateFlags                                            = ^VkEventCreateFlags;

  247.   PPVkEventCreateFlags                                           = ^PVkEventCreateFlags;

  248.   PVkFenceCreateFlags                                            = ^VkFenceCreateFlags;

  249.   PPVkFenceCreateFlags                                           = ^PVkFenceCreateFlags;

  250.   PVkFormatFeatureFlags                                          = ^VkFormatFeatureFlags;

  251.   PPVkFormatFeatureFlags                                         = ^PVkFormatFeatureFlags;

  252.   PVkFramebufferCreateFlags                                      = ^VkFramebufferCreateFlags;

  253.   PPVkFramebufferCreateFlags                                     = ^PVkFramebufferCreateFlags;

  254.   PVkImageAspectFlags                                            = ^VkImageAspectFlags;

  255.   PPVkImageAspectFlags                                           = ^PVkImageAspectFlags;

  256.   PVkImageCreateFlags                                            = ^VkImageCreateFlags;

  257.   PPVkImageCreateFlags                                           = ^PVkImageCreateFlags;

  258.   PVkImageUsageFlags                                             = ^VkImageUsageFlags;

  259.   PPVkImageUsageFlags                                            = ^PVkImageUsageFlags;

  260.   PVkImageViewCreateFlags                                        = ^VkImageViewCreateFlags;

  261.   PPVkImageViewCreateFlags                                       = ^PVkImageViewCreateFlags;

  262.   PVkInstanceCreateFlags                                         = ^VkInstanceCreateFlags;

  263.   PPVkInstanceCreateFlags                                        = ^PVkInstanceCreateFlags;

  264.   PVkMemoryHeapFlags                                             = ^VkMemoryHeapFlags;

  265.   PPVkMemoryHeapFlags                                            = ^PVkMemoryHeapFlags;

  266.   PVkMemoryMapFlags                                              = ^VkMemoryMapFlags;

  267.   PPVkMemoryMapFlags                                             = ^PVkMemoryMapFlags;

  268.   PVkMemoryPropertyFlags                                         = ^VkMemoryPropertyFlags;

  269.   PPVkMemoryPropertyFlags                                        = ^PVkMemoryPropertyFlags;

  270.   PVkPipelineCacheCreateFlags                                    = ^VkPipelineCacheCreateFlags;

  271.   PPVkPipelineCacheCreateFlags                                   = ^PVkPipelineCacheCreateFlags;

  272.   PVkPipelineColorBlendStateCreateFlags                          = ^VkPipelineColorBlendStateCreateFlags;

  273.   PPVkPipelineColorBlendStateCreateFlags                         = ^PVkPipelineColorBlendStateCreateFlags;

  274.   PVkPipelineCreateFlags                                         = ^VkPipelineCreateFlags;

  275.   PPVkPipelineCreateFlags                                        = ^PVkPipelineCreateFlags;

  276.   PVkPipelineDepthStencilStateCreateFlags                        = ^VkPipelineDepthStencilStateCreateFlags;

  277.   PPVkPipelineDepthStencilStateCreateFlags                       = ^PVkPipelineDepthStencilStateCreateFlags;

  278.   PVkPipelineDynamicStateCreateFlags                             = ^VkPipelineDynamicStateCreateFlags;

  279.   PPVkPipelineDynamicStateCreateFlags                            = ^PVkPipelineDynamicStateCreateFlags;

  280.   PVkPipelineInputAssemblyStateCreateFlags                       = ^VkPipelineInputAssemblyStateCreateFlags;

  281.   PPVkPipelineInputAssemblyStateCreateFlags                      = ^PVkPipelineInputAssemblyStateCreateFlags;

  282.   PVkPipelineLayoutCreateFlags                                   = ^VkPipelineLayoutCreateFlags;

  283.   PPVkPipelineLayoutCreateFlags                                  = ^PVkPipelineLayoutCreateFlags;

  284.   PVkPipelineMultisampleStateCreateFlags                         = ^VkPipelineMultisampleStateCreateFlags;

  285.   PPVkPipelineMultisampleStateCreateFlags                        = ^PVkPipelineMultisampleStateCreateFlags;

  286.   PVkPipelineRasterizationStateCreateFlags                       = ^VkPipelineRasterizationStateCreateFlags;

  287.   PPVkPipelineRasterizationStateCreateFlags                      = ^PVkPipelineRasterizationStateCreateFlags;

  288.   PVkPipelineShaderStageCreateFlags                              = ^VkPipelineShaderStageCreateFlags;

  289.   PPVkPipelineShaderStageCreateFlags                             = ^PVkPipelineShaderStageCreateFlags;

  290.   PVkPipelineStageFlags                                          = ^VkPipelineStageFlags;

  291.   PPVkPipelineStageFlags                                         = ^PVkPipelineStageFlags;

  292.   PVkPipelineTessellationStateCreateFlags                        = ^VkPipelineTessellationStateCreateFlags;

  293.   PPVkPipelineTessellationStateCreateFlags                       = ^PVkPipelineTessellationStateCreateFlags;

  294.   PVkPipelineVertexInputStateCreateFlags                         = ^VkPipelineVertexInputStateCreateFlags;

  295.   PPVkPipelineVertexInputStateCreateFlags                        = ^PVkPipelineVertexInputStateCreateFlags;

  296.   PVkPipelineViewportStateCreateFlags                            = ^VkPipelineViewportStateCreateFlags;

  297.   PPVkPipelineViewportStateCreateFlags                           = ^PVkPipelineViewportStateCreateFlags;

  298.   PVkQueryControlFlags                                           = ^VkQueryControlFlags;

  299.   PPVkQueryControlFlags                                          = ^PVkQueryControlFlags;

  300.   PVkQueryPipelineStatisticFlags                                 = ^VkQueryPipelineStatisticFlags;

  301.   PPVkQueryPipelineStatisticFlags                                = ^PVkQueryPipelineStatisticFlags;

  302.   PVkQueryPoolCreateFlags                                        = ^VkQueryPoolCreateFlags;

  303.   PPVkQueryPoolCreateFlags                                       = ^PVkQueryPoolCreateFlags;

  304.   PVkQueryResultFlags                                            = ^VkQueryResultFlags;

  305.   PPVkQueryResultFlags                                           = ^PVkQueryResultFlags;

  306.   PVkQueueFlags                                                  = ^VkQueueFlags;

  307.   PPVkQueueFlags                                                 = ^PVkQueueFlags;

  308.   PVkRenderPassCreateFlags                                       = ^VkRenderPassCreateFlags;

  309.   PPVkRenderPassCreateFlags                                      = ^PVkRenderPassCreateFlags;

  310.   PVkSampleCountFlags                                            = ^VkSampleCountFlags;

  311.   PPVkSampleCountFlags                                           = ^PVkSampleCountFlags;

  312.   PVkSamplerCreateFlags                                          = ^VkSamplerCreateFlags;

  313.   PPVkSamplerCreateFlags                                         = ^PVkSamplerCreateFlags;

  314.   PVkSemaphoreCreateFlags                                        = ^VkSemaphoreCreateFlags;

  315.   PPVkSemaphoreCreateFlags                                       = ^PVkSemaphoreCreateFlags;

  316.   PVkShaderModuleCreateFlags                                     = ^VkShaderModuleCreateFlags;

  317.   PPVkShaderModuleCreateFlags                                    = ^PVkShaderModuleCreateFlags;

  318.   PVkShaderStageFlags                                            = ^VkShaderStageFlags;

  319.   PPVkShaderStageFlags                                           = ^PVkShaderStageFlags;

  320.   PVkSparseImageFormatFlags                                      = ^VkSparseImageFormatFlags;

  321.   PPVkSparseImageFormatFlags                                     = ^PVkSparseImageFormatFlags;

  322.   PVkSparseMemoryBindFlags                                       = ^VkSparseMemoryBindFlags;

  323.   PPVkSparseMemoryBindFlags                                      = ^PVkSparseMemoryBindFlags;

  324.   PVkStencilFaceFlags                                            = ^VkStencilFaceFlags;

  325.   PPVkStencilFaceFlags                                           = ^PVkStencilFaceFlags;

  326.   PVkSubpassDescriptionFlags                                     = ^VkSubpassDescriptionFlags;

  327.   PPVkSubpassDescriptionFlags                                    = ^PVkSubpassDescriptionFlags;

  328. 

  329. type { handles }

  330.   VkBuffer                                                       = VkHandle;

  331.   VkBufferView                                                   = VkHandle;

  332.   VkCommandBuffer                                                = VkHandle;

  333.   VkCommandPool                                                  = VkHandle;

  334.   VkDescriptorPool                                               = VkHandle;

  335.   VkDescriptorSet                                                = VkHandle;

  336.   VkDescriptorSetLayout                                          = VkHandle;

  337.   VkDevice                                                       = VkHandle;

  338.   VkDeviceMemory                                                 = VkHandle;

  339.   VkEvent                                                        = VkHandle;

  340.   VkFence                                                        = VkHandle;

  341.   VkFramebuffer                                                  = VkHandle;

  342.   VkImage                                                        = VkHandle;

  343.   VkImageView                                                    = VkHandle;

  344.   VkInstance                                                     = VkHandle;

  345.   VkPhysicalDevice                                               = VkHandle;

  346.   VkPipeline                                                     = VkHandle;

  347.   VkPipelineCache                                                = VkHandle;

  348.   VkPipelineLayout                                               = VkHandle;

  349.   VkQueryPool                                                    = VkHandle;

  350.   VkQueue                                                        = VkHandle;

  351.   VkRenderPass                                                   = VkHandle;

  352.   VkSampler                                                      = VkHandle;

  353.   VkSemaphore                                                    = VkHandle;

  354.   VkShaderModule                                                 = VkHandle;

  355. 

  356. type { handle pointers }

  357.   PVkBuffer                                                      = ^VkBuffer;

  358.   PPVkBuffer                                                     = ^PVkBuffer;

  359.   PVkBufferView                                                  = ^VkBufferView;

  360.   PPVkBufferView                                                 = ^PVkBufferView;

  361.   PVkCommandBuffer                                               = ^VkCommandBuffer;

  362.   PPVkCommandBuffer                                              = ^PVkCommandBuffer;

  363.   PVkCommandPool                                                 = ^VkCommandPool;

  364.   PPVkCommandPool                                                = ^PVkCommandPool;

  365.   PVkDescriptorPool                                              = ^VkDescriptorPool;

  366.   PPVkDescriptorPool                                             = ^PVkDescriptorPool;

  367.   PVkDescriptorSet                                               = ^VkDescriptorSet;

  368.   PPVkDescriptorSet                                              = ^PVkDescriptorSet;

  369.   PVkDescriptorSetLayout                                         = ^VkDescriptorSetLayout;

  370.   PPVkDescriptorSetLayout                                        = ^PVkDescriptorSetLayout;

  371.   PVkDevice                                                      = ^VkDevice;

  372.   PPVkDevice                                                     = ^PVkDevice;

  373.   PVkDeviceMemory                                                = ^VkDeviceMemory;

  374.   PPVkDeviceMemory                                               = ^PVkDeviceMemory;

  375.   PVkEvent                                                       = ^VkEvent;

  376.   PPVkEvent                                                      = ^PVkEvent;

  377.   PVkFence                                                       = ^VkFence;

  378.   PPVkFence                                                      = ^PVkFence;

  379.   PVkFramebuffer                                                 = ^VkFramebuffer;

  380.   PPVkFramebuffer                                                = ^PVkFramebuffer;

  381.   PVkImage                                                       = ^VkImage;

  382.   PPVkImage                                                      = ^PVkImage;

  383.   PVkImageView                                                   = ^VkImageView;

  384.   PPVkImageView                                                  = ^PVkImageView;

  385.   PVkInstance                                                    = ^VkInstance;

  386.   PPVkInstance                                                   = ^PVkInstance;

  387.   PVkPhysicalDevice                                              = ^VkPhysicalDevice;

  388.   PPVkPhysicalDevice                                             = ^PVkPhysicalDevice;

  389.   PVkPipeline                                                    = ^VkPipeline;

  390.   PPVkPipeline                                                   = ^PVkPipeline;

  391.   PVkPipelineCache                                               = ^VkPipelineCache;

  392.   PPVkPipelineCache                                              = ^PVkPipelineCache;

  393.   PVkPipelineLayout                                              = ^VkPipelineLayout;

  394.   PPVkPipelineLayout                                             = ^PVkPipelineLayout;

  395.   PVkQueryPool                                                   = ^VkQueryPool;

  396.   PPVkQueryPool                                                  = ^PVkQueryPool;

  397.   PVkQueue                                                       = ^VkQueue;

  398.   PPVkQueue                                                      = ^PVkQueue;

  399.   PVkRenderPass                                                  = ^VkRenderPass;

  400.   PPVkRenderPass                                                 = ^PVkRenderPass;

  401.   PVkSampler                                                     = ^VkSampler;

  402.   PPVkSampler                                                    = ^PVkSampler;

  403.   PVkSemaphore                                                   = ^VkSemaphore;

  404.   PPVkSemaphore                                                  = ^PVkSemaphore;

  405.   PVkShaderModule                                                = ^VkShaderModule;

  406.   PPVkShaderModule                                               = ^PVkShaderModule;

  407. 

  408. type { enums }

  409.   TVkAttachmentLoadOp = (

  410.     VK_ATTACHMENT_LOAD_OP_LOAD                                   = 0,

  411.     VK_ATTACHMENT_LOAD_OP_CLEAR                                  = 1,

  412.     VK_ATTACHMENT_LOAD_OP_DONT_CARE                              = 2

  413.   );

  414.   PVkAttachmentLoadOp = ^TVkAttachmentLoadOp;

  415. 

  416.   TVkAttachmentStoreOp = (

  417.     VK_ATTACHMENT_STORE_OP_STORE                                 = 0,

  418.     VK_ATTACHMENT_STORE_OP_DONT_CARE                             = 1

  419.   );

  420.   PVkAttachmentStoreOp = ^TVkAttachmentStoreOp;

  421. 

  422.   TVkBlendFactor = (

  423.     VK_BLEND_FACTOR_ZERO                                         = 0,

  424.     VK_BLEND_FACTOR_ONE                                          = 1,

  425.     VK_BLEND_FACTOR_SRC_COLOR                                    = 2,

  426.     VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR                          = 3,

  427.     VK_BLEND_FACTOR_DST_COLOR                                    = 4,

  428.     VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR                          = 5,

  429.     VK_BLEND_FACTOR_SRC_ALPHA                                    = 6,

  430.     VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA                          = 7,

  431.     VK_BLEND_FACTOR_DST_ALPHA                                    = 8,

  432.     VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA                          = 9,

  433.     VK_BLEND_FACTOR_CONSTANT_COLOR                               = 10,

  434.     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR                     = 11,

  435.     VK_BLEND_FACTOR_CONSTANT_ALPHA                               = 12,

  436.     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA                     = 13,

  437.     VK_BLEND_FACTOR_SRC_ALPHA_SATURATE                           = 14,

  438.     VK_BLEND_FACTOR_SRC1_COLOR                                   = 15,

  439.     VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR                         = 16,

  440.     VK_BLEND_FACTOR_SRC1_ALPHA                                   = 17,

  441.     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA                         = 18

  442.   );

  443.   PVkBlendFactor = ^TVkBlendFactor;

  444. 

  445.   TVkBlendOp = (

  446.     VK_BLEND_OP_ADD                                              = 0,

  447.     VK_BLEND_OP_SUBTRACT                                         = 1,

  448.     VK_BLEND_OP_REVERSE_SUBTRACT                                 = 2,

  449.     VK_BLEND_OP_MIN                                              = 3,

  450.     VK_BLEND_OP_MAX                                              = 4

  451.   );

  452.   PVkBlendOp = ^TVkBlendOp;

  453. 

  454.   TVkBorderColor = (

  455.     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK                      = 0,

  456.     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK                        = 1,

  457.     VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK                           = 2,

  458.     VK_BORDER_COLOR_INT_OPAQUE_BLACK                             = 3,

  459.     VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE                           = 4,

  460.     VK_BORDER_COLOR_INT_OPAQUE_WHITE                             = 5

  461.   );

  462.   PVkBorderColor = ^TVkBorderColor;

  463. 

  464.   TVkCommandBufferLevel = (

  465.     VK_COMMAND_BUFFER_LEVEL_PRIMARY                              = 0,

  466.     VK_COMMAND_BUFFER_LEVEL_SECONDARY                            = 1

  467.   );

  468.   PVkCommandBufferLevel = ^TVkCommandBufferLevel;

  469. 

  470.   TVkCompareOp = (

  471.     VK_COMPARE_OP_NEVER                                          = 0,

  472.     VK_COMPARE_OP_LESS                                           = 1,

  473.     VK_COMPARE_OP_EQUAL                                          = 2,

  474.     VK_COMPARE_OP_LESS_OR_EQUAL                                  = 3,

  475.     VK_COMPARE_OP_GREATER                                        = 4,

  476.     VK_COMPARE_OP_NOT_EQUAL                                      = 5,

  477.     VK_COMPARE_OP_GREATER_OR_EQUAL                               = 6,

  478.     VK_COMPARE_OP_ALWAYS                                         = 7

  479.   );

  480.   PVkCompareOp = ^TVkCompareOp;

  481. 

  482.   TVkComponentSwizzle = (

  483.     VK_COMPONENT_SWIZZLE_IDENTITY                                = 0,

  484.     VK_COMPONENT_SWIZZLE_ZERO                                    = 1,

  485.     VK_COMPONENT_SWIZZLE_ONE                                     = 2,

  486.     VK_COMPONENT_SWIZZLE_R                                       = 3,

  487.     VK_COMPONENT_SWIZZLE_G                                       = 4,

  488.     VK_COMPONENT_SWIZZLE_B                                       = 5,

  489.     VK_COMPONENT_SWIZZLE_A                                       = 6

  490.   );

  491.   PVkComponentSwizzle = ^TVkComponentSwizzle;

  492. 

  493.   TVkDescriptorType = (

  494.     VK_DESCRIPTOR_TYPE_SAMPLER                                   = 0,

  495.     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER                    = 1,

  496.     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE                             = 2,

  497.     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE                             = 3,

  498.     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER                      = 4,

  499.     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER                      = 5,

  500.     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER                            = 6,

  501.     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER                            = 7,

  502.     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC                    = 8,

  503.     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC                    = 9,

  504.     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT                          = 10

  505.   );

  506.   PVkDescriptorType = ^TVkDescriptorType;

  507. 

  508.   TVkDynamicState = (

  509.     VK_DYNAMIC_STATE_VIEWPORT                                    = 0,

  510.     VK_DYNAMIC_STATE_SCISSOR                                     = 1,

  511.     VK_DYNAMIC_STATE_LINE_WIDTH                                  = 2,

  512.     VK_DYNAMIC_STATE_DEPTH_BIAS                                  = 3,

  513.     VK_DYNAMIC_STATE_BLEND_CONSTANTS                             = 4,

  514.     VK_DYNAMIC_STATE_DEPTH_BOUNDS                                = 5,

  515.     VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK                        = 6,

  516.     VK_DYNAMIC_STATE_STENCIL_WRITE_MASK                          = 7,

  517.     VK_DYNAMIC_STATE_STENCIL_REFERENCE                           = 8

  518.   );

  519.   PVkDynamicState = ^TVkDynamicState;

  520. 

  521.   TVkFilter = (

  522.     VK_FILTER_NEAREST                                            = 0,

  523.     VK_FILTER_LINEAR                                             = 1

  524.   );

  525.   PVkFilter = ^TVkFilter;

  526. 

  527.   TVkFormat = (

  528.     VK_FORMAT_UNDEFINED                                          = 0,

  529.     VK_FORMAT_R4G4_UNORM_PACK8                                   = 1,

  530.     VK_FORMAT_R4G4B4A4_UNORM_PACK16                              = 2,

  531.     VK_FORMAT_B4G4R4A4_UNORM_PACK16                              = 3,

  532.     VK_FORMAT_R5G6B5_UNORM_PACK16                                = 4,

  533.     VK_FORMAT_B5G6R5_UNORM_PACK16                                = 5,

  534.     VK_FORMAT_R5G5B5A1_UNORM_PACK16                              = 6,

  535.     VK_FORMAT_B5G5R5A1_UNORM_PACK16                              = 7,

  536.     VK_FORMAT_A1R5G5B5_UNORM_PACK16                              = 8,

  537.     VK_FORMAT_R8_UNORM                                           = 9,

  538.     VK_FORMAT_R8_SNORM                                           = 10,

  539.     VK_FORMAT_R8_USCALED                                         = 11,

  540.     VK_FORMAT_R8_SSCALED                                         = 12,

  541.     VK_FORMAT_R8_UINT                                            = 13,

  542.     VK_FORMAT_R8_SINT                                            = 14,

  543.     VK_FORMAT_R8_SRGB                                            = 15,

  544.     VK_FORMAT_R8G8_UNORM                                         = 16,

  545.     VK_FORMAT_R8G8_SNORM                                         = 17,

  546.     VK_FORMAT_R8G8_USCALED                                       = 18,

  547.     VK_FORMAT_R8G8_SSCALED                                       = 19,

  548.     VK_FORMAT_R8G8_UINT                                          = 20,

  549.     VK_FORMAT_R8G8_SINT                                          = 21,

  550.     VK_FORMAT_R8G8_SRGB                                          = 22,

  551.     VK_FORMAT_R8G8B8_UNORM                                       = 23,

  552.     VK_FORMAT_R8G8B8_SNORM                                       = 24,

  553.     VK_FORMAT_R8G8B8_USCALED                                     = 25,

  554.     VK_FORMAT_R8G8B8_SSCALED                                     = 26,

  555.     VK_FORMAT_R8G8B8_UINT                                        = 27,

  556.     VK_FORMAT_R8G8B8_SINT                                        = 28,

  557.     VK_FORMAT_R8G8B8_SRGB                                        = 29,

  558.     VK_FORMAT_B8G8R8_UNORM                                       = 30,

  559.     VK_FORMAT_B8G8R8_SNORM                                       = 31,

  560.     VK_FORMAT_B8G8R8_USCALED                                     = 32,

  561.     VK_FORMAT_B8G8R8_SSCALED                                     = 33,

  562.     VK_FORMAT_B8G8R8_UINT                                        = 34,

  563.     VK_FORMAT_B8G8R8_SINT                                        = 35,

  564.     VK_FORMAT_B8G8R8_SRGB                                        = 36,

  565.     VK_FORMAT_R8G8B8A8_UNORM                                     = 37,

  566.     VK_FORMAT_R8G8B8A8_SNORM                                     = 38,

  567.     VK_FORMAT_R8G8B8A8_USCALED                                   = 39,

  568.     VK_FORMAT_R8G8B8A8_SSCALED                                   = 40,

  569.     VK_FORMAT_R8G8B8A8_UINT                                      = 41,

  570.     VK_FORMAT_R8G8B8A8_SINT                                      = 42,

  571.     VK_FORMAT_R8G8B8A8_SRGB                                      = 43,

  572.     VK_FORMAT_B8G8R8A8_UNORM                                     = 44,

  573.     VK_FORMAT_B8G8R8A8_SNORM                                     = 45,

  574.     VK_FORMAT_B8G8R8A8_USCALED                                   = 46,

  575.     VK_FORMAT_B8G8R8A8_SSCALED                                   = 47,

  576.     VK_FORMAT_B8G8R8A8_UINT                                      = 48,

  577.     VK_FORMAT_B8G8R8A8_SINT                                      = 49,

  578.     VK_FORMAT_B8G8R8A8_SRGB                                      = 50,

  579.     VK_FORMAT_A8B8G8R8_UNORM_PACK32                              = 51,

  580.     VK_FORMAT_A8B8G8R8_SNORM_PACK32                              = 52,

  581.     VK_FORMAT_A8B8G8R8_USCALED_PACK32                            = 53,

  582.     VK_FORMAT_A8B8G8R8_SSCALED_PACK32                            = 54,

  583.     VK_FORMAT_A8B8G8R8_UINT_PACK32                               = 55,

  584.     VK_FORMAT_A8B8G8R8_SINT_PACK32                               = 56,

  585.     VK_FORMAT_A8B8G8R8_SRGB_PACK32                               = 57,

  586.     VK_FORMAT_A2R10G10B10_UNORM_PACK32                           = 58,

  587.     VK_FORMAT_A2R10G10B10_SNORM_PACK32                           = 59,

  588.     VK_FORMAT_A2R10G10B10_USCALED_PACK32                         = 60,

  589.     VK_FORMAT_A2R10G10B10_SSCALED_PACK32                         = 61,

  590.     VK_FORMAT_A2R10G10B10_UINT_PACK32                            = 62,

  591.     VK_FORMAT_A2R10G10B10_SINT_PACK32                            = 63,

  592.     VK_FORMAT_A2B10G10R10_UNORM_PACK32                           = 64,

  593.     VK_FORMAT_A2B10G10R10_SNORM_PACK32                           = 65,

  594.     VK_FORMAT_A2B10G10R10_USCALED_PACK32                         = 66,

  595.     VK_FORMAT_A2B10G10R10_SSCALED_PACK32                         = 67,

  596.     VK_FORMAT_A2B10G10R10_UINT_PACK32                            = 68,

  597.     VK_FORMAT_A2B10G10R10_SINT_PACK32                            = 69,

  598.     VK_FORMAT_R16_UNORM                                          = 70,

  599.     VK_FORMAT_R16_SNORM                                          = 71,

  600.     VK_FORMAT_R16_USCALED                                        = 72,

  601.     VK_FORMAT_R16_SSCALED                                        = 73,

  602.     VK_FORMAT_R16_UINT                                           = 74,

  603.     VK_FORMAT_R16_SINT                                           = 75,

  604.     VK_FORMAT_R16_SFLOAT                                         = 76,

  605.     VK_FORMAT_R16G16_UNORM                                       = 77,

  606.     VK_FORMAT_R16G16_SNORM                                       = 78,

  607.     VK_FORMAT_R16G16_USCALED                                     = 79,

  608.     VK_FORMAT_R16G16_SSCALED                                     = 80,

  609.     VK_FORMAT_R16G16_UINT                                        = 81,

  610.     VK_FORMAT_R16G16_SINT                                        = 82,

  611.     VK_FORMAT_R16G16_SFLOAT                                      = 83,

  612.     VK_FORMAT_R16G16B16_UNORM                                    = 84,

  613.     VK_FORMAT_R16G16B16_SNORM                                    = 85,

  614.     VK_FORMAT_R16G16B16_USCALED                                  = 86,

  615.     VK_FORMAT_R16G16B16_SSCALED                                  = 87,

  616.     VK_FORMAT_R16G16B16_UINT                                     = 88,

  617.     VK_FORMAT_R16G16B16_SINT                                     = 89,

  618.     VK_FORMAT_R16G16B16_SFLOAT                                   = 90,

  619.     VK_FORMAT_R16G16B16A16_UNORM                                 = 91,

  620.     VK_FORMAT_R16G16B16A16_SNORM                                 = 92,

  621.     VK_FORMAT_R16G16B16A16_USCALED                               = 93,

  622.     VK_FORMAT_R16G16B16A16_SSCALED                               = 94,

  623.     VK_FORMAT_R16G16B16A16_UINT                                  = 95,

  624.     VK_FORMAT_R16G16B16A16_SINT                                  = 96,

  625.     VK_FORMAT_R16G16B16A16_SFLOAT                                = 97,

  626.     VK_FORMAT_R32_UINT                                           = 98,

  627.     VK_FORMAT_R32_SINT                                           = 99,

  628.     VK_FORMAT_R32_SFLOAT                                         = 100,

  629.     VK_FORMAT_R32G32_UINT                                        = 101,

  630.     VK_FORMAT_R32G32_SINT                                        = 102,

  631.     VK_FORMAT_R32G32_SFLOAT                                      = 103,

  632.     VK_FORMAT_R32G32B32_UINT                                     = 104,

  633.     VK_FORMAT_R32G32B32_SINT                                     = 105,

  634.     VK_FORMAT_R32G32B32_SFLOAT                                   = 106,

  635.     VK_FORMAT_R32G32B32A32_UINT                                  = 107,

  636.     VK_FORMAT_R32G32B32A32_SINT                                  = 108,

  637.     VK_FORMAT_R32G32B32A32_SFLOAT                                = 109,

  638.     VK_FORMAT_R64_UINT                                           = 110,

  639.     VK_FORMAT_R64_SINT                                           = 111,

  640.     VK_FORMAT_R64_SFLOAT                                         = 112,

  641.     VK_FORMAT_R64G64_UINT                                        = 113,

  642.     VK_FORMAT_R64G64_SINT                                        = 114,

  643.     VK_FORMAT_R64G64_SFLOAT                                      = 115,

  644.     VK_FORMAT_R64G64B64_UINT                                     = 116,

  645.     VK_FORMAT_R64G64B64_SINT                                     = 117,

  646.     VK_FORMAT_R64G64B64_SFLOAT                                   = 118,

  647.     VK_FORMAT_R64G64B64A64_UINT                                  = 119,

  648.     VK_FORMAT_R64G64B64A64_SINT                                  = 120,

  649.     VK_FORMAT_R64G64B64A64_SFLOAT                                = 121,

  650.     VK_FORMAT_B10G11R11_UFLOAT_PACK32                            = 122,

  651.     VK_FORMAT_E5B9G9R9_UFLOAT_PACK32                             = 123,

  652.     VK_FORMAT_D16_UNORM                                          = 124,

  653.     VK_FORMAT_X8_D24_UNORM_PACK32                                = 125,

  654.     VK_FORMAT_D32_SFLOAT                                         = 126,

  655.     VK_FORMAT_S8_UINT                                            = 127,

  656.     VK_FORMAT_D16_UNORM_S8_UINT                                  = 128,

  657.     VK_FORMAT_D24_UNORM_S8_UINT                                  = 129,

  658.     VK_FORMAT_D32_SFLOAT_S8_UINT                                 = 130,

  659.     VK_FORMAT_BC1_RGB_UNORM_BLOCK                                = 131,

  660.     VK_FORMAT_BC1_RGB_SRGB_BLOCK                                 = 132,

  661.     VK_FORMAT_BC1_RGBA_UNORM_BLOCK                               = 133,

  662.     VK_FORMAT_BC1_RGBA_SRGB_BLOCK                                = 134,

  663.     VK_FORMAT_BC2_UNORM_BLOCK                                    = 135,

  664.     VK_FORMAT_BC2_SRGB_BLOCK                                     = 136,

  665.     VK_FORMAT_BC3_UNORM_BLOCK                                    = 137,

  666.     VK_FORMAT_BC3_SRGB_BLOCK                                     = 138,

  667.     VK_FORMAT_BC4_UNORM_BLOCK                                    = 139,

  668.     VK_FORMAT_BC4_SNORM_BLOCK                                    = 140,

  669.     VK_FORMAT_BC5_UNORM_BLOCK                                    = 141,

  670.     VK_FORMAT_BC5_SNORM_BLOCK                                    = 142,

  671.     VK_FORMAT_BC6H_UFLOAT_BLOCK                                  = 143,

  672.     VK_FORMAT_BC6H_SFLOAT_BLOCK                                  = 144,

  673.     VK_FORMAT_BC7_UNORM_BLOCK                                    = 145,

  674.     VK_FORMAT_BC7_SRGB_BLOCK                                     = 146,

  675.     VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK                            = 147,

  676.     VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK                             = 148,

  677.     VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK                          = 149,

  678.     VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK                           = 150,

  679.     VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK                          = 151,

  680.     VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK                           = 152,

  681.     VK_FORMAT_EAC_R11_UNORM_BLOCK                                = 153,

  682.     VK_FORMAT_EAC_R11_SNORM_BLOCK                                = 154,

  683.     VK_FORMAT_EAC_R11G11_UNORM_BLOCK                             = 155,

  684.     VK_FORMAT_EAC_R11G11_SNORM_BLOCK                             = 156,

  685.     VK_FORMAT_ASTC_4x4_UNORM_BLOCK                               = 157,

  686.     VK_FORMAT_ASTC_4x4_SRGB_BLOCK                                = 158,

  687.     VK_FORMAT_ASTC_5x4_UNORM_BLOCK                               = 159,

  688.     VK_FORMAT_ASTC_5x4_SRGB_BLOCK                                = 160,

  689.     VK_FORMAT_ASTC_5x5_UNORM_BLOCK                               = 161,

  690.     VK_FORMAT_ASTC_5x5_SRGB_BLOCK                                = 162,

  691.     VK_FORMAT_ASTC_6x5_UNORM_BLOCK                               = 163,

  692.     VK_FORMAT_ASTC_6x5_SRGB_BLOCK                                = 164,

  693.     VK_FORMAT_ASTC_6x6_UNORM_BLOCK                               = 165,

  694.     VK_FORMAT_ASTC_6x6_SRGB_BLOCK                                = 166,

  695.     VK_FORMAT_ASTC_8x5_UNORM_BLOCK                               = 167,

  696.     VK_FORMAT_ASTC_8x5_SRGB_BLOCK                                = 168,

  697.     VK_FORMAT_ASTC_8x6_UNORM_BLOCK                               = 169,

  698.     VK_FORMAT_ASTC_8x6_SRGB_BLOCK                                = 170,

  699.     VK_FORMAT_ASTC_8x8_UNORM_BLOCK                               = 171,

  700.     VK_FORMAT_ASTC_8x8_SRGB_BLOCK                                = 172,

  701.     VK_FORMAT_ASTC_10x5_UNORM_BLOCK                              = 173,

  702.     VK_FORMAT_ASTC_10x5_SRGB_BLOCK                               = 174,

  703.     VK_FORMAT_ASTC_10x6_UNORM_BLOCK                              = 175,

  704.     VK_FORMAT_ASTC_10x6_SRGB_BLOCK                               = 176,

  705.     VK_FORMAT_ASTC_10x8_UNORM_BLOCK                              = 177,

  706.     VK_FORMAT_ASTC_10x8_SRGB_BLOCK                               = 178,

  707.     VK_FORMAT_ASTC_10x10_UNORM_BLOCK                             = 179,

  708.     VK_FORMAT_ASTC_10x10_SRGB_BLOCK                              = 180,

  709.     VK_FORMAT_ASTC_12x10_UNORM_BLOCK                             = 181,

  710.     VK_FORMAT_ASTC_12x10_SRGB_BLOCK                              = 182,

  711.     VK_FORMAT_ASTC_12x12_UNORM_BLOCK                             = 183,

  712.     VK_FORMAT_ASTC_12x12_SRGB_BLOCK                              = 184

  713.   );

  714.   PVkFormat = ^TVkFormat;

  715. 

  716.   TVkFrontFace = (

  717.     VK_FRONT_FACE_COUNTER_CLOCKWISE                              = 0,

  718.     VK_FRONT_FACE_CLOCKWISE                                      = 1

  719.   );

  720.   PVkFrontFace = ^TVkFrontFace;

  721. 

  722.   TVkImageLayout = (

  723.     VK_IMAGE_LAYOUT_UNDEFINED                                    = 0,

  724.     VK_IMAGE_LAYOUT_GENERAL                                      = 1,

  725.     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                     = 2,

  726.     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL             = 3,

  727.     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL              = 4,

  728.     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL                     = 5,

  729.     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL                         = 6,

  730.     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL                         = 7,

  731.     VK_IMAGE_LAYOUT_PREINITIALIZED                               = 8

  732.   );

  733.   PVkImageLayout = ^TVkImageLayout;

  734. 

  735.   TVkImageTiling = (

  736.     VK_IMAGE_TILING_OPTIMAL                                      = 0,

  737.     VK_IMAGE_TILING_LINEAR                                       = 1

  738.   );

  739.   PVkImageTiling = ^TVkImageTiling;

  740. 

  741.   TVkImageType = (

  742.     VK_IMAGE_TYPE_1D                                             = 0,

  743.     VK_IMAGE_TYPE_2D                                             = 1,

  744.     VK_IMAGE_TYPE_3D                                             = 2

  745.   );

  746.   PVkImageType = ^TVkImageType;

  747. 

  748.   TVkImageViewType = (

  749.     VK_IMAGE_VIEW_TYPE_1D                                        = 0,

  750.     VK_IMAGE_VIEW_TYPE_2D                                        = 1,

  751.     VK_IMAGE_VIEW_TYPE_3D                                        = 2,

  752.     VK_IMAGE_VIEW_TYPE_CUBE                                      = 3,

  753.     VK_IMAGE_VIEW_TYPE_1D_ARRAY                                  = 4,

  754.     VK_IMAGE_VIEW_TYPE_2D_ARRAY                                  = 5,

  755.     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY                                = 6

  756.   );

  757.   PVkImageViewType = ^TVkImageViewType;

  758. 

  759.   TVkIndexType = (

  760.     VK_INDEX_TYPE_UINT16                                         = 0,

  761.     VK_INDEX_TYPE_UINT32                                         = 1

  762.   );

  763.   PVkIndexType = ^TVkIndexType;

  764. 

  765.   TVkInternalAllocationType = (

  766.     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE                       = 0

  767.   );

  768.   PVkInternalAllocationType = ^TVkInternalAllocationType;

  769. 

  770.   TVkLogicOp = (

  771.     VK_LOGIC_OP_CLEAR                                            = 0,

  772.     VK_LOGIC_OP_AND                                              = 1,

  773.     VK_LOGIC_OP_AND_REVERSE                                      = 2,

  774.     VK_LOGIC_OP_COPY                                             = 3,

  775.     VK_LOGIC_OP_AND_INVERTED                                     = 4,

  776.     VK_LOGIC_OP_NO_OP                                            = 5,

  777.     VK_LOGIC_OP_XOR                                              = 6,

  778.     VK_LOGIC_OP_OR                                               = 7,

  779.     VK_LOGIC_OP_NOR                                              = 8,

  780.     VK_LOGIC_OP_EQUIVALENT                                       = 9,

  781.     VK_LOGIC_OP_INVERT                                           = 10,

  782.     VK_LOGIC_OP_OR_REVERSE                                       = 11,

  783.     VK_LOGIC_OP_COPY_INVERTED                                    = 12,

  784.     VK_LOGIC_OP_OR_INVERTED                                      = 13,

  785.     VK_LOGIC_OP_NAND                                             = 14,

  786.     VK_LOGIC_OP_SET                                              = 15

  787.   );

  788.   PVkLogicOp = ^TVkLogicOp;

  789. 

  790.   TVkPhysicalDeviceType = (

  791.     VK_PHYSICAL_DEVICE_TYPE_OTHER                                = 0,

  792.     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU                       = 1,

  793.     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU                         = 2,

  794.     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU                          = 3,

  795.     VK_PHYSICAL_DEVICE_TYPE_CPU                                  = 4

  796.   );

  797.   PVkPhysicalDeviceType = ^TVkPhysicalDeviceType;

  798. 

  799.   TVkPipelineBindPoint = (

  800.     VK_PIPELINE_BIND_POINT_GRAPHICS                              = 0,

  801.     VK_PIPELINE_BIND_POINT_COMPUTE                               = 1

  802.   );

  803.   PVkPipelineBindPoint = ^TVkPipelineBindPoint;

  804. 

  805.   TVkPipelineCacheHeaderVersion = (

  806.     VK_PIPELINE_CACHE_HEADER_VERSION_ONE                         = 1

  807.   );

  808.   PVkPipelineCacheHeaderVersion = ^TVkPipelineCacheHeaderVersion;

  809. 

  810.   TVkPipelineStageFlagBits = (

  811.     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT                            = (1 shl 0),

  812.     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT                          = (1 shl 1),

  813.     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT                           = (1 shl 2),

  814.     VK_PIPELINE_STAGE_VERTEX_SHADER_BIT                          = (1 shl 3),

  815.     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT            = (1 shl 4),

  816.     VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT         = (1 shl 5),

  817.     VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT                        = (1 shl 6),

  818.     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT                        = (1 shl 7),

  819.     VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT                   = (1 shl 8),

  820.     VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT                    = (1 shl 9),

  821.     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT                = (1 shl 10),

  822.     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT                         = (1 shl 11),

  823.     VK_PIPELINE_STAGE_TRANSFER_BIT                               = (1 shl 12),

  824.     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT                         = (1 shl 13),

  825.     VK_PIPELINE_STAGE_HOST_BIT                                   = (1 shl 14),

  826.     VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT                           = (1 shl 15),

  827.     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT                           = (1 shl 16)

  828.   );

  829.   PVkPipelineStageFlagBits = ^TVkPipelineStageFlagBits;

  830. 

  831.   TVkPolygonMode = (

  832.     VK_POLYGON_MODE_FILL                                         = 0,

  833.     VK_POLYGON_MODE_LINE                                         = 1,

  834.     VK_POLYGON_MODE_POINT                                        = 2

  835.   );

  836.   PVkPolygonMode = ^TVkPolygonMode;

  837. 

  838.   TVkPrimitiveTopology = (

  839.     VK_PRIMITIVE_TOPOLOGY_POINT_LIST                             = 0,

  840.     VK_PRIMITIVE_TOPOLOGY_LINE_LIST                              = 1,

  841.     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP                             = 2,

  842.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST                          = 3,

  843.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP                         = 4,

  844.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN                           = 5,

  845.     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY               = 6,

  846.     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY              = 7,

  847.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY           = 8,

  848.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY          = 9,

  849.     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST                             = 10

  850.   );

  851.   PVkPrimitiveTopology = ^TVkPrimitiveTopology;

  852. 

  853.   TVkQueryType = (

  854.     VK_QUERY_TYPE_OCCLUSION                                      = 0,

  855.     VK_QUERY_TYPE_PIPELINE_STATISTICS                            = 1,

  856.     VK_QUERY_TYPE_TIMESTAMP                                      = 2

  857.   );

  858.   PVkQueryType = ^TVkQueryType;

  859. 

  860.   TVkResult = (

  861.     VK_SUCCESS                                                   = 0,

  862.     VK_NOT_READY                                                 = 1,

  863.     VK_TIMEOUT                                                   = 2,

  864.     VK_EVENT_SET                                                 = 3,

  865.     VK_EVENT_RESET                                               = 4,

  866.     VK_INCOMPLETE                                                = 5,

  867.     VK_ERROR_OUT_OF_HOST_MEMORY                                  = -1,

  868.     VK_ERROR_OUT_OF_DEVICE_MEMORY                                = -2,

  869.     VK_ERROR_INITIALIZATION_FAILED                               = -3,

  870.     VK_ERROR_DEVICE_LOST                                         = -4,

  871.     VK_ERROR_MEMORY_MAP_FAILED                                   = -5,

  872.     VK_ERROR_LAYER_NOT_PRESENT                                   = -6,

  873.     VK_ERROR_EXTENSION_NOT_PRESENT                               = -7,

  874.     VK_ERROR_FEATURE_NOT_PRESENT                                 = -8,

  875.     VK_ERROR_INCOMPATIBLE_DRIVER                                 = -9,

  876.     VK_ERROR_TOO_MANY_OBJECTS                                    = -10,

  877.     VK_ERROR_FORMAT_NOT_SUPPORTED                                = -11

  878.   );

  879.   PVkResult = ^TVkResult;

  880. 

  881.   TVkSampleCountFlagBits = (

  882.     VK_SAMPLE_COUNT_1_BIT                                        = (1 shl 0),

  883.     VK_SAMPLE_COUNT_2_BIT                                        = (1 shl 1),

  884.     VK_SAMPLE_COUNT_4_BIT                                        = (1 shl 2),

  885.     VK_SAMPLE_COUNT_8_BIT                                        = (1 shl 3),

  886.     VK_SAMPLE_COUNT_16_BIT                                       = (1 shl 4),

  887.     VK_SAMPLE_COUNT_32_BIT                                       = (1 shl 5),

  888.     VK_SAMPLE_COUNT_64_BIT                                       = (1 shl 6)

  889.   );

  890.   PVkSampleCountFlagBits = ^TVkSampleCountFlagBits;

  891. 

  892.   TVkSamplerAddressMode = (

  893.     VK_SAMPLER_ADDRESS_MODE_REPEAT                               = 0,

  894.     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT                      = 1,

  895.     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE                        = 2,

  896.     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER                      = 3,

  897.     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE                 = 4

  898.   );

  899.   PVkSamplerAddressMode = ^TVkSamplerAddressMode;

  900. 

  901.   TVkSamplerMipmapMode = (

  902.     VK_SAMPLER_MIPMAP_MODE_NEAREST                               = 0,

  903.     VK_SAMPLER_MIPMAP_MODE_LINEAR                                = 1

  904.   );

  905.   PVkSamplerMipmapMode = ^TVkSamplerMipmapMode;

  906. 

  907.   TVkShaderStageFlagBits = (

  908.     VK_SHADER_STAGE_VERTEX_BIT                                   = (1 shl 0),

  909.     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT                     = (1 shl 1),

  910.     VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT                  = (1 shl 2),

  911.     VK_SHADER_STAGE_GEOMETRY_BIT                                 = (1 shl 3),

  912.     VK_SHADER_STAGE_FRAGMENT_BIT                                 = (1 shl 4),

  913.     VK_SHADER_STAGE_COMPUTE_BIT                                  = (1 shl 5),

  914.     VK_SHADER_STAGE_ALL_GRAPHICS                                 = $1F,

  915.     VK_SHADER_STAGE_ALL                                          = $7FFFFFFF

  916.   );

  917.   PVkShaderStageFlagBits = ^TVkShaderStageFlagBits;

  918. 

  919.   TVkSharingMode = (

  920.     VK_SHARING_MODE_EXCLUSIVE                                    = 0,

  921.     VK_SHARING_MODE_CONCURRENT                                   = 1

  922.   );

  923.   PVkSharingMode = ^TVkSharingMode;

  924. 

  925.   TVkStencilOp = (

  926.     VK_STENCIL_OP_KEEP                                           = 0,

  927.     VK_STENCIL_OP_ZERO                                           = 1,

  928.     VK_STENCIL_OP_REPLACE                                        = 2,

  929.     VK_STENCIL_OP_INCREMENT_AND_CLAMP                            = 3,

  930.     VK_STENCIL_OP_DECREMENT_AND_CLAMP                            = 4,

  931.     VK_STENCIL_OP_INVERT                                         = 5,

  932.     VK_STENCIL_OP_INCREMENT_AND_WRAP                             = 6,

  933.     VK_STENCIL_OP_DECREMENT_AND_WRAP                             = 7

  934.   );

  935.   PVkStencilOp = ^TVkStencilOp;

  936. 

  937.   TVkStructureType = (

  938.     VK_STRUCTURE_TYPE_APPLICATION_INFO                           = 0,

  939.     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO                       = 1,

  940.     VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO                   = 2,

  941.     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO                         = 3,

  942.     VK_STRUCTURE_TYPE_SUBMIT_INFO                                = 4,

  943.     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO                       = 5,

  944.     VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE                        = 6,

  945.     VK_STRUCTURE_TYPE_BIND_SPARSE_INFO                           = 7,

  946.     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO                          = 8,

  947.     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO                      = 9,

  948.     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO                          = 10,

  949.     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO                     = 11,

  950.     VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO                         = 12,

  951.     VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO                    = 13,

  952.     VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO                          = 14,

  953.     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO                     = 15,

  954.     VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO                  = 16,

  955.     VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO                 = 17,

  956.     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO          = 18,

  957.     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO    = 19,

  958.     VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO  = 20,

  959.     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO    = 21,

  960.     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO        = 22,

  961.     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO   = 23,

  962.     VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO     = 24,

  963.     VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO   = 25,

  964.     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO     = 26,

  965.     VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO         = 27,

  966.     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO              = 28,

  967.     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO               = 29,

  968.     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO                = 30,

  969.     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO                        = 31,

  970.     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO          = 32,

  971.     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO                = 33,

  972.     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO               = 34,

  973.     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET                       = 35,

  974.     VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET                        = 36,

  975.     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO                    = 37,

  976.     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO                    = 38,

  977.     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO                   = 39,

  978.     VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO               = 40,

  979.     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO            = 41,

  980.     VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO                  = 42,

  981.     VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO                     = 43,

  982.     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER                      = 44,

  983.     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER                       = 45,

  984.     VK_STRUCTURE_TYPE_MEMORY_BARRIER                             = 46,

  985.     VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO                = 47,

  986.     VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO                  = 48

  987.   );

  988.   PVkStructureType = ^TVkStructureType;

  989. 

  990.   TVkSubpassContents = (

  991.     VK_SUBPASS_CONTENTS_INLINE                                   = 0,

  992.     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS                = 1

  993.   );

  994.   PVkSubpassContents = ^TVkSubpassContents;

  995. 

  996.   TVkSystemAllocationScope = (

  997.     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND                           = 0,

  998.     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT                            = 1,

  999.     VK_SYSTEM_ALLOCATION_SCOPE_CACHE                             = 2,

  1000.     VK_SYSTEM_ALLOCATION_SCOPE_DEVICE                            = 3,

  1001.     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE                          = 4

  1002.   );

  1003.   PVkSystemAllocationScope = ^TVkSystemAllocationScope;

  1004. 

  1005.   TVkVertexInputRate = (

  1006.     VK_VERTEX_INPUT_RATE_VERTEX                                  = 0,

  1007.     VK_VERTEX_INPUT_RATE_INSTANCE                                = 1

  1008.   );

  1009.   PVkVertexInputRate = ^TVkVertexInputRate;

  1010. 

  1011. type { funcptrs }

  1012.   TvkVoidFunction                                    = procedure(); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1013.   TvkFreeFunction                                    = procedure(pUserData: PVkVoid; pMemory: PVkVoid); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1014.   TvkAllocationFunction                              = procedure(pUserData: PVkVoid; size: VkSize; alignment: VkSize; allocationScope: TVkSystemAllocationScope); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1015.   TvkInternalAllocationNotification                  = procedure(pUserData: PVkVoid; size: VkSize; allocationType: TVkInternalAllocationType; allocationScope: TVkSystemAllocationScope); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1016.   TvkInternalFreeNotification                        = procedure(pUserData: PVkVoid; size: VkSize; allocationType: TVkInternalAllocationType; allocationScope: TVkSystemAllocationScope); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1017.   TvkReallocationFunction                            = procedure(pUserData: PVkVoid; pOriginal: PVkVoid; size: VkSize; alignment: VkSize; allocationScope: TVkSystemAllocationScope); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  1018. 

  1019. type { structs }

  1020.   TVkViewport = record

  1021.     x:                                                VkFloat;

  1022.     y:                                                VkFloat;

  1023.     width:                                            VkFloat;

  1024.     height:                                           VkFloat;

  1025.     minDepth:                                         VkFloat;

  1026.     maxDepth:                                         VkFloat;

  1027.   end;

  1028.   PVkViewport = ^TVkViewport;

  1029.   PPVkViewport = ^PVkViewport;

  1030. 

  1031.   TVkOffset2D = record

  1032.     x:                                                VkInt32;

  1033.     y:                                                VkInt32;

  1034.   end;

  1035.   PVkOffset2D = ^TVkOffset2D;

  1036.   PPVkOffset2D = ^PVkOffset2D;

  1037. 

  1038.   TVkOffset3D = record

  1039.     x:                                                VkInt32;

  1040.     y:                                                VkInt32;

  1041.     z:                                                VkInt32;

  1042.   end;

  1043.   PVkOffset3D = ^TVkOffset3D;

  1044.   PPVkOffset3D = ^PVkOffset3D;

  1045. 

  1046.   TVkClearColorValue = record

  1047.     case Integer of

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

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

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

  1051.   end;

  1052.   PVkClearColorValue = ^TVkClearColorValue;

  1053.   PPVkClearColorValue = ^PVkClearColorValue;

  1054. 

  1055.   TVkClearDepthStencilValue = record

  1056.     depth:                                            VkFloat;

  1057.     stencil:                                          VkUint32;

  1058.   end;

  1059.   PVkClearDepthStencilValue = ^TVkClearDepthStencilValue;

  1060.   PPVkClearDepthStencilValue = ^PVkClearDepthStencilValue;

  1061. 

  1062.   TVkDispatchIndirectCommand = record

  1063.     x:                                                VkUint32;

  1064.     y:                                                VkUint32;

  1065.     z:                                                VkUint32;

  1066.   end;

  1067.   PVkDispatchIndirectCommand = ^TVkDispatchIndirectCommand;

  1068.   PPVkDispatchIndirectCommand = ^PVkDispatchIndirectCommand;

  1069. 

  1070.   TVkDrawIndexedIndirectCommand = record

  1071.     indexCount:                                       VkUint32;

  1072.     instanceCount:                                    VkUint32;

  1073.     firstIndex:                                       VkUint32;

  1074.     vertexOffset:                                     VkInt32;

  1075.     firstInstance:                                    VkUint32;

  1076.   end;

  1077.   PVkDrawIndexedIndirectCommand = ^TVkDrawIndexedIndirectCommand;

  1078.   PPVkDrawIndexedIndirectCommand = ^PVkDrawIndexedIndirectCommand;

  1079. 

  1080.   TVkDrawIndirectCommand = record

  1081.     vertexCount:                                      VkUint32;

  1082.     instanceCount:                                    VkUint32;

  1083.     firstVertex:                                      VkUint32;

  1084.     firstInstance:                                    VkUint32;

  1085.   end;

  1086.   PVkDrawIndirectCommand = ^TVkDrawIndirectCommand;

  1087.   PPVkDrawIndirectCommand = ^PVkDrawIndirectCommand;

  1088. 

  1089.   TVkExtensionProperties = record

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

  1091.     specVersion:                                      VkUint32;

  1092.   end;

  1093.   PVkExtensionProperties = ^TVkExtensionProperties;

  1094.   PPVkExtensionProperties = ^PVkExtensionProperties;

  1095. 

  1096.   TVkExtent2D = record

  1097.     width:                                            VkUint32;

  1098.     height:                                           VkUint32;

  1099.   end;

  1100.   PVkExtent2D = ^TVkExtent2D;

  1101.   PPVkExtent2D = ^PVkExtent2D;

  1102. 

  1103.   TVkExtent3D = record

  1104.     width:                                            VkUint32;

  1105.     height:                                           VkUint32;

  1106.     depth:                                            VkUint32;

  1107.   end;

  1108.   PVkExtent3D = ^TVkExtent3D;

  1109.   PPVkExtent3D = ^PVkExtent3D;

  1110. 

  1111.   TVkLayerProperties = record

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

  1113.     specVersion:                                      VkUint32;

  1114.     implementationVersion:                            VkUint32;

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

  1116.   end;

  1117.   PVkLayerProperties = ^TVkLayerProperties;

  1118.   PPVkLayerProperties = ^PVkLayerProperties;

  1119. 

  1120.   TVkSpecializationMapEntry = record

  1121.     constantID:                                       VkUint32;

  1122.     offset:                                           VkUint32;

  1123.     size:                                             VkSize;

  1124.   end;

  1125.   PVkSpecializationMapEntry = ^TVkSpecializationMapEntry;

  1126.   PPVkSpecializationMapEntry = ^PVkSpecializationMapEntry;

  1127. 

  1128.   TVkPhysicalDeviceFeatures = record

  1129.     robustBufferAccess:                               VkBool32;

  1130.     fullDrawIndexUint32:                              VkBool32;

  1131.     imageCubeArray:                                   VkBool32;

  1132.     independentBlend:                                 VkBool32;

  1133.     geometryShader:                                   VkBool32;

  1134.     tessellationShader:                               VkBool32;

  1135.     sampleRateShading:                                VkBool32;

  1136.     dualSrcBlend:                                     VkBool32;

  1137.     logicOp:                                          VkBool32;

  1138.     multiDrawIndirect:                                VkBool32;

  1139.     drawIndirectFirstInstance:                        VkBool32;

  1140.     depthClamp:                                       VkBool32;

  1141.     depthBiasClamp:                                   VkBool32;

  1142.     fillModeNonSolid:                                 VkBool32;

  1143.     depthBounds:                                      VkBool32;

  1144.     wideLines:                                        VkBool32;

  1145.     largePoints:                                      VkBool32;

  1146.     alphaToOne:                                       VkBool32;

  1147.     multiViewport:                                    VkBool32;

  1148.     samplerAnisotropy:                                VkBool32;

  1149.     textureCompressionETC2:                           VkBool32;

  1150.     textureCompressionASTC_LDR:                       VkBool32;

  1151.     textureCompressionBC:                             VkBool32;

  1152.     occlusionQueryPrecise:                            VkBool32;

  1153.     pipelineStatisticsQuery:                          VkBool32;

  1154.     vertexPipelineStoresAndAtomics:                   VkBool32;

  1155.     fragmentStoresAndAtomics:                         VkBool32;

  1156.     shaderTessellationAndGeometryPointSize:           VkBool32;

  1157.     shaderImageGatherExtended:                        VkBool32;

  1158.     shaderStorageImageExtendedFormats:                VkBool32;

  1159.     shaderStorageImageMultisample:                    VkBool32;

  1160.     shaderStorageImageReadWithoutFormat:              VkBool32;

  1161.     shaderStorageImageWriteWithoutFormat:             VkBool32;

  1162.     shaderUniformBufferArrayDynamicIndexing:          VkBool32;

  1163.     shaderSampledImageArrayDynamicIndexing:           VkBool32;

  1164.     shaderStorageBufferArrayDynamicIndexing:          VkBool32;

  1165.     shaderStorageImageArrayDynamicIndexing:           VkBool32;

  1166.     shaderClipDistance:                               VkBool32;

  1167.     shaderCullDistance:                               VkBool32;

  1168.     shaderFloat64:                                    VkBool32;

  1169.     shaderInt64:                                      VkBool32;

  1170.     shaderInt16:                                      VkBool32;

  1171.     shaderResourceResidency:                          VkBool32;

  1172.     shaderResourceMinLod:                             VkBool32;

  1173.     sparseBinding:                                    VkBool32;

  1174.     sparseResidencyBuffer:                            VkBool32;

  1175.     sparseResidencyImage2D:                           VkBool32;

  1176.     sparseResidencyImage3D:                           VkBool32;

  1177.     sparseResidency2Samples:                          VkBool32;

  1178.     sparseResidency4Samples:                          VkBool32;

  1179.     sparseResidency8Samples:                          VkBool32;

  1180.     sparseResidency16Samples:                         VkBool32;

  1181.     sparseResidencyAliased:                           VkBool32;

  1182.     variableMultisampleRate:                          VkBool32;

  1183.     inheritedQueries:                                 VkBool32;

  1184.   end;

  1185.   PVkPhysicalDeviceFeatures = ^TVkPhysicalDeviceFeatures;

  1186.   PPVkPhysicalDeviceFeatures = ^PVkPhysicalDeviceFeatures;

  1187. 

  1188.   TVkPhysicalDeviceSparseProperties = record

  1189.     residencyStandard2DBlockShape:                    VkBool32;

  1190.     residencyStandard2DMultisampleBlockShape:         VkBool32;

  1191.     residencyStandard3DBlockShape:                    VkBool32;

  1192.     residencyAlignedMipSize:                          VkBool32;

  1193.     residencyNonResidentStrict:                       VkBool32;

  1194.   end;

  1195.   PVkPhysicalDeviceSparseProperties = ^TVkPhysicalDeviceSparseProperties;

  1196.   PPVkPhysicalDeviceSparseProperties = ^PVkPhysicalDeviceSparseProperties;

  1197. 

  1198.   TVkBufferCopy = record

  1199.     srcOffset:                                        VkDeviceSize;

  1200.     dstOffset:                                        VkDeviceSize;

  1201.     size:                                             VkDeviceSize;

  1202.   end;

  1203.   PVkBufferCopy = ^TVkBufferCopy;

  1204.   PPVkBufferCopy = ^PVkBufferCopy;

  1205. 

  1206.   TVkMemoryRequirements = record

  1207.     size:                                             VkDeviceSize;

  1208.     alignment:                                        VkDeviceSize;

  1209.     memoryTypeBits:                                   VkUint32;

  1210.   end;

  1211.   PVkMemoryRequirements = ^TVkMemoryRequirements;

  1212.   PPVkMemoryRequirements = ^PVkMemoryRequirements;

  1213. 

  1214.   TVkSubresourceLayout = record

  1215.     offset:                                           VkDeviceSize;

  1216.     size:                                             VkDeviceSize;

  1217.     rowPitch:                                         VkDeviceSize;

  1218.     arrayPitch:                                       VkDeviceSize;

  1219.     depthPitch:                                       VkDeviceSize;

  1220.   end;

  1221.   PVkSubresourceLayout = ^TVkSubresourceLayout;

  1222.   PPVkSubresourceLayout = ^PVkSubresourceLayout;

  1223. 

  1224.   TVkFormatProperties = record

  1225.     linearTilingFeatures:                             VkFormatFeatureFlags;

  1226.     optimalTilingFeatures:                            VkFormatFeatureFlags;

  1227.     bufferFeatures:                                   VkFormatFeatureFlags;

  1228.   end;

  1229.   PVkFormatProperties = ^TVkFormatProperties;

  1230.   PPVkFormatProperties = ^PVkFormatProperties;

  1231. 

  1232.   TVkImageSubresource = record

  1233.     aspectMask:                                       VkImageAspectFlags;

  1234.     mipLevel:                                         VkUint32;

  1235.     arrayLayer:                                       VkUint32;

  1236.   end;

  1237.   PVkImageSubresource = ^TVkImageSubresource;

  1238.   PPVkImageSubresource = ^PVkImageSubresource;

  1239. 

  1240.   TVkImageSubresourceLayers = record

  1241.     aspectMask:                                       VkImageAspectFlags;

  1242.     mipLevel:                                         VkUint32;

  1243.     baseArrayLayer:                                   VkUint32;

  1244.     layerCount:                                       VkUint32;

  1245.   end;

  1246.   PVkImageSubresourceLayers = ^TVkImageSubresourceLayers;

  1247.   PPVkImageSubresourceLayers = ^PVkImageSubresourceLayers;

  1248. 

  1249.   TVkImageSubresourceRange = record

  1250.     aspectMask:                                       VkImageAspectFlags;

  1251.     baseMipLevel:                                     VkUint32;

  1252.     levelCount:                                       VkUint32;

  1253.     baseArrayLayer:                                   VkUint32;

  1254.     layerCount:                                       VkUint32;

  1255.   end;

  1256.   PVkImageSubresourceRange = ^TVkImageSubresourceRange;

  1257.   PPVkImageSubresourceRange = ^PVkImageSubresourceRange;

  1258. 

  1259.   TVkMemoryHeap = record

  1260.     size:                                             VkDeviceSize;

  1261.     flags:                                            VkMemoryHeapFlags;

  1262.   end;

  1263.   PVkMemoryHeap = ^TVkMemoryHeap;

  1264.   PPVkMemoryHeap = ^PVkMemoryHeap;

  1265. 

  1266.   TVkMemoryType = record

  1267.     propertyFlags:                                    VkMemoryPropertyFlags;

  1268.     heapIndex:                                        VkUint32;

  1269.   end;

  1270.   PVkMemoryType = ^TVkMemoryType;

  1271.   PPVkMemoryType = ^PVkMemoryType;

  1272. 

  1273.   TVkSubpassDependency = record

  1274.     srcSubpass:                                       VkUint32;

  1275.     dstSubpass:                                       VkUint32;

  1276.     srcStageMask:                                     VkPipelineStageFlags;

  1277.     dstStageMask:                                     VkPipelineStageFlags;

  1278.     srcAccessMask:                                    VkAccessFlags;

  1279.     dstAccessMask:                                    VkAccessFlags;

  1280.     dependencyFlags:                                  VkDependencyFlags;

  1281.   end;

  1282.   PVkSubpassDependency = ^TVkSubpassDependency;

  1283.   PPVkSubpassDependency = ^PVkSubpassDependency;

  1284. 

  1285.   TVkPushConstantRange = record

  1286.     stageFlags:                                       VkShaderStageFlags;

  1287.     offset:                                           VkUint32;

  1288.     size:                                             VkUint32;

  1289.   end;

  1290.   PVkPushConstantRange = ^TVkPushConstantRange;

  1291.   PPVkPushConstantRange = ^PVkPushConstantRange;

  1292. 

  1293.   TVkPhysicalDeviceLimits = record

  1294.     maxImageDimension1D:                              VkUint32;

  1295.     maxImageDimension2D:                              VkUint32;

  1296.     maxImageDimension3D:                              VkUint32;

  1297.     maxImageDimensionCube:                            VkUint32;

  1298.     maxImageArrayLayers:                              VkUint32;

  1299.     maxTexelBufferElements:                           VkUint32;

  1300.     maxUniformBufferRange:                            VkUint32;

  1301.     maxStorageBufferRange:                            VkUint32;

  1302.     maxPushConstantsSize:                             VkUint32;

  1303.     maxMemoryAllocationCount:                         VkUint32;

  1304.     maxSamplerAllocationCount:                        VkUint32;

  1305.     bufferImageGranularity:                           VkDeviceSize;

  1306.     sparseAddressSpaceSize:                           VkDeviceSize;

  1307.     maxBoundDescriptorSets:                           VkUint32;

  1308.     maxPerStageDescriptorSamplers:                    VkUint32;

  1309.     maxPerStageDescriptorUniformBuffers:              VkUint32;

  1310.     maxPerStageDescriptorStorageBuffers:              VkUint32;

  1311.     maxPerStageDescriptorSampledImages:               VkUint32;

  1312.     maxPerStageDescriptorStorageImages:               VkUint32;

  1313.     maxPerStageDescriptorInputAttachments:            VkUint32;

  1314.     maxPerStageResources:                             VkUint32;

  1315.     maxDescriptorSetSamplers:                         VkUint32;

  1316.     maxDescriptorSetUniformBuffers:                   VkUint32;

  1317.     maxDescriptorSetUniformBuffersDynamic:            VkUint32;

  1318.     maxDescriptorSetStorageBuffers:                   VkUint32;

  1319.     maxDescriptorSetStorageBuffersDynamic:            VkUint32;

  1320.     maxDescriptorSetSampledImages:                    VkUint32;

  1321.     maxDescriptorSetStorageImages:                    VkUint32;

  1322.     maxDescriptorSetInputAttachments:                 VkUint32;

  1323.     maxVertexInputAttributes:                         VkUint32;

  1324.     maxVertexInputBindings:                           VkUint32;

  1325.     maxVertexInputAttributeOffset:                    VkUint32;

  1326.     maxVertexInputBindingStride:                      VkUint32;

  1327.     maxVertexOutputComponents:                        VkUint32;

  1328.     maxTessellationGenerationLevel:                   VkUint32;

  1329.     maxTessellationPatchSize:                         VkUint32;

  1330.     maxTessellationControlPerVertexInputComponents:   VkUint32;

  1331.     maxTessellationControlPerVertexOutputComponents:  VkUint32;

  1332.     maxTessellationControlPerPatchOutputComponents:   VkUint32;

  1333.     maxTessellationControlTotalOutputComponents:      VkUint32;

  1334.     maxTessellationEvaluationInputComponents:         VkUint32;

  1335.     maxTessellationEvaluationOutputComponents:        VkUint32;

  1336.     maxGeometryShaderInvocations:                     VkUint32;

  1337.     maxGeometryInputComponents:                       VkUint32;

  1338.     maxGeometryOutputComponents:                      VkUint32;

  1339.     maxGeometryOutputVertices:                        VkUint32;

  1340.     maxGeometryTotalOutputComponents:                 VkUint32;

  1341.     maxFragmentInputComponents:                       VkUint32;

  1342.     maxFragmentOutputAttachments:                     VkUint32;

  1343.     maxFragmentDualSrcAttachments:                    VkUint32;

  1344.     maxFragmentCombinedOutputResources:               VkUint32;

  1345.     maxComputeSharedMemorySize:                       VkUint32;

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

  1347.     maxComputeWorkGroupInvocations:                   VkUint32;

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

  1349.     subPixelPrecisionBits:                            VkUint32;

  1350.     subTexelPrecisionBits:                            VkUint32;

  1351.     mipmapPrecisionBits:                              VkUint32;

  1352.     maxDrawIndexedIndexValue:                         VkUint32;

  1353.     maxDrawIndirectCount:                             VkUint32;

  1354.     maxSamplerLodBias:                                VkFloat;

  1355.     maxSamplerAnisotropy:                             VkFloat;

  1356.     maxViewports:                                     VkUint32;

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

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

  1359.     viewportSubPixelBits:                             VkUint32;

  1360.     minMemoryMapAlignment:                            VkSize;

  1361.     minTexelBufferOffsetAlignment:                    VkDeviceSize;

  1362.     minUniformBufferOffsetAlignment:                  VkDeviceSize;

  1363.     minStorageBufferOffsetAlignment:                  VkDeviceSize;

  1364.     minTexelOffset:                                   VkInt32;

  1365.     maxTexelOffset:                                   VkUint32;

  1366.     minTexelGatherOffset:                             VkInt32;

  1367.     maxTexelGatherOffset:                             VkUint32;

  1368.     minInterpolationOffset:                           VkFloat;

  1369.     maxInterpolationOffset:                           VkFloat;

  1370.     subPixelInterpolationOffsetBits:                  VkUint32;

  1371.     maxFramebufferWidth:                              VkUint32;

  1372.     maxFramebufferHeight:                             VkUint32;

  1373.     maxFramebufferLayers:                             VkUint32;

  1374.     framebufferColorSampleCounts:                     VkSampleCountFlags;

  1375.     framebufferDepthSampleCounts:                     VkSampleCountFlags;

  1376.     framebufferStencilSampleCounts:                   VkSampleCountFlags;

  1377.     framebufferNoAttachmentsSampleCounts:             VkSampleCountFlags;

  1378.     maxColorAttachments:                              VkUint32;

  1379.     sampledImageColorSampleCounts:                    VkSampleCountFlags;

  1380.     sampledImageIntegerSampleCounts:                  VkSampleCountFlags;

  1381.     sampledImageDepthSampleCounts:                    VkSampleCountFlags;

  1382.     sampledImageStencilSampleCounts:                  VkSampleCountFlags;

  1383.     storageImageSampleCounts:                         VkSampleCountFlags;

  1384.     maxSampleMaskWords:                               VkUint32;

  1385.     timestampComputeAndGraphics:                      VkBool32;

  1386.     timestampPeriod:                                  VkFloat;

  1387.     maxClipDistances:                                 VkUint32;

  1388.     maxCullDistances:                                 VkUint32;

  1389.     maxCombinedClipAndCullDistances:                  VkUint32;

  1390.     discreteQueuePriorities:                          VkUint32;

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

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

  1393.     pointSizeGranularity:                             VkFloat;

  1394.     lineWidthGranularity:                             VkFloat;

  1395.     strictLines:                                      VkBool32;

  1396.     standardSampleLocations:                          VkBool32;

  1397.     optimalBufferCopyOffsetAlignment:                 VkDeviceSize;

  1398.     optimalBufferCopyRowPitchAlignment:               VkDeviceSize;

  1399.     nonCoherentAtomSize:                              VkDeviceSize;

  1400.   end;

  1401.   PVkPhysicalDeviceLimits = ^TVkPhysicalDeviceLimits;

  1402.   PPVkPhysicalDeviceLimits = ^PVkPhysicalDeviceLimits;

  1403. 

  1404.   TVkDescriptorBufferInfo = record

  1405.     buffer:                                           VkBuffer;

  1406.     offset:                                           VkDeviceSize;

  1407.     range:                                            VkDeviceSize;

  1408.   end;

  1409.   PVkDescriptorBufferInfo = ^TVkDescriptorBufferInfo;

  1410.   PPVkDescriptorBufferInfo = ^PVkDescriptorBufferInfo;

  1411. 

  1412.   TVkSparseMemoryBind = record

  1413.     resourceOffset:                                   VkDeviceSize;

  1414.     size:                                             VkDeviceSize;

  1415.     memory:                                           VkDeviceMemory;

  1416.     memoryOffset:                                     VkDeviceSize;

  1417.     flags:                                            VkSparseMemoryBindFlags;

  1418.   end;

  1419.   PVkSparseMemoryBind = ^TVkSparseMemoryBind;

  1420.   PPVkSparseMemoryBind = ^PVkSparseMemoryBind;

  1421. 

  1422.   TVkComponentMapping = record

  1423.     r:                                                TVkComponentSwizzle;

  1424.     g:                                                TVkComponentSwizzle;

  1425.     b:                                                TVkComponentSwizzle;

  1426.     a:                                                TVkComponentSwizzle;

  1427.   end;

  1428.   PVkComponentMapping = ^TVkComponentMapping;

  1429.   PPVkComponentMapping = ^PVkComponentMapping;

  1430. 

  1431.   TVkAttachmentReference = record

  1432.     attachment:                                       VkUint32;

  1433.     layout:                                           TVkImageLayout;

  1434.   end;

  1435.   PVkAttachmentReference = ^TVkAttachmentReference;

  1436.   PPVkAttachmentReference = ^PVkAttachmentReference;

  1437. 

  1438.   TVkDescriptorPoolSize = record

  1439.     dType:                                            TVkDescriptorType;

  1440.     descriptorCount:                                  VkUint32;

  1441.   end;

  1442.   PVkDescriptorPoolSize = ^TVkDescriptorPoolSize;

  1443.   PPVkDescriptorPoolSize = ^PVkDescriptorPoolSize;

  1444. 

  1445.   TVkStencilOpState = record

  1446.     failOp:                                           TVkStencilOp;

  1447.     passOp:                                           TVkStencilOp;

  1448.     depthFailOp:                                      TVkStencilOp;

  1449.     compareOp:                                        TVkCompareOp;

  1450.     compareMask:                                      VkUint32;

  1451.     writeMask:                                        VkUint32;

  1452.     reference:                                        VkUint32;

  1453.   end;

  1454.   PVkStencilOpState = ^TVkStencilOpState;

  1455.   PPVkStencilOpState = ^PVkStencilOpState;

  1456. 

  1457.   TVkVertexInputAttributeDescription = record

  1458.     location:                                         VkUint32;

  1459.     binding:                                          VkUint32;

  1460.     format:                                           TVkFormat;

  1461.     offset:                                           VkUint32;

  1462.   end;

  1463.   PVkVertexInputAttributeDescription = ^TVkVertexInputAttributeDescription;

  1464.   PPVkVertexInputAttributeDescription = ^PVkVertexInputAttributeDescription;

  1465. 

  1466.   TVkVertexInputBindingDescription = record

  1467.     binding:                                          VkUint32;

  1468.     stride:                                           VkUint32;

  1469.     inputRate:                                        TVkVertexInputRate;

  1470.   end;

  1471.   PVkVertexInputBindingDescription = ^TVkVertexInputBindingDescription;

  1472.   PPVkVertexInputBindingDescription = ^PVkVertexInputBindingDescription;

  1473. 

  1474.   TVkApplicationInfo = record

  1475.     sType:                                            TVkStructureType;

  1476.     pNext:                                            PVkVoid;

  1477.     pApplicationName:                                 PVkChar;

  1478.     applicationVersion:                               VkUint32;

  1479.     pEngineName:                                      PVkChar;

  1480.     engineVersion:                                    VkUint32;

  1481.     apiVersion:                                       VkUint32;

  1482.   end;

  1483.   PVkApplicationInfo = ^TVkApplicationInfo;

  1484.   PPVkApplicationInfo = ^PVkApplicationInfo;

  1485. 

  1486.   TVkCommandBufferAllocateInfo = record

  1487.     sType:                                            TVkStructureType;

  1488.     pNext:                                            PVkVoid;

  1489.     commandPool:                                      VkCommandPool;

  1490.     level:                                            TVkCommandBufferLevel;

  1491.     commandBufferCount:                               VkUint32;

  1492.   end;

  1493.   PVkCommandBufferAllocateInfo = ^TVkCommandBufferAllocateInfo;

  1494.   PPVkCommandBufferAllocateInfo = ^PVkCommandBufferAllocateInfo;

  1495. 

  1496.   TVkCopyDescriptorSet = record

  1497.     sType:                                            TVkStructureType;

  1498.     pNext:                                            PVkVoid;

  1499.     srcSet:                                           VkDescriptorSet;

  1500.     srcBinding:                                       VkUint32;

  1501.     srcArrayElement:                                  VkUint32;

  1502.     dstSet:                                           VkDescriptorSet;

  1503.     dstBinding:                                       VkUint32;

  1504.     dstArrayElement:                                  VkUint32;

  1505.     descriptorCount:                                  VkUint32;

  1506.   end;

  1507.   PVkCopyDescriptorSet = ^TVkCopyDescriptorSet;

  1508.   PPVkCopyDescriptorSet = ^PVkCopyDescriptorSet;

  1509. 

  1510.   TVkDescriptorSetAllocateInfo = record

  1511.     sType:                                            TVkStructureType;

  1512.     pNext:                                            PVkVoid;

  1513.     descriptorPool:                                   VkDescriptorPool;

  1514.     descriptorSetCount:                               VkUint32;

  1515.     pSetLayouts:                                      PVkDescriptorSetLayout;

  1516.   end;

  1517.   PVkDescriptorSetAllocateInfo = ^TVkDescriptorSetAllocateInfo;

  1518.   PPVkDescriptorSetAllocateInfo = ^PVkDescriptorSetAllocateInfo;

  1519. 

  1520.   TVkDescriptorImageInfo = record

  1521.     sampler:                                          VkSampler;

  1522.     imageView:                                        VkImageView;

  1523.     imageLayout:                                      TVkImageLayout;

  1524.   end;

  1525.   PVkDescriptorImageInfo = ^TVkDescriptorImageInfo;

  1526.   PPVkDescriptorImageInfo = ^PVkDescriptorImageInfo;

  1527. 

  1528.   TVkClearValue = record

  1529.     case Integer of

  1530.       000: (color:                                    TVkClearColorValue);

  1531.       001: (depthStencil:                             TVkClearDepthStencilValue);

  1532.   end;

  1533.   PVkClearValue = ^TVkClearValue;

  1534.   PPVkClearValue = ^PVkClearValue;

  1535. 

  1536.   TVkRect2D = record

  1537.     offset:                                           TVkOffset2D;

  1538.     extent:                                           TVkExtent2D;

  1539.   end;

  1540.   PVkRect2D = ^TVkRect2D;

  1541.   PPVkRect2D = ^PVkRect2D;

  1542. 

  1543.   TVkSpecializationInfo = record

  1544.     mapEntryCount:                                    VkUint32;

  1545.     pMapEntries:                                      PVkSpecializationMapEntry;

  1546.     dataSize:                                         VkSize;

  1547.     pData:                                            PVkVoid;

  1548.   end;

  1549.   PVkSpecializationInfo = ^TVkSpecializationInfo;

  1550.   PPVkSpecializationInfo = ^PVkSpecializationInfo;

  1551. 

  1552.   TVkBufferMemoryBarrier = record

  1553.     sType:                                            TVkStructureType;

  1554.     pNext:                                            PVkVoid;

  1555.     srcAccessMask:                                    VkAccessFlags;

  1556.     dstAccessMask:                                    VkAccessFlags;

  1557.     srcQueueFamilyIndex:                              VkUint32;

  1558.     dstQueueFamilyIndex:                              VkUint32;

  1559.     buffer:                                           VkBuffer;

  1560.     offset:                                           VkDeviceSize;

  1561.     size:                                             VkDeviceSize;

  1562.   end;

  1563.   PVkBufferMemoryBarrier = ^TVkBufferMemoryBarrier;

  1564.   PPVkBufferMemoryBarrier = ^PVkBufferMemoryBarrier;

  1565. 

  1566.   TVkBufferCreateInfo = record

  1567.     sType:                                            TVkStructureType;

  1568.     pNext:                                            PVkVoid;

  1569.     flags:                                            VkBufferCreateFlags;

  1570.     size:                                             VkDeviceSize;

  1571.     usage:                                            VkBufferUsageFlags;

  1572.     sharingMode:                                      TVkSharingMode;

  1573.     queueFamilyIndexCount:                            VkUint32;

  1574.     pQueueFamilyIndices:                              PVkUint32;

  1575.   end;

  1576.   PVkBufferCreateInfo = ^TVkBufferCreateInfo;

  1577.   PPVkBufferCreateInfo = ^PVkBufferCreateInfo;

  1578. 

  1579.   TVkBufferViewCreateInfo = record

  1580.     sType:                                            TVkStructureType;

  1581.     pNext:                                            PVkVoid;

  1582.     flags:                                            VkBufferViewCreateFlags;

  1583.     buffer:                                           VkBuffer;

  1584.     format:                                           TVkFormat;

  1585.     offset:                                           VkDeviceSize;

  1586.     range:                                            VkDeviceSize;

  1587.   end;

  1588.   PVkBufferViewCreateInfo = ^TVkBufferViewCreateInfo;

  1589.   PPVkBufferViewCreateInfo = ^PVkBufferViewCreateInfo;

  1590. 

  1591.   TVkPipelineColorBlendAttachmentState = record

  1592.     blendEnable:                                      VkBool32;

  1593.     srcColorBlendFactor:                              TVkBlendFactor;

  1594.     dstColorBlendFactor:                              TVkBlendFactor;

  1595.     colorBlendOp:                                     TVkBlendOp;

  1596.     srcAlphaBlendFactor:                              TVkBlendFactor;

  1597.     dstAlphaBlendFactor:                              TVkBlendFactor;

  1598.     alphaBlendOp:                                     TVkBlendOp;

  1599.     colorWriteMask:                                   VkColorComponentFlags;

  1600.   end;

  1601.   PVkPipelineColorBlendAttachmentState = ^TVkPipelineColorBlendAttachmentState;

  1602.   PPVkPipelineColorBlendAttachmentState = ^PVkPipelineColorBlendAttachmentState;

  1603. 

  1604.   TVkCommandPoolCreateInfo = record

  1605.     sType:                                            TVkStructureType;

  1606.     pNext:                                            PVkVoid;

  1607.     flags:                                            VkCommandPoolCreateFlags;

  1608.     queueFamilyIndex:                                 VkUint32;

  1609.   end;

  1610.   PVkCommandPoolCreateInfo = ^TVkCommandPoolCreateInfo;

  1611.   PPVkCommandPoolCreateInfo = ^PVkCommandPoolCreateInfo;

  1612. 

  1613.   TVkDeviceQueueCreateInfo = record

  1614.     sType:                                            TVkStructureType;

  1615.     pNext:                                            PVkVoid;

  1616.     flags:                                            VkDeviceQueueCreateFlags;

  1617.     queueFamilyIndex:                                 VkUint32;

  1618.     queueCount:                                       VkUint32;

  1619.     pQueuePriorities:                                 PVkFloat;

  1620.   end;

  1621.   PVkDeviceQueueCreateInfo = ^TVkDeviceQueueCreateInfo;

  1622.   PPVkDeviceQueueCreateInfo = ^PVkDeviceQueueCreateInfo;

  1623. 

  1624.   TVkCommandBufferInheritanceInfo = record

  1625.     sType:                                            TVkStructureType;

  1626.     pNext:                                            PVkVoid;

  1627.     renderPass:                                       VkRenderPass;

  1628.     subpass:                                          VkUint32;

  1629.     framebuffer:                                      VkFramebuffer;

  1630.     occlusionQueryEnable:                             VkBool32;

  1631.     queryFlags:                                       VkQueryControlFlags;

  1632.     pipelineStatistics:                               VkQueryPipelineStatisticFlags;

  1633.   end;

  1634.   PVkCommandBufferInheritanceInfo = ^TVkCommandBufferInheritanceInfo;

  1635.   PPVkCommandBufferInheritanceInfo = ^PVkCommandBufferInheritanceInfo;

  1636. 

  1637.   TVkQueueFamilyProperties = record

  1638.     queueFlags:                                       VkQueueFlags;

  1639.     queueCount:                                       VkUint32;

  1640.     timestampValidBits:                               VkUint32;

  1641.     minImageTransferGranularity:                      TVkExtent3D;

  1642.   end;

  1643.   PVkQueueFamilyProperties = ^TVkQueueFamilyProperties;

  1644.   PPVkQueueFamilyProperties = ^PVkQueueFamilyProperties;

  1645. 

  1646.   TVkImageFormatProperties = record

  1647.     maxExtent:                                        TVkExtent3D;

  1648.     maxMipLevels:                                     VkUint32;

  1649.     maxArrayLayers:                                   VkUint32;

  1650.     sampleCounts:                                     VkSampleCountFlags;

  1651.     maxResourceSize:                                  VkDeviceSize;

  1652.   end;

  1653.   PVkImageFormatProperties = ^TVkImageFormatProperties;

  1654.   PPVkImageFormatProperties = ^PVkImageFormatProperties;

  1655. 

  1656.   TVkDescriptorSetLayoutBinding = record

  1657.     binding:                                          VkUint32;

  1658.     descriptorType:                                   TVkDescriptorType;

  1659.     descriptorCount:                                  VkUint32;

  1660.     stageFlags:                                       VkShaderStageFlags;

  1661.     pImmutableSamplers:                               PVkSampler;

  1662.   end;

  1663.   PVkDescriptorSetLayoutBinding = ^TVkDescriptorSetLayoutBinding;

  1664.   PPVkDescriptorSetLayoutBinding = ^PVkDescriptorSetLayoutBinding;

  1665. 

  1666.   TVkSparseImageFormatProperties = record

  1667.     aspectMask:                                       VkImageAspectFlags;

  1668.     imageGranularity:                                 TVkExtent3D;

  1669.     flags:                                            VkSparseImageFormatFlags;

  1670.   end;

  1671.   PVkSparseImageFormatProperties = ^TVkSparseImageFormatProperties;

  1672.   PPVkSparseImageFormatProperties = ^PVkSparseImageFormatProperties;

  1673. 

  1674.   TVkSparseImageMemoryBind = record

  1675.     subresource:                                      TVkImageSubresource;

  1676.     offset:                                           TVkOffset3D;

  1677.     extent:                                           TVkExtent3D;

  1678.     memory:                                           VkDeviceMemory;

  1679.     memoryOffset:                                     VkDeviceSize;

  1680.     flags:                                            VkSparseMemoryBindFlags;

  1681.   end;

  1682.   PVkSparseImageMemoryBind = ^TVkSparseImageMemoryBind;

  1683.   PPVkSparseImageMemoryBind = ^PVkSparseImageMemoryBind;

  1684. 

  1685.   TVkBufferImageCopy = record

  1686.     bufferOffset:                                     VkDeviceSize;

  1687.     bufferRowLength:                                  VkUint32;

  1688.     bufferImageHeight:                                VkUint32;

  1689.     imageSubresource:                                 TVkImageSubresourceLayers;

  1690.     imageOffset:                                      TVkOffset3D;

  1691.     imageExtent:                                      TVkExtent3D;

  1692.   end;

  1693.   PVkBufferImageCopy = ^TVkBufferImageCopy;

  1694.   PPVkBufferImageCopy = ^PVkBufferImageCopy;

  1695. 

  1696.   TVkImageBlit = record

  1697.     srcSubresource:                                   TVkImageSubresourceLayers;

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

  1699.     dstSubresource:                                   TVkImageSubresourceLayers;

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

  1701.   end;

  1702.   PVkImageBlit = ^TVkImageBlit;

  1703.   PPVkImageBlit = ^PVkImageBlit;

  1704. 

  1705.   TVkImageCopy = record

  1706.     srcSubresource:                                   TVkImageSubresourceLayers;

  1707.     srcOffset:                                        TVkOffset3D;

  1708.     dstSubresource:                                   TVkImageSubresourceLayers;

  1709.     dstOffset:                                        TVkOffset3D;

  1710.     extent:                                           TVkExtent3D;

  1711.   end;

  1712.   PVkImageCopy = ^TVkImageCopy;

  1713.   PPVkImageCopy = ^PVkImageCopy;

  1714. 

  1715.   TVkImageResolve = record

  1716.     srcSubresource:                                   TVkImageSubresourceLayers;

  1717.     srcOffset:                                        TVkOffset3D;

  1718.     dstSubresource:                                   TVkImageSubresourceLayers;

  1719.     dstOffset:                                        TVkOffset3D;

  1720.     extent:                                           TVkExtent3D;

  1721.   end;

  1722.   PVkImageResolve = ^TVkImageResolve;

  1723.   PPVkImageResolve = ^PVkImageResolve;

  1724. 

  1725.   TVkPhysicalDeviceMemoryProperties = record

  1726.     memoryTypeCount:                                  VkUint32;

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

  1728.     memoryHeapCount:                                  VkUint32;

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

  1730.   end;

  1731.   PVkPhysicalDeviceMemoryProperties = ^TVkPhysicalDeviceMemoryProperties;

  1732.   PPVkPhysicalDeviceMemoryProperties = ^PVkPhysicalDeviceMemoryProperties;

  1733. 

  1734.   TVkPhysicalDeviceProperties = record

  1735.     apiVersion:                                       VkUint32;

  1736.     driverVersion:                                    VkUint32;

  1737.     vendorID:                                         VkUint32;

  1738.     deviceID:                                         VkUint32;

  1739.     deviceType:                                       TVkPhysicalDeviceType;

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

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

  1742.     limits:                                           TVkPhysicalDeviceLimits;

  1743.     sparseProperties:                                 TVkPhysicalDeviceSparseProperties;

  1744.   end;

  1745.   PVkPhysicalDeviceProperties = ^TVkPhysicalDeviceProperties;

  1746.   PPVkPhysicalDeviceProperties = ^PVkPhysicalDeviceProperties;

  1747. 

  1748.   TVkSparseBufferMemoryBindInfo = record

  1749.     buffer:                                           VkBuffer;

  1750.     bindCount:                                        VkUint32;

  1751.     pBinds:                                           PVkSparseMemoryBind;

  1752.   end;

  1753.   PVkSparseBufferMemoryBindInfo = ^TVkSparseBufferMemoryBindInfo;

  1754.   PPVkSparseBufferMemoryBindInfo = ^PVkSparseBufferMemoryBindInfo;

  1755. 

  1756.   TVkSparseImageOpaqueMemoryBindInfo = record

  1757.     image:                                            VkImage;

  1758.     bindCount:                                        VkUint32;

  1759.     pBinds:                                           PVkSparseMemoryBind;

  1760.   end;

  1761.   PVkSparseImageOpaqueMemoryBindInfo = ^TVkSparseImageOpaqueMemoryBindInfo;

  1762.   PPVkSparseImageOpaqueMemoryBindInfo = ^PVkSparseImageOpaqueMemoryBindInfo;

  1763. 

  1764.   TVkSubpassDescription = record

  1765.     flags:                                            VkSubpassDescriptionFlags;

  1766.     pipelineBindPoint:                                TVkPipelineBindPoint;

  1767.     inputAttachmentCount:                             VkUint32;

  1768.     pInputAttachments:                                PVkAttachmentReference;

  1769.     colorAttachmentCount:                             VkUint32;

  1770.     pColorAttachments:                                PVkAttachmentReference;

  1771.     pResolveAttachments:                              PVkAttachmentReference;

  1772.     pDepthStencilAttachment:                          PVkAttachmentReference;

  1773.     preserveAttachmentCount:                          VkUint32;

  1774.     pPreserveAttachments:                             PVkUint32;

  1775.   end;

  1776.   PVkSubpassDescription = ^TVkSubpassDescription;

  1777.   PPVkSubpassDescription = ^PVkSubpassDescription;

  1778. 

  1779.   TVkDescriptorPoolCreateInfo = record

  1780.     sType:                                            TVkStructureType;

  1781.     pNext:                                            PVkVoid;

  1782.     flags:                                            VkDescriptorPoolCreateFlags;

  1783.     maxSets:                                          VkUint32;

  1784.     poolSizeCount:                                    VkUint32;

  1785.     pPoolSizes:                                       PVkDescriptorPoolSize;

  1786.   end;

  1787.   PVkDescriptorPoolCreateInfo = ^TVkDescriptorPoolCreateInfo;

  1788.   PPVkDescriptorPoolCreateInfo = ^PVkDescriptorPoolCreateInfo;

  1789. 

  1790.   TVkAllocationCallbacks = record

  1791.     pUserData:                                        PVkVoid;

  1792.     pfnAllocation:                                    TvkAllocationFunction;

  1793.     pfnReallocation:                                  TvkReallocationFunction;

  1794.     pfnFree:                                          TvkFreeFunction;

  1795.     pfnInternalAllocation:                            TvkInternalAllocationNotification;

  1796.     pfnInternalFree:                                  TvkInternalFreeNotification;

  1797.   end;

  1798.   PVkAllocationCallbacks = ^TVkAllocationCallbacks;

  1799.   PPVkAllocationCallbacks = ^PVkAllocationCallbacks;

  1800. 

  1801.   TVkClearAttachment = record

  1802.     aspectMask:                                       VkImageAspectFlags;

  1803.     colorAttachment:                                  VkUint32;

  1804.     clearValue:                                       TVkClearValue;

  1805.   end;

  1806.   PVkClearAttachment = ^TVkClearAttachment;

  1807.   PPVkClearAttachment = ^PVkClearAttachment;

  1808. 

  1809.   TVkClearRect = record

  1810.     rect:                                             TVkRect2D;

  1811.     baseArrayLayer:                                   VkUint32;

  1812.     layerCount:                                       VkUint32;

  1813.   end;

  1814.   PVkClearRect = ^TVkClearRect;

  1815.   PPVkClearRect = ^PVkClearRect;

  1816. 

  1817.   TVkDeviceCreateInfo = record

  1818.     sType:                                            TVkStructureType;

  1819.     pNext:                                            PVkVoid;

  1820.     flags:                                            VkDeviceCreateFlags;

  1821.     queueCreateInfoCount:                             VkUint32;

  1822.     pQueueCreateInfos:                                PVkDeviceQueueCreateInfo;

  1823.     enabledLayerCount:                                VkUint32;

  1824.     ppEnabledLayerNames:                              PPVkChar;

  1825.     enabledExtensionCount:                            VkUint32;

  1826.     ppEnabledExtensionNames:                          PPVkChar;

  1827.     pEnabledFeatures:                                 PVkPhysicalDeviceFeatures;

  1828.   end;

  1829.   PVkDeviceCreateInfo = ^TVkDeviceCreateInfo;

  1830.   PPVkDeviceCreateInfo = ^PVkDeviceCreateInfo;

  1831. 

  1832.   TVkCommandBufferBeginInfo = record

  1833.     sType:                                            TVkStructureType;

  1834.     pNext:                                            PVkVoid;

  1835.     flags:                                            VkCommandBufferUsageFlags;

  1836.     pInheritanceInfo:                                 PVkCommandBufferInheritanceInfo;

  1837.   end;

  1838.   PVkCommandBufferBeginInfo = ^TVkCommandBufferBeginInfo;

  1839.   PPVkCommandBufferBeginInfo = ^PVkCommandBufferBeginInfo;

  1840. 

  1841.   TVkDescriptorSetLayoutCreateInfo = record

  1842.     sType:                                            TVkStructureType;

  1843.     pNext:                                            PVkVoid;

  1844.     flags:                                            VkDescriptorSetLayoutCreateFlags;

  1845.     bindingCount:                                     VkUint32;

  1846.     pBindings:                                        PVkDescriptorSetLayoutBinding;

  1847.   end;

  1848.   PVkDescriptorSetLayoutCreateInfo = ^TVkDescriptorSetLayoutCreateInfo;

  1849.   PPVkDescriptorSetLayoutCreateInfo = ^PVkDescriptorSetLayoutCreateInfo;

  1850. 

  1851.   TVkSparseImageMemoryRequirements = record

  1852.     formatProperties:                                 TVkSparseImageFormatProperties;

  1853.     imageMipTailFirstLod:                             VkUint32;

  1854.     imageMipTailSize:                                 VkDeviceSize;

  1855.     imageMipTailOffset:                               VkDeviceSize;

  1856.     imageMipTailStride:                               VkDeviceSize;

  1857.   end;

  1858.   PVkSparseImageMemoryRequirements = ^TVkSparseImageMemoryRequirements;

  1859.   PPVkSparseImageMemoryRequirements = ^PVkSparseImageMemoryRequirements;

  1860. 

  1861.   TVkSparseImageMemoryBindInfo = record

  1862.     image:                                            VkImage;

  1863.     bindCount:                                        VkUint32;

  1864.     pBinds:                                           PVkSparseImageMemoryBind;

  1865.   end;

  1866.   PVkSparseImageMemoryBindInfo = ^TVkSparseImageMemoryBindInfo;

  1867.   PPVkSparseImageMemoryBindInfo = ^PVkSparseImageMemoryBindInfo;

  1868. 

  1869.   TVkBindSparseInfo = record

  1870.     sType:                                            TVkStructureType;

  1871.     pNext:                                            PVkVoid;

  1872.     waitSemaphoreCount:                               VkUint32;

  1873.     pWaitSemaphores:                                  PVkSemaphore;

  1874.     bufferBindCount:                                  VkUint32;

  1875.     pBufferBinds:                                     PVkSparseBufferMemoryBindInfo;

  1876.     imageOpaqueBindCount:                             VkUint32;

  1877.     pImageOpaqueBinds:                                PVkSparseImageOpaqueMemoryBindInfo;

  1878.     imageBindCount:                                   VkUint32;

  1879.     pImageBinds:                                      PVkSparseImageMemoryBindInfo;

  1880.     signalSemaphoreCount:                             VkUint32;

  1881.     pSignalSemaphores:                                PVkSemaphore;

  1882.   end;

  1883.   PVkBindSparseInfo = ^TVkBindSparseInfo;

  1884.   PPVkBindSparseInfo = ^PVkBindSparseInfo;

  1885. 

  1886.   TVkMappedMemoryRange = record

  1887.     sType:                                            TVkStructureType;

  1888.     pNext:                                            PVkVoid;

  1889.     memory:                                           VkDeviceMemory;

  1890.     offset:                                           VkDeviceSize;

  1891.     size:                                             VkDeviceSize;

  1892.   end;

  1893.   PVkMappedMemoryRange = ^TVkMappedMemoryRange;

  1894.   PPVkMappedMemoryRange = ^PVkMappedMemoryRange;

  1895. 

  1896.   TVkMemoryAllocateInfo = record

  1897.     sType:                                            TVkStructureType;

  1898.     pNext:                                            PVkVoid;

  1899.     allocationSize:                                   VkDeviceSize;

  1900.     memoryTypeIndex:                                  VkUint32;

  1901.   end;

  1902.   PVkMemoryAllocateInfo = ^TVkMemoryAllocateInfo;

  1903.   PPVkMemoryAllocateInfo = ^PVkMemoryAllocateInfo;

  1904. 

  1905.   TVkMemoryBarrier = record

  1906.     sType:                                            TVkStructureType;

  1907.     pNext:                                            PVkVoid;

  1908.     srcAccessMask:                                    VkAccessFlags;

  1909.     dstAccessMask:                                    VkAccessFlags;

  1910.   end;

  1911.   PVkMemoryBarrier = ^TVkMemoryBarrier;

  1912.   PPVkMemoryBarrier = ^PVkMemoryBarrier;

  1913. 

  1914.   TVkAttachmentDescription = record

  1915.     flags:                                            VkAttachmentDescriptionFlags;

  1916.     format:                                           TVkFormat;

  1917.     samples:                                          TVkSampleCountFlagBits;

  1918.     loadOp:                                           TVkAttachmentLoadOp;

  1919.     storeOp:                                          TVkAttachmentStoreOp;

  1920.     stencilLoadOp:                                    TVkAttachmentLoadOp;

  1921.     stencilStoreOp:                                   TVkAttachmentStoreOp;

  1922.     initialLayout:                                    TVkImageLayout;

  1923.     finalLayout:                                      TVkImageLayout;

  1924.   end;

  1925.   PVkAttachmentDescription = ^TVkAttachmentDescription;

  1926.   PPVkAttachmentDescription = ^PVkAttachmentDescription;

  1927. 

  1928.   TVkEventCreateInfo = record

  1929.     sType:                                            TVkStructureType;

  1930.     pNext:                                            PVkVoid;

  1931.     flags:                                            VkEventCreateFlags;

  1932.   end;

  1933.   PVkEventCreateInfo = ^TVkEventCreateInfo;

  1934.   PPVkEventCreateInfo = ^PVkEventCreateInfo;

  1935. 

  1936.   TVkFenceCreateInfo = record

  1937.     sType:                                            TVkStructureType;

  1938.     pNext:                                            PVkVoid;

  1939.     flags:                                            VkFenceCreateFlags;

  1940.   end;

  1941.   PVkFenceCreateInfo = ^TVkFenceCreateInfo;

  1942.   PPVkFenceCreateInfo = ^PVkFenceCreateInfo;

  1943. 

  1944.   TVkFramebufferCreateInfo = record

  1945.     sType:                                            TVkStructureType;

  1946.     pNext:                                            PVkVoid;

  1947.     flags:                                            VkFramebufferCreateFlags;

  1948.     renderPass:                                       VkRenderPass;

  1949.     attachmentCount:                                  VkUint32;

  1950.     pAttachments:                                     PVkImageView;

  1951.     width:                                            VkUint32;

  1952.     height:                                           VkUint32;

  1953.     layers:                                           VkUint32;

  1954.   end;

  1955.   PVkFramebufferCreateInfo = ^TVkFramebufferCreateInfo;

  1956.   PPVkFramebufferCreateInfo = ^PVkFramebufferCreateInfo;

  1957. 

  1958.   TVkImageCreateInfo = record

  1959.     sType:                                            TVkStructureType;

  1960.     pNext:                                            PVkVoid;

  1961.     flags:                                            VkImageCreateFlags;

  1962.     imageType:                                        TVkImageType;

  1963.     format:                                           TVkFormat;

  1964.     extent:                                           TVkExtent3D;

  1965.     mipLevels:                                        VkUint32;

  1966.     arrayLayers:                                      VkUint32;

  1967.     samples:                                          TVkSampleCountFlagBits;

  1968.     tiling:                                           TVkImageTiling;

  1969.     usage:                                            VkImageUsageFlags;

  1970.     sharingMode:                                      TVkSharingMode;

  1971.     queueFamilyIndexCount:                            VkUint32;

  1972.     pQueueFamilyIndices:                              PVkUint32;

  1973.     initialLayout:                                    TVkImageLayout;

  1974.   end;

  1975.   PVkImageCreateInfo = ^TVkImageCreateInfo;

  1976.   PPVkImageCreateInfo = ^PVkImageCreateInfo;

  1977. 

  1978.   TVkPipelineCacheCreateInfo = record

  1979.     sType:                                            TVkStructureType;

  1980.     pNext:                                            PVkVoid;

  1981.     flags:                                            VkPipelineCacheCreateFlags;

  1982.     initialDataSize:                                  VkSize;

  1983.     pInitialData:                                     PVkVoid;

  1984.   end;

  1985.   PVkPipelineCacheCreateInfo = ^TVkPipelineCacheCreateInfo;

  1986.   PPVkPipelineCacheCreateInfo = ^PVkPipelineCacheCreateInfo;

  1987. 

  1988.   TVkPipelineDynamicStateCreateInfo = record

  1989.     sType:                                            TVkStructureType;

  1990.     pNext:                                            PVkVoid;

  1991.     flags:                                            VkPipelineDynamicStateCreateFlags;

  1992.     dynamicStateCount:                                VkUint32;

  1993.     pDynamicStates:                                   PVkDynamicState;

  1994.   end;

  1995.   PVkPipelineDynamicStateCreateInfo = ^TVkPipelineDynamicStateCreateInfo;

  1996.   PPVkPipelineDynamicStateCreateInfo = ^PVkPipelineDynamicStateCreateInfo;

  1997. 

  1998.   TVkPipelineInputAssemblyStateCreateInfo = record

  1999.     sType:                                            TVkStructureType;

  2000.     pNext:                                            PVkVoid;

  2001.     flags:                                            VkPipelineInputAssemblyStateCreateFlags;

  2002.     topology:                                         TVkPrimitiveTopology;

  2003.     primitiveRestartEnable:                           VkBool32;

  2004.   end;

  2005.   PVkPipelineInputAssemblyStateCreateInfo = ^TVkPipelineInputAssemblyStateCreateInfo;

  2006.   PPVkPipelineInputAssemblyStateCreateInfo = ^PVkPipelineInputAssemblyStateCreateInfo;

  2007. 

  2008.   TVkPipelineMultisampleStateCreateInfo = record

  2009.     sType:                                            TVkStructureType;

  2010.     pNext:                                            PVkVoid;

  2011.     flags:                                            VkPipelineMultisampleStateCreateFlags;

  2012.     rasterizationSamples:                             TVkSampleCountFlagBits;

  2013.     sampleShadingEnable:                              VkBool32;

  2014.     minSampleShading:                                 VkFloat;

  2015.     pSampleMask:                                      PVkSampleMask;

  2016.     alphaToCoverageEnable:                            VkBool32;

  2017.     alphaToOneEnable:                                 VkBool32;

  2018.   end;

  2019.   PVkPipelineMultisampleStateCreateInfo = ^TVkPipelineMultisampleStateCreateInfo;

  2020.   PPVkPipelineMultisampleStateCreateInfo = ^PVkPipelineMultisampleStateCreateInfo;

  2021. 

  2022.   TVkPipelineRasterizationStateCreateInfo = record

  2023.     sType:                                            TVkStructureType;

  2024.     pNext:                                            PVkVoid;

  2025.     flags:                                            VkPipelineRasterizationStateCreateFlags;

  2026.     depthClampEnable:                                 VkBool32;

  2027.     rasterizerDiscardEnable:                          VkBool32;

  2028.     polygonMode:                                      TVkPolygonMode;

  2029.     cullMode:                                         VkCullModeFlags;

  2030.     frontFace:                                        TVkFrontFace;

  2031.     depthBiasEnable:                                  VkBool32;

  2032.     depthBiasConstantFactor:                          VkFloat;

  2033.     depthBiasClamp:                                   VkFloat;

  2034.     depthBiasSlopeFactor:                             VkFloat;

  2035.     lineWidth:                                        VkFloat;

  2036.   end;

  2037.   PVkPipelineRasterizationStateCreateInfo = ^TVkPipelineRasterizationStateCreateInfo;

  2038.   PPVkPipelineRasterizationStateCreateInfo = ^PVkPipelineRasterizationStateCreateInfo;

  2039. 

  2040.   TVkSubmitInfo = record

  2041.     sType:                                            TVkStructureType;

  2042.     pNext:                                            PVkVoid;

  2043.     waitSemaphoreCount:                               VkUint32;

  2044.     pWaitSemaphores:                                  PVkSemaphore;

  2045.     pWaitDstStageMask:                                PVkPipelineStageFlags;

  2046.     commandBufferCount:                               VkUint32;

  2047.     pCommandBuffers:                                  PVkCommandBuffer;

  2048.     signalSemaphoreCount:                             VkUint32;

  2049.     pSignalSemaphores:                                PVkSemaphore;

  2050.   end;

  2051.   PVkSubmitInfo = ^TVkSubmitInfo;

  2052.   PPVkSubmitInfo = ^PVkSubmitInfo;

  2053. 

  2054.   TVkPipelineTessellationStateCreateInfo = record

  2055.     sType:                                            TVkStructureType;

  2056.     pNext:                                            PVkVoid;

  2057.     flags:                                            VkPipelineTessellationStateCreateFlags;

  2058.     patchControlPoints:                               VkUint32;

  2059.   end;

  2060.   PVkPipelineTessellationStateCreateInfo = ^TVkPipelineTessellationStateCreateInfo;

  2061.   PPVkPipelineTessellationStateCreateInfo = ^PVkPipelineTessellationStateCreateInfo;

  2062. 

  2063.   TVkQueryPoolCreateInfo = record

  2064.     sType:                                            TVkStructureType;

  2065.     pNext:                                            PVkVoid;

  2066.     flags:                                            VkQueryPoolCreateFlags;

  2067.     queryType:                                        TVkQueryType;

  2068.     queryCount:                                       VkUint32;

  2069.     pipelineStatistics:                               VkQueryPipelineStatisticFlags;

  2070.   end;

  2071.   PVkQueryPoolCreateInfo = ^TVkQueryPoolCreateInfo;

  2072.   PPVkQueryPoolCreateInfo = ^PVkQueryPoolCreateInfo;

  2073. 

  2074.   TVkSamplerCreateInfo = record

  2075.     sType:                                            TVkStructureType;

  2076.     pNext:                                            PVkVoid;

  2077.     flags:                                            VkSamplerCreateFlags;

  2078.     magFilter:                                        TVkFilter;

  2079.     minFilter:                                        TVkFilter;

  2080.     mipmapMode:                                       TVkSamplerMipmapMode;

  2081.     addressModeU:                                     TVkSamplerAddressMode;

  2082.     addressModeV:                                     TVkSamplerAddressMode;

  2083.     addressModeW:                                     TVkSamplerAddressMode;

  2084.     mipLodBias:                                       VkFloat;

  2085.     anisotropyEnable:                                 VkBool32;

  2086.     maxAnisotropy:                                    VkFloat;

  2087.     compareEnable:                                    VkBool32;

  2088.     compareOp:                                        TVkCompareOp;

  2089.     minLod:                                           VkFloat;

  2090.     maxLod:                                           VkFloat;

  2091.     borderColor:                                      TVkBorderColor;

  2092.     unnormalizedCoordinates:                          VkBool32;

  2093.   end;

  2094.   PVkSamplerCreateInfo = ^TVkSamplerCreateInfo;

  2095.   PPVkSamplerCreateInfo = ^PVkSamplerCreateInfo;

  2096. 

  2097.   TVkSemaphoreCreateInfo = record

  2098.     sType:                                            TVkStructureType;

  2099.     pNext:                                            PVkVoid;

  2100.     flags:                                            VkSemaphoreCreateFlags;

  2101.   end;

  2102.   PVkSemaphoreCreateInfo = ^TVkSemaphoreCreateInfo;

  2103.   PPVkSemaphoreCreateInfo = ^PVkSemaphoreCreateInfo;

  2104. 

  2105.   TVkShaderModuleCreateInfo = record

  2106.     sType:                                            TVkStructureType;

  2107.     pNext:                                            PVkVoid;

  2108.     flags:                                            VkShaderModuleCreateFlags;

  2109.     codeSize:                                         VkSize;

  2110.     pCode:                                            PVkUint32;

  2111.   end;

  2112.   PVkShaderModuleCreateInfo = ^TVkShaderModuleCreateInfo;

  2113.   PPVkShaderModuleCreateInfo = ^PVkShaderModuleCreateInfo;

  2114. 

  2115.   TVkImageMemoryBarrier = record

  2116.     sType:                                            TVkStructureType;

  2117.     pNext:                                            PVkVoid;

  2118.     srcAccessMask:                                    VkAccessFlags;

  2119.     dstAccessMask:                                    VkAccessFlags;

  2120.     oldLayout:                                        TVkImageLayout;

  2121.     newLayout:                                        TVkImageLayout;

  2122.     srcQueueFamilyIndex:                              VkUint32;

  2123.     dstQueueFamilyIndex:                              VkUint32;

  2124.     image:                                            VkImage;

  2125.     subresourceRange:                                 TVkImageSubresourceRange;

  2126.   end;

  2127.   PVkImageMemoryBarrier = ^TVkImageMemoryBarrier;

  2128.   PPVkImageMemoryBarrier = ^PVkImageMemoryBarrier;

  2129. 

  2130.   TVkPipelineLayoutCreateInfo = record

  2131.     sType:                                            TVkStructureType;

  2132.     pNext:                                            PVkVoid;

  2133.     flags:                                            VkPipelineLayoutCreateFlags;

  2134.     setLayoutCount:                                   VkUint32;

  2135.     pSetLayouts:                                      PVkDescriptorSetLayout;

  2136.     pushConstantRangeCount:                           VkUint32;

  2137.     pPushConstantRanges:                              PVkPushConstantRange;

  2138.   end;

  2139.   PVkPipelineLayoutCreateInfo = ^TVkPipelineLayoutCreateInfo;

  2140.   PPVkPipelineLayoutCreateInfo = ^PVkPipelineLayoutCreateInfo;

  2141. 

  2142.   TVkImageViewCreateInfo = record

  2143.     sType:                                            TVkStructureType;

  2144.     pNext:                                            PVkVoid;

  2145.     flags:                                            VkImageViewCreateFlags;

  2146.     image:                                            VkImage;

  2147.     viewType:                                         TVkImageViewType;

  2148.     format:                                           TVkFormat;

  2149.     components:                                       TVkComponentMapping;

  2150.     subresourceRange:                                 TVkImageSubresourceRange;

  2151.   end;

  2152.   PVkImageViewCreateInfo = ^TVkImageViewCreateInfo;

  2153.   PPVkImageViewCreateInfo = ^PVkImageViewCreateInfo;

  2154. 

  2155.   TVkPipelineDepthStencilStateCreateInfo = record

  2156.     sType:                                            TVkStructureType;

  2157.     pNext:                                            PVkVoid;

  2158.     flags:                                            VkPipelineDepthStencilStateCreateFlags;

  2159.     depthTestEnable:                                  VkBool32;

  2160.     depthWriteEnable:                                 VkBool32;

  2161.     depthCompareOp:                                   TVkCompareOp;

  2162.     depthBoundsTestEnable:                            VkBool32;

  2163.     stencilTestEnable:                                VkBool32;

  2164.     front:                                            TVkStencilOpState;

  2165.     back:                                             TVkStencilOpState;

  2166.     minDepthBounds:                                   VkFloat;

  2167.     maxDepthBounds:                                   VkFloat;

  2168.   end;

  2169.   PVkPipelineDepthStencilStateCreateInfo = ^TVkPipelineDepthStencilStateCreateInfo;

  2170.   PPVkPipelineDepthStencilStateCreateInfo = ^PVkPipelineDepthStencilStateCreateInfo;

  2171. 

  2172.   TVkPipelineVertexInputStateCreateInfo = record

  2173.     sType:                                            TVkStructureType;

  2174.     pNext:                                            PVkVoid;

  2175.     flags:                                            VkPipelineVertexInputStateCreateFlags;

  2176.     vertexBindingDescriptionCount:                    VkUint32;

  2177.     pVertexBindingDescriptions:                       PVkVertexInputBindingDescription;

  2178.     vertexAttributeDescriptionCount:                  VkUint32;

  2179.     pVertexAttributeDescriptions:                     PVkVertexInputAttributeDescription;

  2180.   end;

  2181.   PVkPipelineVertexInputStateCreateInfo = ^TVkPipelineVertexInputStateCreateInfo;

  2182.   PPVkPipelineVertexInputStateCreateInfo = ^PVkPipelineVertexInputStateCreateInfo;

  2183. 

  2184.   TVkInstanceCreateInfo = record

  2185.     sType:                                            TVkStructureType;

  2186.     pNext:                                            PVkVoid;

  2187.     flags:                                            VkInstanceCreateFlags;

  2188.     pApplicationInfo:                                 PVkApplicationInfo;

  2189.     enabledLayerCount:                                VkUint32;

  2190.     ppEnabledLayerNames:                              PPVkChar;

  2191.     enabledExtensionCount:                            VkUint32;

  2192.     ppEnabledExtensionNames:                          PPVkChar;

  2193.   end;

  2194.   PVkInstanceCreateInfo = ^TVkInstanceCreateInfo;

  2195.   PPVkInstanceCreateInfo = ^PVkInstanceCreateInfo;

  2196. 

  2197.   TVkWriteDescriptorSet = record

  2198.     sType:                                            TVkStructureType;

  2199.     pNext:                                            PVkVoid;

  2200.     dstSet:                                           VkDescriptorSet;

  2201.     dstBinding:                                       VkUint32;

  2202.     dstArrayElement:                                  VkUint32;

  2203.     descriptorCount:                                  VkUint32;

  2204.     descriptorType:                                   TVkDescriptorType;

  2205.     pImageInfo:                                       PVkDescriptorImageInfo;

  2206.     pBufferInfo:                                      PVkDescriptorBufferInfo;

  2207.     pTexelBufferView:                                 PVkBufferView;

  2208.   end;

  2209.   PVkWriteDescriptorSet = ^TVkWriteDescriptorSet;

  2210.   PPVkWriteDescriptorSet = ^PVkWriteDescriptorSet;

  2211. 

  2212.   TVkPipelineViewportStateCreateInfo = record

  2213.     sType:                                            TVkStructureType;

  2214.     pNext:                                            PVkVoid;

  2215.     flags:                                            VkPipelineViewportStateCreateFlags;

  2216.     viewportCount:                                    VkUint32;

  2217.     pViewports:                                       PVkViewport;

  2218.     scissorCount:                                     VkUint32;

  2219.     pScissors:                                        PVkRect2D;

  2220.   end;

  2221.   PVkPipelineViewportStateCreateInfo = ^TVkPipelineViewportStateCreateInfo;

  2222.   PPVkPipelineViewportStateCreateInfo = ^PVkPipelineViewportStateCreateInfo;

  2223. 

  2224.   TVkRenderPassBeginInfo = record

  2225.     sType:                                            TVkStructureType;

  2226.     pNext:                                            PVkVoid;

  2227.     renderPass:                                       VkRenderPass;

  2228.     framebuffer:                                      VkFramebuffer;

  2229.     renderArea:                                       TVkRect2D;

  2230.     clearValueCount:                                  VkUint32;

  2231.     pClearValues:                                     PVkClearValue;

  2232.   end;

  2233.   PVkRenderPassBeginInfo = ^TVkRenderPassBeginInfo;

  2234.   PPVkRenderPassBeginInfo = ^PVkRenderPassBeginInfo;

  2235. 

  2236.   TVkPipelineShaderStageCreateInfo = record

  2237.     sType:                                            TVkStructureType;

  2238.     pNext:                                            PVkVoid;

  2239.     flags:                                            VkPipelineShaderStageCreateFlags;

  2240.     stage:                                            TVkShaderStageFlagBits;

  2241.     module:                                           VkShaderModule;

  2242.     pName:                                            PVkChar;

  2243.     pSpecializationInfo:                              PVkSpecializationInfo;

  2244.   end;

  2245.   PVkPipelineShaderStageCreateInfo = ^TVkPipelineShaderStageCreateInfo;

  2246.   PPVkPipelineShaderStageCreateInfo = ^PVkPipelineShaderStageCreateInfo;

  2247. 

  2248.   TVkPipelineColorBlendStateCreateInfo = record

  2249.     sType:                                            TVkStructureType;

  2250.     pNext:                                            PVkVoid;

  2251.     flags:                                            VkPipelineColorBlendStateCreateFlags;

  2252.     logicOpEnable:                                    VkBool32;

  2253.     logicOp:                                          TVkLogicOp;

  2254.     attachmentCount:                                  VkUint32;

  2255.     pAttachments:                                     PVkPipelineColorBlendAttachmentState;

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

  2257.   end;

  2258.   PVkPipelineColorBlendStateCreateInfo = ^TVkPipelineColorBlendStateCreateInfo;

  2259.   PPVkPipelineColorBlendStateCreateInfo = ^PVkPipelineColorBlendStateCreateInfo;

  2260. 

  2261.   TVkRenderPassCreateInfo = record

  2262.     sType:                                            TVkStructureType;

  2263.     pNext:                                            PVkVoid;

  2264.     flags:                                            VkRenderPassCreateFlags;

  2265.     attachmentCount:                                  VkUint32;

  2266.     pAttachments:                                     PVkAttachmentDescription;

  2267.     subpassCount:                                     VkUint32;

  2268.     pSubpasses:                                       PVkSubpassDescription;

  2269.     dependencyCount:                                  VkUint32;

  2270.     pDependencies:                                    PVkSubpassDependency;

  2271.   end;

  2272.   PVkRenderPassCreateInfo = ^TVkRenderPassCreateInfo;

  2273.   PPVkRenderPassCreateInfo = ^PVkRenderPassCreateInfo;

  2274. 

  2275.   TVkComputePipelineCreateInfo = record

  2276.     sType:                                            TVkStructureType;

  2277.     pNext:                                            PVkVoid;

  2278.     flags:                                            VkPipelineCreateFlags;

  2279.     stage:                                            TVkPipelineShaderStageCreateInfo;

  2280.     layout:                                           VkPipelineLayout;

  2281.     basePipelineHandle:                               VkPipeline;

  2282.     basePipelineIndex:                                VkInt32;

  2283.   end;

  2284.   PVkComputePipelineCreateInfo = ^TVkComputePipelineCreateInfo;

  2285.   PPVkComputePipelineCreateInfo = ^PVkComputePipelineCreateInfo;

  2286. 

  2287.   TVkGraphicsPipelineCreateInfo = record

  2288.     sType:                                            TVkStructureType;

  2289.     pNext:                                            PVkVoid;

  2290.     flags:                                            VkPipelineCreateFlags;

  2291.     stageCount:                                       VkUint32;

  2292.     pStages:                                          PVkPipelineShaderStageCreateInfo;

  2293.     pVertexInputState:                                PVkPipelineVertexInputStateCreateInfo;

  2294.     pInputAssemblyState:                              PVkPipelineInputAssemblyStateCreateInfo;

  2295.     pTessellationState:                               PVkPipelineTessellationStateCreateInfo;

  2296.     pViewportState:                                   PVkPipelineViewportStateCreateInfo;

  2297.     pRasterizationState:                              PVkPipelineRasterizationStateCreateInfo;

  2298.     pMultisampleState:                                PVkPipelineMultisampleStateCreateInfo;

  2299.     pDepthStencilState:                               PVkPipelineDepthStencilStateCreateInfo;

  2300.     pColorBlendState:                                 PVkPipelineColorBlendStateCreateInfo;

  2301.     pDynamicState:                                    PVkPipelineDynamicStateCreateInfo;

  2302.     layout:                                           VkPipelineLayout;

  2303.     renderPass:                                       VkRenderPass;

  2304.     subpass:                                          VkUint32;

  2305.     basePipelineHandle:                               VkPipeline;

  2306.     basePipelineIndex:                                VkInt32;

  2307.   end;

  2308.   PVkGraphicsPipelineCreateInfo = ^TVkGraphicsPipelineCreateInfo;

  2309.   PPVkGraphicsPipelineCreateInfo = ^PVkGraphicsPipelineCreateInfo;

  2310. 

  2311. type { commands }

  2312.   TvkCmdDispatch                                     = procedure(commandBuffer: VkCommandBuffer; x: VkUint32; y: VkUint32; z: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2313.   TvkCmdDraw                                         = procedure(commandBuffer: VkCommandBuffer; vertexCount: VkUint32; instanceCount: VkUint32; firstVertex: VkUint32; firstInstance: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2314.   TvkCmdDrawIndexed                                  = procedure(commandBuffer: VkCommandBuffer; indexCount: VkUint32; instanceCount: VkUint32; firstIndex: VkUint32; vertexOffset: VkInt32; firstInstance: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2315.   TvkCmdEndRenderPass                                = procedure(commandBuffer: VkCommandBuffer); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2316.   TvkCmdExecuteCommands                              = procedure(commandBuffer: VkCommandBuffer; commandBufferCount: VkUint32; const pCommandBuffers: PVkCommandBuffer); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2317.   TvkCmdSetBlendConstants                            = procedure(commandBuffer: VkCommandBuffer; const blendConstants: VkFloat); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2318.   TvkCmdSetDepthBias                                 = procedure(commandBuffer: VkCommandBuffer; depthBiasConstantFactor: VkFloat; depthBiasClamp: VkFloat; depthBiasSlopeFactor: VkFloat); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2319.   TvkCmdSetDepthBounds                               = procedure(commandBuffer: VkCommandBuffer; minDepthBounds: VkFloat; maxDepthBounds: VkFloat); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2320.   TvkDeviceWaitIdle                                  = function (device: VkDevice): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2321.   TvkGetDeviceProcAddr                               = function (device: VkDevice; const pName: PVkChar): TvkVoidFunction; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2322.   TvkGetInstanceProcAddr                             = function (instance: VkInstance; const pName: PVkChar): TvkVoidFunction; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2323.   TvkEnumeratePhysicalDevices                        = function (instance: VkInstance; pPhysicalDeviceCount: PVkUint32; pPhysicalDevices: PVkPhysicalDevice): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2324.   TvkGetDeviceQueue                                  = procedure(device: VkDevice; queueFamilyIndex: VkUint32; queueIndex: VkUint32; pQueue: PVkQueue); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2325.   TvkQueueWaitIdle                                   = function (queue: VkQueue): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2326.   TvkCmdSetLineWidth                                 = procedure(commandBuffer: VkCommandBuffer; lineWidth: VkFloat); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2327.   TvkEndCommandBuffer                                = function (commandBuffer: VkCommandBuffer): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2328.   TvkFreeCommandBuffers                              = procedure(device: VkDevice; commandPool: VkCommandPool; commandBufferCount: VkUint32; const pCommandBuffers: PVkCommandBuffer); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2329.   TvkFreeDescriptorSets                              = function (device: VkDevice; descriptorPool: VkDescriptorPool; descriptorSetCount: VkUint32; const pDescriptorSets: PVkDescriptorSet): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2330.   TvkUnmapMemory                                     = procedure(device: VkDevice; memory: VkDeviceMemory); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2331.   TvkGetEventStatus                                  = function (device: VkDevice; event: VkEvent): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2332.   TvkResetEvent                                      = function (device: VkDevice; event: VkEvent): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2333.   TvkSetEvent                                        = function (device: VkDevice; event: VkEvent): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2334.   TvkGetFenceStatus                                  = function (device: VkDevice; fence: VkFence): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2335.   TvkResetFences                                     = function (device: VkDevice; fenceCount: VkUint32; const pFences: PVkFence): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2336.   TvkGetPipelineCacheData                            = function (device: VkDevice; pipelineCache: VkPipelineCache; pDataSize: PVkSize; pData: PVkVoid): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2337.   TvkMergePipelineCaches                             = function (device: VkDevice; dstCache: VkPipelineCache; srcCacheCount: VkUint32; const pSrcCaches: PVkPipelineCache): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2338.   TvkCmdEndQuery                                     = procedure(commandBuffer: VkCommandBuffer; queryPool: VkQueryPool; query: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2339.   TvkCmdResetQueryPool                               = procedure(commandBuffer: VkCommandBuffer; queryPool: VkQueryPool; firstQuery: VkUint32; queryCount: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2340.   TvkWaitForFences                                   = function (device: VkDevice; fenceCount: VkUint32; const pFences: PVkFence; waitAll: VkBool32; timeout: VkUint64): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2341.   TvkBindBufferMemory                                = function (device: VkDevice; buffer: VkBuffer; memory: VkDeviceMemory; memoryOffset: VkDeviceSize): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2342.   TvkBindImageMemory                                 = function (device: VkDevice; image: VkImage; memory: VkDeviceMemory; memoryOffset: VkDeviceSize): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2343.   TvkCmdBindVertexBuffers                            = procedure(commandBuffer: VkCommandBuffer; firstBinding: VkUint32; bindingCount: VkUint32; const pBuffers: PVkBuffer; const pOffsets: PVkDeviceSize); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2344.   TvkCmdDispatchIndirect                             = procedure(commandBuffer: VkCommandBuffer; buffer: VkBuffer; offset: VkDeviceSize); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2345.   TvkCmdDrawIndexedIndirect                          = procedure(commandBuffer: VkCommandBuffer; buffer: VkBuffer; offset: VkDeviceSize; drawCount: VkUint32; stride: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2346.   TvkCmdDrawIndirect                                 = procedure(commandBuffer: VkCommandBuffer; buffer: VkBuffer; offset: VkDeviceSize; drawCount: VkUint32; stride: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2347.   TvkCmdFillBuffer                                   = procedure(commandBuffer: VkCommandBuffer; dstBuffer: VkBuffer; dstOffset: VkDeviceSize; size: VkDeviceSize; data: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2348.   TvkCmdUpdateBuffer                                 = procedure(commandBuffer: VkCommandBuffer; dstBuffer: VkBuffer; dstOffset: VkDeviceSize; dataSize: VkDeviceSize; const pData: PVkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2349.   TvkGetDeviceMemoryCommitment                       = procedure(device: VkDevice; memory: VkDeviceMemory; pCommittedMemoryInBytes: PVkDeviceSize); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2350.   TvkResetCommandBuffer                              = function (commandBuffer: VkCommandBuffer; flags: VkCommandBufferResetFlags): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2351.   TvkResetCommandPool                                = function (device: VkDevice; commandPool: VkCommandPool; flags: VkCommandPoolResetFlags): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2352.   TvkResetDescriptorPool                             = function (device: VkDevice; descriptorPool: VkDescriptorPool; flags: VkDescriptorPoolResetFlags): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2353.   TvkMapMemory                                       = function (device: VkDevice; memory: VkDeviceMemory; offset: VkDeviceSize; size: VkDeviceSize; flags: VkMemoryMapFlags; ppData: PPVkVoid): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2354.   TvkCmdResetEvent                                   = procedure(commandBuffer: VkCommandBuffer; event: VkEvent; stageMask: VkPipelineStageFlags); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2355.   TvkCmdSetEvent                                     = procedure(commandBuffer: VkCommandBuffer; event: VkEvent; stageMask: VkPipelineStageFlags); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2356.   TvkCmdBeginQuery                                   = procedure(commandBuffer: VkCommandBuffer; queryPool: VkQueryPool; query: VkUint32; flags: VkQueryControlFlags); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2357.   TvkCmdCopyQueryPoolResults                         = procedure(commandBuffer: VkCommandBuffer; queryPool: VkQueryPool; firstQuery: VkUint32; queryCount: VkUint32; dstBuffer: VkBuffer; dstOffset: VkDeviceSize; stride: VkDeviceSize; flags: VkQueryResultFlags); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2358.   TvkGetQueryPoolResults                             = function (device: VkDevice; queryPool: VkQueryPool; firstQuery: VkUint32; queryCount: VkUint32; dataSize: VkSize; pData: PVkVoid; stride: VkDeviceSize; flags: VkQueryResultFlags): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2359.   TvkCmdPushConstants                                = procedure(commandBuffer: VkCommandBuffer; layout: VkPipelineLayout; stageFlags: VkShaderStageFlags; offset: VkUint32; size: VkUint32; const pValues: PVkVoid); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2360.   TvkCmdSetStencilCompareMask                        = procedure(commandBuffer: VkCommandBuffer; faceMask: VkStencilFaceFlags; compareMask: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2361.   TvkCmdSetStencilReference                          = procedure(commandBuffer: VkCommandBuffer; faceMask: VkStencilFaceFlags; reference: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2362.   TvkCmdSetStencilWriteMask                          = procedure(commandBuffer: VkCommandBuffer; faceMask: VkStencilFaceFlags; writeMask: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2363.   TvkCmdBindPipeline                                 = procedure(commandBuffer: VkCommandBuffer; pipelineBindPoint: TVkPipelineBindPoint; pipeline: VkPipeline); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2364.   TvkCmdBindDescriptorSets                           = procedure(commandBuffer: VkCommandBuffer; pipelineBindPoint: TVkPipelineBindPoint; layout: VkPipelineLayout; firstSet: VkUint32; descriptorSetCount: VkUint32; const pDescriptorSets: PVkDescriptorSet; dynamicOffsetCount: VkUint32; const pDynamicOffsets: PVkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2365.   TvkCmdSetViewport                                  = procedure(commandBuffer: VkCommandBuffer; firstViewport: VkUint32; viewportCount: VkUint32; const pViewports: PVkViewport); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2366.   TvkEnumerateDeviceExtensionProperties              = function (physicalDevice: VkPhysicalDevice; const pLayerName: PVkChar; pPropertyCount: PVkUint32; pProperties: PVkExtensionProperties): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2367.   TvkEnumerateInstanceExtensionProperties            = function (const pLayerName: PVkChar; pPropertyCount: PVkUint32; pProperties: PVkExtensionProperties): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2368.   TvkGetRenderAreaGranularity                        = procedure(device: VkDevice; renderPass: VkRenderPass; pGranularity: PVkExtent2D); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2369.   TvkEnumerateDeviceLayerProperties                  = function (physicalDevice: VkPhysicalDevice; pPropertyCount: PVkUint32; pProperties: PVkLayerProperties): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2370.   TvkEnumerateInstanceLayerProperties                = function (pPropertyCount: PVkUint32; pProperties: PVkLayerProperties): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2371.   TvkCmdBindIndexBuffer                              = procedure(commandBuffer: VkCommandBuffer; buffer: VkBuffer; offset: VkDeviceSize; indexType: TVkIndexType); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2372.   TvkGetPhysicalDeviceFeatures                       = procedure(physicalDevice: VkPhysicalDevice; pFeatures: PVkPhysicalDeviceFeatures); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2373.   TvkCmdCopyBuffer                                   = procedure(commandBuffer: VkCommandBuffer; srcBuffer: VkBuffer; dstBuffer: VkBuffer; regionCount: VkUint32; const pRegions: PVkBufferCopy); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2374.   TvkGetBufferMemoryRequirements                     = procedure(device: VkDevice; buffer: VkBuffer; pMemoryRequirements: PVkMemoryRequirements); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2375.   TvkGetImageMemoryRequirements                      = procedure(device: VkDevice; image: VkImage; pMemoryRequirements: PVkMemoryRequirements); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2376.   TvkGetPhysicalDeviceFormatProperties               = procedure(physicalDevice: VkPhysicalDevice; format: TVkFormat; pFormatProperties: PVkFormatProperties); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2377.   TvkGetImageSubresourceLayout                       = procedure(device: VkDevice; image: VkImage; const pSubresource: PVkImageSubresource; pLayout: PVkSubresourceLayout); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2378.   TvkCmdClearColorImage                              = procedure(commandBuffer: VkCommandBuffer; image: VkImage; imageLayout: TVkImageLayout; const pColor: PVkClearColorValue; rangeCount: VkUint32; const pRanges: PVkImageSubresourceRange); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2379.   TvkCmdClearDepthStencilImage                       = procedure(commandBuffer: VkCommandBuffer; image: VkImage; imageLayout: TVkImageLayout; const pDepthStencil: PVkClearDepthStencilValue; rangeCount: VkUint32; const pRanges: PVkImageSubresourceRange); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2380.   TvkAllocateCommandBuffers                          = function (device: VkDevice; const pAllocateInfo: PVkCommandBufferAllocateInfo; pCommandBuffers: PVkCommandBuffer): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2381.   TvkAllocateDescriptorSets                          = function (device: VkDevice; const pAllocateInfo: PVkDescriptorSetAllocateInfo; pDescriptorSets: PVkDescriptorSet): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2382.   TvkCmdSetScissor                                   = procedure(commandBuffer: VkCommandBuffer; firstScissor: VkUint32; scissorCount: VkUint32; const pScissors: PVkRect2D); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2383.   TvkGetPhysicalDeviceQueueFamilyProperties          = procedure(physicalDevice: VkPhysicalDevice; pQueueFamilyPropertyCount: PVkUint32; pQueueFamilyProperties: PVkQueueFamilyProperties); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2384.   TvkGetPhysicalDeviceImageFormatProperties          = function (physicalDevice: VkPhysicalDevice; format: TVkFormat; iType: TVkImageType; tiling: TVkImageTiling; usage: VkImageUsageFlags; flags: VkImageCreateFlags; pImageFormatProperties: PVkImageFormatProperties): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2385.   TvkCmdCopyImage                                    = procedure(commandBuffer: VkCommandBuffer; srcImage: VkImage; srcImageLayout: TVkImageLayout; dstImage: VkImage; dstImageLayout: TVkImageLayout; regionCount: VkUint32; const pRegions: PVkImageCopy); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2386.   TvkCreateBuffer                                    = function (device: VkDevice; const pCreateInfo: PVkBufferCreateInfo; const pAllocator: PVkAllocationCallbacks; pBuffer: PVkBuffer): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2387.   TvkCreateBufferView                                = function (device: VkDevice; const pCreateInfo: PVkBufferViewCreateInfo; const pAllocator: PVkAllocationCallbacks; pView: PVkBufferView): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2388.   TvkCreateCommandPool                               = function (device: VkDevice; const pCreateInfo: PVkCommandPoolCreateInfo; const pAllocator: PVkAllocationCallbacks; pCommandPool: PVkCommandPool): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2389.   TvkDestroyBuffer                                   = procedure(device: VkDevice; buffer: VkBuffer; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2390.   TvkDestroyBufferView                               = procedure(device: VkDevice; bufferView: VkBufferView; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2391.   TvkDestroyCommandPool                              = procedure(device: VkDevice; commandPool: VkCommandPool; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2392.   TvkCmdCopyBufferToImage                            = procedure(commandBuffer: VkCommandBuffer; srcBuffer: VkBuffer; dstImage: VkImage; dstImageLayout: TVkImageLayout; regionCount: VkUint32; const pRegions: PVkBufferImageCopy); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2393.   TvkCmdBlitImage                                    = procedure(commandBuffer: VkCommandBuffer; srcImage: VkImage; srcImageLayout: TVkImageLayout; dstImage: VkImage; dstImageLayout: TVkImageLayout; regionCount: VkUint32; const pRegions: PVkImageBlit; filter: TVkFilter); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2394.   TvkQueueBindSparse                                 = function (queue: VkQueue; bindInfoCount: VkUint32; const pBindInfo: PVkBindSparseInfo; fence: VkFence): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2395.   TvkCmdCopyImageToBuffer                            = procedure(commandBuffer: VkCommandBuffer; srcImage: VkImage; srcImageLayout: TVkImageLayout; dstBuffer: VkBuffer; regionCount: VkUint32; const pRegions: PVkBufferImageCopy); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2396.   TvkCmdResolveImage                                 = procedure(commandBuffer: VkCommandBuffer; srcImage: VkImage; srcImageLayout: TVkImageLayout; dstImage: VkImage; dstImageLayout: TVkImageLayout; regionCount: VkUint32; const pRegions: PVkImageResolve); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2397.   TvkGetPhysicalDeviceMemoryProperties               = procedure(physicalDevice: VkPhysicalDevice; pMemoryProperties: PVkPhysicalDeviceMemoryProperties); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2398.   TvkCreateDescriptorPool                            = function (device: VkDevice; const pCreateInfo: PVkDescriptorPoolCreateInfo; const pAllocator: PVkAllocationCallbacks; pDescriptorPool: PVkDescriptorPool): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2399.   TvkCreateDevice                                    = function (physicalDevice: VkPhysicalDevice; const pCreateInfo: PVkDeviceCreateInfo; const pAllocator: PVkAllocationCallbacks; pDevice: PVkDevice): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2400.   TvkCreateDescriptorSetLayout                       = function (device: VkDevice; const pCreateInfo: PVkDescriptorSetLayoutCreateInfo; const pAllocator: PVkAllocationCallbacks; pSetLayout: PVkDescriptorSetLayout): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2401.   TvkGetImageSparseMemoryRequirements                = procedure(device: VkDevice; image: VkImage; pSparseMemoryRequirementCount: PVkUint32; pSparseMemoryRequirements: PVkSparseImageMemoryRequirements); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2402.   TvkDestroyDescriptorPool                           = procedure(device: VkDevice; descriptorPool: VkDescriptorPool; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2403.   TvkDestroyDescriptorSetLayout                      = procedure(device: VkDevice; descriptorSetLayout: VkDescriptorSetLayout; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2404.   TvkDestroyDevice                                   = procedure(device: VkDevice; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2405.   TvkDestroyEvent                                    = procedure(device: VkDevice; event: VkEvent; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2406.   TvkDestroyFence                                    = procedure(device: VkDevice; fence: VkFence; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2407.   TvkDestroyFramebuffer                              = procedure(device: VkDevice; framebuffer: VkFramebuffer; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2408.   TvkDestroyImage                                    = procedure(device: VkDevice; image: VkImage; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2409.   TvkDestroyImageView                                = procedure(device: VkDevice; imageView: VkImageView; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2410.   TvkDestroyInstance                                 = procedure(instance: VkInstance; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2411.   TvkDestroyPipeline                                 = procedure(device: VkDevice; pipeline: VkPipeline; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2412.   TvkDestroyPipelineCache                            = procedure(device: VkDevice; pipelineCache: VkPipelineCache; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2413.   TvkDestroyPipelineLayout                           = procedure(device: VkDevice; pipelineLayout: VkPipelineLayout; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2414.   TvkGetPhysicalDeviceProperties                     = procedure(physicalDevice: VkPhysicalDevice; pProperties: PVkPhysicalDeviceProperties); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2415.   TvkDestroyQueryPool                                = procedure(device: VkDevice; queryPool: VkQueryPool; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2416.   TvkDestroyRenderPass                               = procedure(device: VkDevice; renderPass: VkRenderPass; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2417.   TvkDestroySampler                                  = procedure(device: VkDevice; sampler: VkSampler; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2418.   TvkDestroySemaphore                                = procedure(device: VkDevice; semaphore: VkSemaphore; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2419.   TvkDestroyShaderModule                             = procedure(device: VkDevice; shaderModule: VkShaderModule; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2420.   TvkFreeMemory                                      = procedure(device: VkDevice; memory: VkDeviceMemory; const pAllocator: PVkAllocationCallbacks); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2421.   TvkCmdClearAttachments                             = procedure(commandBuffer: VkCommandBuffer; attachmentCount: VkUint32; const pAttachments: PVkClearAttachment; rectCount: VkUint32; const pRects: PVkClearRect); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2422.   TvkBeginCommandBuffer                              = function (commandBuffer: VkCommandBuffer; const pBeginInfo: PVkCommandBufferBeginInfo): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2423.   TvkCmdNextSubpass                                  = procedure(commandBuffer: VkCommandBuffer; contents: TVkSubpassContents); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2424.   TvkCmdWriteTimestamp                               = procedure(commandBuffer: VkCommandBuffer; pipelineStage: TVkPipelineStageFlagBits; queryPool: VkQueryPool; query: VkUint32); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2425.   TvkGetPhysicalDeviceSparseImageFormatProperties    = procedure(physicalDevice: VkPhysicalDevice; format: TVkFormat; iType: TVkImageType; samples: TVkSampleCountFlagBits; usage: VkImageUsageFlags; tiling: TVkImageTiling; pPropertyCount: PVkUint32; pProperties: PVkSparseImageFormatProperties); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2426.   TvkFlushMappedMemoryRanges                         = function (device: VkDevice; memoryRangeCount: VkUint32; const pMemoryRanges: PVkMappedMemoryRange): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2427.   TvkInvalidateMappedMemoryRanges                    = function (device: VkDevice; memoryRangeCount: VkUint32; const pMemoryRanges: PVkMappedMemoryRange): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2428.   TvkAllocateMemory                                  = function (device: VkDevice; const pAllocateInfo: PVkMemoryAllocateInfo; const pAllocator: PVkAllocationCallbacks; pMemory: PVkDeviceMemory): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2429.   TvkCreateEvent                                     = function (device: VkDevice; const pCreateInfo: PVkEventCreateInfo; const pAllocator: PVkAllocationCallbacks; pEvent: PVkEvent): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2430.   TvkCreateFence                                     = function (device: VkDevice; const pCreateInfo: PVkFenceCreateInfo; const pAllocator: PVkAllocationCallbacks; pFence: PVkFence): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2431.   TvkCreateFramebuffer                               = function (device: VkDevice; const pCreateInfo: PVkFramebufferCreateInfo; const pAllocator: PVkAllocationCallbacks; pFramebuffer: PVkFramebuffer): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2432.   TvkCreateImage                                     = function (device: VkDevice; const pCreateInfo: PVkImageCreateInfo; const pAllocator: PVkAllocationCallbacks; pImage: PVkImage): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2433.   TvkCreatePipelineCache                             = function (device: VkDevice; const pCreateInfo: PVkPipelineCacheCreateInfo; const pAllocator: PVkAllocationCallbacks; pPipelineCache: PVkPipelineCache): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2434.   TvkQueueSubmit                                     = function (queue: VkQueue; submitCount: VkUint32; const pSubmits: PVkSubmitInfo; fence: VkFence): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2435.   TvkCreateQueryPool                                 = function (device: VkDevice; const pCreateInfo: PVkQueryPoolCreateInfo; const pAllocator: PVkAllocationCallbacks; pQueryPool: PVkQueryPool): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2436.   TvkCreateSampler                                   = function (device: VkDevice; const pCreateInfo: PVkSamplerCreateInfo; const pAllocator: PVkAllocationCallbacks; pSampler: PVkSampler): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2437.   TvkCreateSemaphore                                 = function (device: VkDevice; const pCreateInfo: PVkSemaphoreCreateInfo; const pAllocator: PVkAllocationCallbacks; pSemaphore: PVkSemaphore): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2438.   TvkCreateShaderModule                              = function (device: VkDevice; const pCreateInfo: PVkShaderModuleCreateInfo; const pAllocator: PVkAllocationCallbacks; pShaderModule: PVkShaderModule): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2439.   TvkCmdPipelineBarrier                              = procedure(commandBuffer: VkCommandBuffer; srcStageMask: VkPipelineStageFlags; dstStageMask: VkPipelineStageFlags; dependencyFlags: VkDependencyFlags; memoryBarrierCount: VkUint32; const pMemoryBarriers: PVkMemoryBarrier; bufferMemoryBarrierCount: VkUint32; const pBufferMemoryBarriers: PVkBufferMemoryBarrier; imageMemoryBarrierCount: VkUint32; const pImageMemoryBarriers: PVkImageMemoryBarrier); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2440.   TvkCmdWaitEvents                                   = procedure(commandBuffer: VkCommandBuffer; eventCount: VkUint32; const pEvents: PVkEvent; srcStageMask: VkPipelineStageFlags; dstStageMask: VkPipelineStageFlags; memoryBarrierCount: VkUint32; const pMemoryBarriers: PVkMemoryBarrier; bufferMemoryBarrierCount: VkUint32; const pBufferMemoryBarriers: PVkBufferMemoryBarrier; imageMemoryBarrierCount: VkUint32; const pImageMemoryBarriers: PVkImageMemoryBarrier); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2441.   TvkCreatePipelineLayout                            = function (device: VkDevice; const pCreateInfo: PVkPipelineLayoutCreateInfo; const pAllocator: PVkAllocationCallbacks; pPipelineLayout: PVkPipelineLayout): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2442.   TvkCreateImageView                                 = function (device: VkDevice; const pCreateInfo: PVkImageViewCreateInfo; const pAllocator: PVkAllocationCallbacks; pView: PVkImageView): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2443.   TvkCreateInstance                                  = function (const pCreateInfo: PVkInstanceCreateInfo; const pAllocator: PVkAllocationCallbacks; pInstance: PVkInstance): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2444.   TvkUpdateDescriptorSets                            = procedure(device: VkDevice; descriptorWriteCount: VkUint32; const pDescriptorWrites: PVkWriteDescriptorSet; descriptorCopyCount: VkUint32; const pDescriptorCopies: PVkCopyDescriptorSet); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2445.   TvkCmdBeginRenderPass                              = procedure(commandBuffer: VkCommandBuffer; const pRenderPassBegin: PVkRenderPassBeginInfo; contents: TVkSubpassContents); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2446.   TvkCreateRenderPass                                = function (device: VkDevice; const pCreateInfo: PVkRenderPassCreateInfo; const pAllocator: PVkAllocationCallbacks; pRenderPass: PVkRenderPass): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2447.   TvkCreateGraphicsPipelines                         = function (device: VkDevice; pipelineCache: VkPipelineCache; createInfoCount: VkUint32; const pCreateInfos: PVkGraphicsPipelineCreateInfo; const pAllocator: PVkAllocationCallbacks; pPipelines: PVkPipeline): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2448.   TvkCreateComputePipelines                          = function (device: VkDevice; pipelineCache: VkPipelineCache; createInfoCount: VkUint32; const pCreateInfos: PVkComputePipelineCreateInfo; const pAllocator: PVkAllocationCallbacks; pPipelines: PVkPipeline): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  2449. 

  2450. var { command variables }

  2451.   vkCmdDispatch:                                     TvkCmdDispatch = nil;

  2452.   vkCmdDraw:                                         TvkCmdDraw = nil;

  2453.   vkCmdDrawIndexed:                                  TvkCmdDrawIndexed = nil;

  2454.   vkCmdEndRenderPass:                                TvkCmdEndRenderPass = nil;

  2455.   vkCmdExecuteCommands:                              TvkCmdExecuteCommands = nil;

  2456.   vkCmdSetBlendConstants:                            TvkCmdSetBlendConstants = nil;

  2457.   vkCmdSetDepthBias:                                 TvkCmdSetDepthBias = nil;

  2458.   vkCmdSetDepthBounds:                               TvkCmdSetDepthBounds = nil;

  2459.   vkDeviceWaitIdle:                                  TvkDeviceWaitIdle = nil;

  2460.   vkGetDeviceProcAddr:                               TvkGetDeviceProcAddr = nil;

  2461.   vkGetInstanceProcAddr:                             TvkGetInstanceProcAddr = nil;

  2462.   vkEnumeratePhysicalDevices:                        TvkEnumeratePhysicalDevices = nil;

  2463.   vkGetDeviceQueue:                                  TvkGetDeviceQueue = nil;

  2464.   vkQueueWaitIdle:                                   TvkQueueWaitIdle = nil;

  2465.   vkCmdSetLineWidth:                                 TvkCmdSetLineWidth = nil;

  2466.   vkEndCommandBuffer:                                TvkEndCommandBuffer = nil;

  2467.   vkFreeCommandBuffers:                              TvkFreeCommandBuffers = nil;

  2468.   vkFreeDescriptorSets:                              TvkFreeDescriptorSets = nil;

  2469.   vkUnmapMemory:                                     TvkUnmapMemory = nil;

  2470.   vkGetEventStatus:                                  TvkGetEventStatus = nil;

  2471.   vkResetEvent:                                      TvkResetEvent = nil;

  2472.   vkSetEvent:                                        TvkSetEvent = nil;

  2473.   vkGetFenceStatus:                                  TvkGetFenceStatus = nil;

  2474.   vkResetFences:                                     TvkResetFences = nil;

  2475.   vkGetPipelineCacheData:                            TvkGetPipelineCacheData = nil;

  2476.   vkMergePipelineCaches:                             TvkMergePipelineCaches = nil;

  2477.   vkCmdEndQuery:                                     TvkCmdEndQuery = nil;

  2478.   vkCmdResetQueryPool:                               TvkCmdResetQueryPool = nil;

  2479.   vkWaitForFences:                                   TvkWaitForFences = nil;

  2480.   vkBindBufferMemory:                                TvkBindBufferMemory = nil;

  2481.   vkBindImageMemory:                                 TvkBindImageMemory = nil;

  2482.   vkCmdBindVertexBuffers:                            TvkCmdBindVertexBuffers = nil;

  2483.   vkCmdDispatchIndirect:                             TvkCmdDispatchIndirect = nil;

  2484.   vkCmdDrawIndexedIndirect:                          TvkCmdDrawIndexedIndirect = nil;

  2485.   vkCmdDrawIndirect:                                 TvkCmdDrawIndirect = nil;

  2486.   vkCmdFillBuffer:                                   TvkCmdFillBuffer = nil;

  2487.   vkCmdUpdateBuffer:                                 TvkCmdUpdateBuffer = nil;

  2488.   vkGetDeviceMemoryCommitment:                       TvkGetDeviceMemoryCommitment = nil;

  2489.   vkResetCommandBuffer:                              TvkResetCommandBuffer = nil;

  2490.   vkResetCommandPool:                                TvkResetCommandPool = nil;

  2491.   vkResetDescriptorPool:                             TvkResetDescriptorPool = nil;

  2492.   vkMapMemory:                                       TvkMapMemory = nil;

  2493.   vkCmdResetEvent:                                   TvkCmdResetEvent = nil;

  2494.   vkCmdSetEvent:                                     TvkCmdSetEvent = nil;

  2495.   vkCmdBeginQuery:                                   TvkCmdBeginQuery = nil;

  2496.   vkCmdCopyQueryPoolResults:                         TvkCmdCopyQueryPoolResults = nil;

  2497.   vkGetQueryPoolResults:                             TvkGetQueryPoolResults = nil;

  2498.   vkCmdPushConstants:                                TvkCmdPushConstants = nil;

  2499.   vkCmdSetStencilCompareMask:                        TvkCmdSetStencilCompareMask = nil;

  2500.   vkCmdSetStencilReference:                          TvkCmdSetStencilReference = nil;

  2501.   vkCmdSetStencilWriteMask:                          TvkCmdSetStencilWriteMask = nil;

  2502.   vkCmdBindPipeline:                                 TvkCmdBindPipeline = nil;

  2503.   vkCmdBindDescriptorSets:                           TvkCmdBindDescriptorSets = nil;

  2504.   vkCmdSetViewport:                                  TvkCmdSetViewport = nil;

  2505.   vkEnumerateDeviceExtensionProperties:              TvkEnumerateDeviceExtensionProperties = nil;

  2506.   vkEnumerateInstanceExtensionProperties:            TvkEnumerateInstanceExtensionProperties = nil;

  2507.   vkGetRenderAreaGranularity:                        TvkGetRenderAreaGranularity = nil;

  2508.   vkEnumerateDeviceLayerProperties:                  TvkEnumerateDeviceLayerProperties = nil;

  2509.   vkEnumerateInstanceLayerProperties:                TvkEnumerateInstanceLayerProperties = nil;

  2510.   vkCmdBindIndexBuffer:                              TvkCmdBindIndexBuffer = nil;

  2511.   vkGetPhysicalDeviceFeatures:                       TvkGetPhysicalDeviceFeatures = nil;

  2512.   vkCmdCopyBuffer:                                   TvkCmdCopyBuffer = nil;

  2513.   vkGetBufferMemoryRequirements:                     TvkGetBufferMemoryRequirements = nil;

  2514.   vkGetImageMemoryRequirements:                      TvkGetImageMemoryRequirements = nil;

  2515.   vkGetPhysicalDeviceFormatProperties:               TvkGetPhysicalDeviceFormatProperties = nil;

  2516.   vkGetImageSubresourceLayout:                       TvkGetImageSubresourceLayout = nil;

  2517.   vkCmdClearColorImage:                              TvkCmdClearColorImage = nil;

  2518.   vkCmdClearDepthStencilImage:                       TvkCmdClearDepthStencilImage = nil;

  2519.   vkAllocateCommandBuffers:                          TvkAllocateCommandBuffers = nil;

  2520.   vkAllocateDescriptorSets:                          TvkAllocateDescriptorSets = nil;

  2521.   vkCmdSetScissor:                                   TvkCmdSetScissor = nil;

  2522.   vkGetPhysicalDeviceQueueFamilyProperties:          TvkGetPhysicalDeviceQueueFamilyProperties = nil;

  2523.   vkGetPhysicalDeviceImageFormatProperties:          TvkGetPhysicalDeviceImageFormatProperties = nil;

  2524.   vkCmdCopyImage:                                    TvkCmdCopyImage = nil;

  2525.   vkCreateBuffer:                                    TvkCreateBuffer = nil;

  2526.   vkCreateBufferView:                                TvkCreateBufferView = nil;

  2527.   vkCreateCommandPool:                               TvkCreateCommandPool = nil;

  2528.   vkDestroyBuffer:                                   TvkDestroyBuffer = nil;

  2529.   vkDestroyBufferView:                               TvkDestroyBufferView = nil;

  2530.   vkDestroyCommandPool:                              TvkDestroyCommandPool = nil;

  2531.   vkCmdCopyBufferToImage:                            TvkCmdCopyBufferToImage = nil;

  2532.   vkCmdBlitImage:                                    TvkCmdBlitImage = nil;

  2533.   vkQueueBindSparse:                                 TvkQueueBindSparse = nil;

  2534.   vkCmdCopyImageToBuffer:                            TvkCmdCopyImageToBuffer = nil;

  2535.   vkCmdResolveImage:                                 TvkCmdResolveImage = nil;

  2536.   vkGetPhysicalDeviceMemoryProperties:               TvkGetPhysicalDeviceMemoryProperties = nil;

  2537.   vkCreateDescriptorPool:                            TvkCreateDescriptorPool = nil;

  2538.   vkCreateDevice:                                    TvkCreateDevice = nil;

  2539.   vkCreateDescriptorSetLayout:                       TvkCreateDescriptorSetLayout = nil;

  2540.   vkGetImageSparseMemoryRequirements:                TvkGetImageSparseMemoryRequirements = nil;

  2541.   vkDestroyDescriptorPool:                           TvkDestroyDescriptorPool = nil;

  2542.   vkDestroyDescriptorSetLayout:                      TvkDestroyDescriptorSetLayout = nil;

  2543.   vkDestroyDevice:                                   TvkDestroyDevice = nil;

  2544.   vkDestroyEvent:                                    TvkDestroyEvent = nil;

  2545.   vkDestroyFence:                                    TvkDestroyFence = nil;

  2546.   vkDestroyFramebuffer:                              TvkDestroyFramebuffer = nil;

  2547.   vkDestroyImage:                                    TvkDestroyImage = nil;

  2548.   vkDestroyImageView:                                TvkDestroyImageView = nil;

  2549.   vkDestroyInstance:                                 TvkDestroyInstance = nil;

  2550.   vkDestroyPipeline:                                 TvkDestroyPipeline = nil;

  2551.   vkDestroyPipelineCache:                            TvkDestroyPipelineCache = nil;

  2552.   vkDestroyPipelineLayout:                           TvkDestroyPipelineLayout = nil;

  2553.   vkGetPhysicalDeviceProperties:                     TvkGetPhysicalDeviceProperties = nil;

  2554.   vkDestroyQueryPool:                                TvkDestroyQueryPool = nil;

  2555.   vkDestroyRenderPass:                               TvkDestroyRenderPass = nil;

  2556.   vkDestroySampler:                                  TvkDestroySampler = nil;

  2557.   vkDestroySemaphore:                                TvkDestroySemaphore = nil;

  2558.   vkDestroyShaderModule:                             TvkDestroyShaderModule = nil;

  2559.   vkFreeMemory:                                      TvkFreeMemory = nil;

  2560.   vkCmdClearAttachments:                             TvkCmdClearAttachments = nil;

  2561.   vkBeginCommandBuffer:                              TvkBeginCommandBuffer = nil;

  2562.   vkCmdNextSubpass:                                  TvkCmdNextSubpass = nil;

  2563.   vkCmdWriteTimestamp:                               TvkCmdWriteTimestamp = nil;

  2564.   vkGetPhysicalDeviceSparseImageFormatProperties:    TvkGetPhysicalDeviceSparseImageFormatProperties = nil;

  2565.   vkFlushMappedMemoryRanges:                         TvkFlushMappedMemoryRanges = nil;

  2566.   vkInvalidateMappedMemoryRanges:                    TvkInvalidateMappedMemoryRanges = nil;

  2567.   vkAllocateMemory:                                  TvkAllocateMemory = nil;

  2568.   vkCreateEvent:                                     TvkCreateEvent = nil;

  2569.   vkCreateFence:                                     TvkCreateFence = nil;

  2570.   vkCreateFramebuffer:                               TvkCreateFramebuffer = nil;

  2571.   vkCreateImage:                                     TvkCreateImage = nil;

  2572.   vkCreatePipelineCache:                             TvkCreatePipelineCache = nil;

  2573.   vkQueueSubmit:                                     TvkQueueSubmit = nil;

  2574.   vkCreateQueryPool:                                 TvkCreateQueryPool = nil;

  2575.   vkCreateSampler:                                   TvkCreateSampler = nil;

  2576.   vkCreateSemaphore:                                 TvkCreateSemaphore = nil;

  2577.   vkCreateShaderModule:                              TvkCreateShaderModule = nil;

  2578.   vkCmdPipelineBarrier:                              TvkCmdPipelineBarrier = nil;

  2579.   vkCmdWaitEvents:                                   TvkCmdWaitEvents = nil;

  2580.   vkCreatePipelineLayout:                            TvkCreatePipelineLayout = nil;

  2581.   vkCreateImageView:                                 TvkCreateImageView = nil;

  2582.   vkCreateInstance:                                  TvkCreateInstance = nil;

  2583.   vkUpdateDescriptorSets:                            TvkUpdateDescriptorSets = nil;

  2584.   vkCmdBeginRenderPass:                              TvkCmdBeginRenderPass = nil;

  2585.   vkCreateRenderPass:                                TvkCreateRenderPass = nil;

  2586.   vkCreateGraphicsPipelines:                         TvkCreateGraphicsPipelines = nil;

  2587.   vkCreateComputePipelines:                          TvkCreateComputePipelines = nil;

  2588. 

  2589. const

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

  2591. 

  2592. type

  2593.   VkVersion = VkInt32;

  2594. 

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

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

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

  2598. function vkgetVersionPatch(const aVersion: VkVersion): Integer;

  2599. 

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

  2601. procedure FinalizeVulkan;

  2602. 

  2603. implementation

  2604. 

  2605. type

  2606. {$IF DEFINED(VK_WIN)}

  2607.   TvkLibHandle = TLibHandle;

  2608. {$ELSE}

  2609.   TvkLibHandle = Pointer;

  2610. {$ENDIF}

  2611. 

  2612. const

  2613. {$IF DEFINED(VK_WIN)}

  2614.   InvalidLibHandle = 0;

  2615. {$ELSE}

  2616.   InvalidLibHandle = nil;

  2617. {$ENDIF}

  2618. 

  2619. var

  2620.   vkLibHandle: TvkLibHandle = InvalidLibHandle;

  2621. 

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

  2623. begin

  2624.   {$IF DEFINED(VK_WIN)}

  2625.   result := LoadLibrary(aLibName);

  2626.   {$ELSE}

  2627.   result := InvalidLibHandle;

  2628.   {$ENDIF}

  2629. end;

  2630. 

  2631. function vkGetProcAddress(const aProcName: String; aLibHandle: TvkLibHandle = InvalidLibHandle): Pointer;

  2632. begin

  2633.   if (aLibHandle = InvalidLibHandle) then

  2634.     aLibHandle := vkLibHandle;

  2635.   {$IF DEFINED(VK_WIN)}

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

  2637.   {$ELSE}

  2638.   result := nil;

  2639.   {$ENDIF}

  2640. end;

  2641. 

  2642. procedure vkFreeLibrary(var aLibHandle: TvkLibHandle);

  2643. begin

  2644.   if (aLibHandle <> InvalidLibHandle) then begin

  2645.     {$IF DEFINED(VK_WIN)}

  2646.     FreeLibrary(aLibHandle);

  2647.     {$ENDIF}

  2648.     aLibHandle := InvalidLibHandle;

  2649.   end;

  2650. end;

  2651. 

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

  2653. begin

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

  2655. end;

  2656. 

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

  2658. begin

  2659.   result := (aVersion shr 22);

  2660. end;

  2661. 

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

  2663. begin

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

  2665. end;

  2666. 

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

  2668. begin

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

  2670. end;

  2671. 

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

  2673. begin

  2674.   FinalizeVulkan;

  2675.   vkLibHandle := vkLoadLibrary(aLibName);

  2676.   result := (vkLibHandle <> InvalidLibHandle);

  2677.   if not result then

  2678.     exit;

  2679. 

  2680. {********************************* VK_VERSION_1_0 *********************************}

  2681. 

  2682.   vkCmdDispatch                                      := vkGetProcAddress('vkCmdDispatch');

  2683.   vkCmdDraw                                          := vkGetProcAddress('vkCmdDraw');

  2684.   vkCmdDrawIndexed                                   := vkGetProcAddress('vkCmdDrawIndexed');

  2685.   vkCmdEndRenderPass                                 := vkGetProcAddress('vkCmdEndRenderPass');

  2686.   vkCmdExecuteCommands                               := vkGetProcAddress('vkCmdExecuteCommands');

  2687.   vkCmdSetBlendConstants                             := vkGetProcAddress('vkCmdSetBlendConstants');

  2688.   vkCmdSetDepthBias                                  := vkGetProcAddress('vkCmdSetDepthBias');

  2689.   vkCmdSetDepthBounds                                := vkGetProcAddress('vkCmdSetDepthBounds');

  2690.   vkDeviceWaitIdle                                   := vkGetProcAddress('vkDeviceWaitIdle');

  2691.   vkGetDeviceProcAddr                                := vkGetProcAddress('vkGetDeviceProcAddr');

  2692.   vkGetInstanceProcAddr                              := vkGetProcAddress('vkGetInstanceProcAddr');

  2693.   vkEnumeratePhysicalDevices                         := vkGetProcAddress('vkEnumeratePhysicalDevices');

  2694.   vkGetDeviceQueue                                   := vkGetProcAddress('vkGetDeviceQueue');

  2695.   vkQueueWaitIdle                                    := vkGetProcAddress('vkQueueWaitIdle');

  2696.   vkCmdSetLineWidth                                  := vkGetProcAddress('vkCmdSetLineWidth');

  2697.   vkEndCommandBuffer                                 := vkGetProcAddress('vkEndCommandBuffer');

  2698.   vkFreeCommandBuffers                               := vkGetProcAddress('vkFreeCommandBuffers');

  2699.   vkFreeDescriptorSets                               := vkGetProcAddress('vkFreeDescriptorSets');

  2700.   vkUnmapMemory                                      := vkGetProcAddress('vkUnmapMemory');

  2701.   vkGetEventStatus                                   := vkGetProcAddress('vkGetEventStatus');

  2702.   vkResetEvent                                       := vkGetProcAddress('vkResetEvent');

  2703.   vkSetEvent                                         := vkGetProcAddress('vkSetEvent');

  2704.   vkGetFenceStatus                                   := vkGetProcAddress('vkGetFenceStatus');

  2705.   vkResetFences                                      := vkGetProcAddress('vkResetFences');

  2706.   vkGetPipelineCacheData                             := vkGetProcAddress('vkGetPipelineCacheData');

  2707.   vkMergePipelineCaches                              := vkGetProcAddress('vkMergePipelineCaches');

  2708.   vkCmdEndQuery                                      := vkGetProcAddress('vkCmdEndQuery');

  2709.   vkCmdResetQueryPool                                := vkGetProcAddress('vkCmdResetQueryPool');

  2710.   vkWaitForFences                                    := vkGetProcAddress('vkWaitForFences');

  2711.   vkBindBufferMemory                                 := vkGetProcAddress('vkBindBufferMemory');

  2712.   vkBindImageMemory                                  := vkGetProcAddress('vkBindImageMemory');

  2713.   vkCmdBindVertexBuffers                             := vkGetProcAddress('vkCmdBindVertexBuffers');

  2714.   vkCmdDispatchIndirect                              := vkGetProcAddress('vkCmdDispatchIndirect');

  2715.   vkCmdDrawIndexedIndirect                           := vkGetProcAddress('vkCmdDrawIndexedIndirect');

  2716.   vkCmdDrawIndirect                                  := vkGetProcAddress('vkCmdDrawIndirect');

  2717.   vkCmdFillBuffer                                    := vkGetProcAddress('vkCmdFillBuffer');

  2718.   vkCmdUpdateBuffer                                  := vkGetProcAddress('vkCmdUpdateBuffer');

  2719.   vkGetDeviceMemoryCommitment                        := vkGetProcAddress('vkGetDeviceMemoryCommitment');

  2720.   vkResetCommandBuffer                               := vkGetProcAddress('vkResetCommandBuffer');

  2721.   vkResetCommandPool                                 := vkGetProcAddress('vkResetCommandPool');

  2722.   vkResetDescriptorPool                              := vkGetProcAddress('vkResetDescriptorPool');

  2723.   vkMapMemory                                        := vkGetProcAddress('vkMapMemory');

  2724.   vkCmdResetEvent                                    := vkGetProcAddress('vkCmdResetEvent');

  2725.   vkCmdSetEvent                                      := vkGetProcAddress('vkCmdSetEvent');

  2726.   vkCmdBeginQuery                                    := vkGetProcAddress('vkCmdBeginQuery');

  2727.   vkCmdCopyQueryPoolResults                          := vkGetProcAddress('vkCmdCopyQueryPoolResults');

  2728.   vkGetQueryPoolResults                              := vkGetProcAddress('vkGetQueryPoolResults');

  2729.   vkCmdPushConstants                                 := vkGetProcAddress('vkCmdPushConstants');

  2730.   vkCmdSetStencilCompareMask                         := vkGetProcAddress('vkCmdSetStencilCompareMask');

  2731.   vkCmdSetStencilReference                           := vkGetProcAddress('vkCmdSetStencilReference');

  2732.   vkCmdSetStencilWriteMask                           := vkGetProcAddress('vkCmdSetStencilWriteMask');

  2733.   vkCmdBindPipeline                                  := vkGetProcAddress('vkCmdBindPipeline');

  2734.   vkCmdBindDescriptorSets                            := vkGetProcAddress('vkCmdBindDescriptorSets');

  2735.   vkCmdSetViewport                                   := vkGetProcAddress('vkCmdSetViewport');

  2736.   vkEnumerateDeviceExtensionProperties               := vkGetProcAddress('vkEnumerateDeviceExtensionProperties');

  2737.   vkEnumerateInstanceExtensionProperties             := vkGetProcAddress('vkEnumerateInstanceExtensionProperties');

  2738.   vkGetRenderAreaGranularity                         := vkGetProcAddress('vkGetRenderAreaGranularity');

  2739.   vkEnumerateDeviceLayerProperties                   := vkGetProcAddress('vkEnumerateDeviceLayerProperties');

  2740.   vkEnumerateInstanceLayerProperties                 := vkGetProcAddress('vkEnumerateInstanceLayerProperties');

  2741.   vkCmdBindIndexBuffer                               := vkGetProcAddress('vkCmdBindIndexBuffer');

  2742.   vkGetPhysicalDeviceFeatures                        := vkGetProcAddress('vkGetPhysicalDeviceFeatures');

  2743.   vkCmdCopyBuffer                                    := vkGetProcAddress('vkCmdCopyBuffer');

  2744.   vkGetBufferMemoryRequirements                      := vkGetProcAddress('vkGetBufferMemoryRequirements');

  2745.   vkGetImageMemoryRequirements                       := vkGetProcAddress('vkGetImageMemoryRequirements');

  2746.   vkGetPhysicalDeviceFormatProperties                := vkGetProcAddress('vkGetPhysicalDeviceFormatProperties');

  2747.   vkGetImageSubresourceLayout                        := vkGetProcAddress('vkGetImageSubresourceLayout');

  2748.   vkCmdClearColorImage                               := vkGetProcAddress('vkCmdClearColorImage');

  2749.   vkCmdClearDepthStencilImage                        := vkGetProcAddress('vkCmdClearDepthStencilImage');

  2750.   vkAllocateCommandBuffers                           := vkGetProcAddress('vkAllocateCommandBuffers');

  2751.   vkAllocateDescriptorSets                           := vkGetProcAddress('vkAllocateDescriptorSets');

  2752.   vkCmdSetScissor                                    := vkGetProcAddress('vkCmdSetScissor');

  2753.   vkGetPhysicalDeviceQueueFamilyProperties           := vkGetProcAddress('vkGetPhysicalDeviceQueueFamilyProperties');

  2754.   vkGetPhysicalDeviceImageFormatProperties           := vkGetProcAddress('vkGetPhysicalDeviceImageFormatProperties');

  2755.   vkCmdCopyImage                                     := vkGetProcAddress('vkCmdCopyImage');

  2756.   vkCreateBuffer                                     := vkGetProcAddress('vkCreateBuffer');

  2757.   vkCreateBufferView                                 := vkGetProcAddress('vkCreateBufferView');

  2758.   vkCreateCommandPool                                := vkGetProcAddress('vkCreateCommandPool');

  2759.   vkDestroyBuffer                                    := vkGetProcAddress('vkDestroyBuffer');

  2760.   vkDestroyBufferView                                := vkGetProcAddress('vkDestroyBufferView');

  2761.   vkDestroyCommandPool                               := vkGetProcAddress('vkDestroyCommandPool');

  2762.   vkCmdCopyBufferToImage                             := vkGetProcAddress('vkCmdCopyBufferToImage');

  2763.   vkCmdBlitImage                                     := vkGetProcAddress('vkCmdBlitImage');

  2764.   vkQueueBindSparse                                  := vkGetProcAddress('vkQueueBindSparse');

  2765.   vkCmdCopyImageToBuffer                             := vkGetProcAddress('vkCmdCopyImageToBuffer');

  2766.   vkCmdResolveImage                                  := vkGetProcAddress('vkCmdResolveImage');

  2767.   vkGetPhysicalDeviceMemoryProperties                := vkGetProcAddress('vkGetPhysicalDeviceMemoryProperties');

  2768.   vkCreateDescriptorPool                             := vkGetProcAddress('vkCreateDescriptorPool');

  2769.   vkCreateDevice                                     := vkGetProcAddress('vkCreateDevice');

  2770.   vkCreateDescriptorSetLayout                        := vkGetProcAddress('vkCreateDescriptorSetLayout');

  2771.   vkGetImageSparseMemoryRequirements                 := vkGetProcAddress('vkGetImageSparseMemoryRequirements');

  2772.   vkDestroyDescriptorPool                            := vkGetProcAddress('vkDestroyDescriptorPool');

  2773.   vkDestroyDescriptorSetLayout                       := vkGetProcAddress('vkDestroyDescriptorSetLayout');

  2774.   vkDestroyDevice                                    := vkGetProcAddress('vkDestroyDevice');

  2775.   vkDestroyEvent                                     := vkGetProcAddress('vkDestroyEvent');

  2776.   vkDestroyFence                                     := vkGetProcAddress('vkDestroyFence');

  2777.   vkDestroyFramebuffer                               := vkGetProcAddress('vkDestroyFramebuffer');

  2778.   vkDestroyImage                                     := vkGetProcAddress('vkDestroyImage');

  2779.   vkDestroyImageView                                 := vkGetProcAddress('vkDestroyImageView');

  2780.   vkDestroyInstance                                  := vkGetProcAddress('vkDestroyInstance');

  2781.   vkDestroyPipeline                                  := vkGetProcAddress('vkDestroyPipeline');

  2782.   vkDestroyPipelineCache                             := vkGetProcAddress('vkDestroyPipelineCache');

  2783.   vkDestroyPipelineLayout                            := vkGetProcAddress('vkDestroyPipelineLayout');

  2784.   vkGetPhysicalDeviceProperties                      := vkGetProcAddress('vkGetPhysicalDeviceProperties');

  2785.   vkDestroyQueryPool                                 := vkGetProcAddress('vkDestroyQueryPool');

  2786.   vkDestroyRenderPass                                := vkGetProcAddress('vkDestroyRenderPass');

  2787.   vkDestroySampler                                   := vkGetProcAddress('vkDestroySampler');

  2788.   vkDestroySemaphore                                 := vkGetProcAddress('vkDestroySemaphore');

  2789.   vkDestroyShaderModule                              := vkGetProcAddress('vkDestroyShaderModule');

  2790.   vkFreeMemory                                       := vkGetProcAddress('vkFreeMemory');

  2791.   vkCmdClearAttachments                              := vkGetProcAddress('vkCmdClearAttachments');

  2792.   vkBeginCommandBuffer                               := vkGetProcAddress('vkBeginCommandBuffer');

  2793.   vkCmdNextSubpass                                   := vkGetProcAddress('vkCmdNextSubpass');

  2794.   vkCmdWriteTimestamp                                := vkGetProcAddress('vkCmdWriteTimestamp');

  2795.   vkGetPhysicalDeviceSparseImageFormatProperties     := vkGetProcAddress('vkGetPhysicalDeviceSparseImageFormatProperties');

  2796.   vkFlushMappedMemoryRanges                          := vkGetProcAddress('vkFlushMappedMemoryRanges');

  2797.   vkInvalidateMappedMemoryRanges                     := vkGetProcAddress('vkInvalidateMappedMemoryRanges');

  2798.   vkAllocateMemory                                   := vkGetProcAddress('vkAllocateMemory');

  2799.   vkCreateEvent                                      := vkGetProcAddress('vkCreateEvent');

  2800.   vkCreateFence                                      := vkGetProcAddress('vkCreateFence');

  2801.   vkCreateFramebuffer                                := vkGetProcAddress('vkCreateFramebuffer');

  2802.   vkCreateImage                                      := vkGetProcAddress('vkCreateImage');

  2803.   vkCreatePipelineCache                              := vkGetProcAddress('vkCreatePipelineCache');

  2804.   vkQueueSubmit                                      := vkGetProcAddress('vkQueueSubmit');

  2805.   vkCreateQueryPool                                  := vkGetProcAddress('vkCreateQueryPool');

  2806.   vkCreateSampler                                    := vkGetProcAddress('vkCreateSampler');

  2807.   vkCreateSemaphore                                  := vkGetProcAddress('vkCreateSemaphore');

  2808.   vkCreateShaderModule                               := vkGetProcAddress('vkCreateShaderModule');

  2809.   vkCmdPipelineBarrier                               := vkGetProcAddress('vkCmdPipelineBarrier');

  2810.   vkCmdWaitEvents                                    := vkGetProcAddress('vkCmdWaitEvents');

  2811.   vkCreatePipelineLayout                             := vkGetProcAddress('vkCreatePipelineLayout');

  2812.   vkCreateImageView                                  := vkGetProcAddress('vkCreateImageView');

  2813.   vkCreateInstance                                   := vkGetProcAddress('vkCreateInstance');

  2814.   vkUpdateDescriptorSets                             := vkGetProcAddress('vkUpdateDescriptorSets');

  2815.   vkCmdBeginRenderPass                               := vkGetProcAddress('vkCmdBeginRenderPass');

  2816.   vkCreateRenderPass                                 := vkGetProcAddress('vkCreateRenderPass');

  2817.   vkCreateGraphicsPipelines                          := vkGetProcAddress('vkCreateGraphicsPipelines');

  2818.   vkCreateComputePipelines                           := vkGetProcAddress('vkCreateComputePipelines');

  2819. 

  2820. end;

  2821. 

  2822. procedure FinalizeVulkan;

  2823. begin

  2824.   vkFreeLibrary(vkLibHandle);

  2825. end;

  2826. 

  2827. initialization

  2828. 

  2829. finalization

  2830.   FinalizeVulkan;

  2831. 

  2832. end.