opengl
/
Vulkan
1
0
Förgrening 0
Kod Ärenden 0 Pull-förfrågningar 0 Släpp 0 Wiki Aktiviteter
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
5 Incheckningar
1 Gren
458 KiB
 
 
Träd: 4cac6c7e44
Grenar Taggar
${ item.name }
Skapa branchen ${ searchTerm }
från '4cac6c7e44'
${ noResults }
Vulkan/projects/Vulkan.pas

2838 rader
188 KiB
Rå Blame Historik 

  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_API_VERSION                                                 = 4194307;

  85.   VK_API_VERSION_MAJOR                                           = 1;

  86.   VK_API_VERSION_MINOR                                           = 0;

  87.   VK_API_VERSION_BUGFIX                                          = 3;

  88. 

  89.   VK_MAX_PHYSICAL_DEVICE_NAME_SIZE                               = 256;

  90.   VK_UUID_SIZE                                                   = 16;

  91.   VK_MAX_EXTENSION_NAME_SIZE                                     = 256;

  92.   VK_MAX_DESCRIPTION_SIZE                                        = 256;

  93.   VK_MAX_MEMORY_TYPES                                            = 32;

  94.   VK_MAX_MEMORY_HEAPS                                            = 16;

  95.   VK_LOD_CLAMP_NONE                                              = 1000;

  96.   VK_REMAINING_MIP_LEVELS                                        = $FFFFFFFF;

  97.   VK_REMAINING_ARRAY_LAYERS                                      = $FFFFFFFF;

  98.   VK_WHOLE_SIZE                                                  = $FFFFFFFF;

  99.   VK_ATTACHMENT_UNUSED                                           = $FFFFFFFF;

  100.   VK_TRUE                                                        = 1;

  101.   VK_FALSE                                                       = 0;

  102.   VK_QUEUE_FAMILY_IGNORED                                        = $FFFFFFFF;

  103.   VK_SUBPASS_EXTERNAL                                            = $FFFFFFFF;

  104. 

  105. type { types }

  106.   PVkVoid                                                        = Pointer;

  107.   VkChar                                                         = AnsiChar;

  108.   VkDouble                                                       = Double;

  109.   VkFloat                                                        = Single;

  110.   VkHandle                                                       = Pointer;

  111.   VkInt16                                                        = SmallInt;

  112.   VkInt32                                                        = Integer;

  113.   VkInt64                                                        = Int64;

  114.   VkSize                                                         = SizeUInt;

  115.   VkUint16                                                       = Word;

  116.   VkUint32                                                       = Cardinal;

  117.   VkUint64                                                       = QWord;

  118.   VkUint8                                                        = Byte;

  119.   VkBool32                                                       = VkUint32;

  120.   VkFlags                                                        = VkUint32;

  121.   VkSampleMask                                                   = VkUint32;

  122.   VkDeviceSize                                                   = VkUint64;

  123.   VkAccessFlags                                                  = VkFlags;

  124.   VkAttachmentDescriptionFlags                                   = VkFlags;

  125.   VkBufferCreateFlags                                            = VkFlags;

  126.   VkBufferUsageFlags                                             = VkFlags;

  127.   VkBufferViewCreateFlags                                        = VkFlags;

  128.   VkColorComponentFlags                                          = VkFlags;

  129.   VkCommandBufferResetFlags                                      = VkFlags;

  130.   VkCommandBufferUsageFlags                                      = VkFlags;

  131.   VkCommandPoolCreateFlags                                       = VkFlags;

  132.   VkCommandPoolResetFlags                                        = VkFlags;

  133.   VkCullModeFlags                                                = VkFlags;

  134.   VkDependencyFlags                                              = VkFlags;

  135.   VkDescriptorPoolCreateFlags                                    = VkFlags;

  136.   VkDescriptorPoolResetFlags                                     = VkFlags;

  137.   VkDescriptorSetLayoutCreateFlags                               = VkFlags;

  138.   VkDeviceCreateFlags                                            = VkFlags;

  139.   VkDeviceQueueCreateFlags                                       = VkFlags;

  140.   VkEventCreateFlags                                             = VkFlags;

  141.   VkFenceCreateFlags                                             = VkFlags;

  142.   VkFormatFeatureFlags                                           = VkFlags;

  143.   VkFramebufferCreateFlags                                       = VkFlags;

  144.   VkImageAspectFlags                                             = VkFlags;

  145.   VkImageCreateFlags                                             = VkFlags;

  146.   VkImageUsageFlags                                              = VkFlags;

  147.   VkImageViewCreateFlags                                         = VkFlags;

  148.   VkInstanceCreateFlags                                          = VkFlags;

  149.   VkMemoryHeapFlags                                              = VkFlags;

  150.   VkMemoryMapFlags                                               = VkFlags;

  151.   VkMemoryPropertyFlags                                          = VkFlags;

  152.   VkPipelineCacheCreateFlags                                     = VkFlags;

  153.   VkPipelineColorBlendStateCreateFlags                           = VkFlags;

  154.   VkPipelineCreateFlags                                          = VkFlags;

  155.   VkPipelineDepthStencilStateCreateFlags                         = VkFlags;

  156.   VkPipelineDynamicStateCreateFlags                              = VkFlags;

  157.   VkPipelineInputAssemblyStateCreateFlags                        = VkFlags;

  158.   VkPipelineLayoutCreateFlags                                    = VkFlags;

  159.   VkPipelineMultisampleStateCreateFlags                          = VkFlags;

  160.   VkPipelineRasterizationStateCreateFlags                        = VkFlags;

  161.   VkPipelineShaderStageCreateFlags                               = VkFlags;

  162.   VkPipelineStageFlags                                           = VkFlags;

  163.   VkPipelineTessellationStateCreateFlags                         = VkFlags;

  164.   VkPipelineVertexInputStateCreateFlags                          = VkFlags;

  165.   VkPipelineViewportStateCreateFlags                             = VkFlags;

  166.   VkQueryControlFlags                                            = VkFlags;

  167.   VkQueryPipelineStatisticFlags                                  = VkFlags;

  168.   VkQueryPoolCreateFlags                                         = VkFlags;

  169.   VkQueryResultFlags                                             = VkFlags;

  170.   VkQueueFlags                                                   = VkFlags;

  171.   VkRenderPassCreateFlags                                        = VkFlags;

  172.   VkSampleCountFlags                                             = VkFlags;

  173.   VkSamplerCreateFlags                                           = VkFlags;

  174.   VkSemaphoreCreateFlags                                         = VkFlags;

  175.   VkShaderModuleCreateFlags                                      = VkFlags;

  176.   VkShaderStageFlags                                             = VkFlags;

  177.   VkSparseImageFormatFlags                                       = VkFlags;

  178.   VkSparseMemoryBindFlags                                        = VkFlags;

  179.   VkStencilFaceFlags                                             = VkFlags;

  180.   VkSubpassDescriptionFlags                                      = VkFlags;

  181. 

  182. type { type pointers }

  183.   PPVkVoid                                                       = ^PVkVoid;

  184.   PPPVkVoid                                                      = ^PPVkVoid;

  185.   PVkChar                                                        = ^VkChar;

  186.   PPVkChar                                                       = ^PVkChar;

  187.   PVkDouble                                                      = ^VkDouble;

  188.   PPVkDouble                                                     = ^PVkDouble;

  189.   PVkFloat                                                       = ^VkFloat;

  190.   PPVkFloat                                                      = ^PVkFloat;

  191.   PVkHandle                                                      = ^VkHandle;

  192.   PPVkHandle                                                     = ^PVkHandle;

  193.   PVkInt16                                                       = ^VkInt16;

  194.   PPVkInt16                                                      = ^PVkInt16;

  195.   PVkInt32                                                       = ^VkInt32;

  196.   PPVkInt32                                                      = ^PVkInt32;

  197.   PVkInt64                                                       = ^VkInt64;

  198.   PPVkInt64                                                      = ^PVkInt64;

  199.   PVkSize                                                        = ^VkSize;

  200.   PPVkSize                                                       = ^PVkSize;

  201.   PVkUint16                                                      = ^VkUint16;

  202.   PPVkUint16                                                     = ^PVkUint16;

  203.   PVkUint32                                                      = ^VkUint32;

  204.   PPVkUint32                                                     = ^PVkUint32;

  205.   PVkUint64                                                      = ^VkUint64;

  206.   PPVkUint64                                                     = ^PVkUint64;

  207.   PVkUint8                                                       = ^VkUint8;

  208.   PPVkUint8                                                      = ^PVkUint8;

  209.   PVkBool32                                                      = ^VkBool32;

  210.   PPVkBool32                                                     = ^PVkBool32;

  211.   PVkFlags                                                       = ^VkFlags;

  212.   PPVkFlags                                                      = ^PVkFlags;

  213.   PVkSampleMask                                                  = ^VkSampleMask;

  214.   PPVkSampleMask                                                 = ^PVkSampleMask;

  215.   PVkDeviceSize                                                  = ^VkDeviceSize;

  216.   PPVkDeviceSize                                                 = ^PVkDeviceSize;

  217.   PVkAccessFlags                                                 = ^VkAccessFlags;

  218.   PPVkAccessFlags                                                = ^PVkAccessFlags;

  219.   PVkAttachmentDescriptionFlags                                  = ^VkAttachmentDescriptionFlags;

  220.   PPVkAttachmentDescriptionFlags                                 = ^PVkAttachmentDescriptionFlags;

  221.   PVkBufferCreateFlags                                           = ^VkBufferCreateFlags;

  222.   PPVkBufferCreateFlags                                          = ^PVkBufferCreateFlags;

  223.   PVkBufferUsageFlags                                            = ^VkBufferUsageFlags;

  224.   PPVkBufferUsageFlags                                           = ^PVkBufferUsageFlags;

  225.   PVkBufferViewCreateFlags                                       = ^VkBufferViewCreateFlags;

  226.   PPVkBufferViewCreateFlags                                      = ^PVkBufferViewCreateFlags;

  227.   PVkColorComponentFlags                                         = ^VkColorComponentFlags;

  228.   PPVkColorComponentFlags                                        = ^PVkColorComponentFlags;

  229.   PVkCommandBufferResetFlags                                     = ^VkCommandBufferResetFlags;

  230.   PPVkCommandBufferResetFlags                                    = ^PVkCommandBufferResetFlags;

  231.   PVkCommandBufferUsageFlags                                     = ^VkCommandBufferUsageFlags;

  232.   PPVkCommandBufferUsageFlags                                    = ^PVkCommandBufferUsageFlags;

  233.   PVkCommandPoolCreateFlags                                      = ^VkCommandPoolCreateFlags;

  234.   PPVkCommandPoolCreateFlags                                     = ^PVkCommandPoolCreateFlags;

  235.   PVkCommandPoolResetFlags                                       = ^VkCommandPoolResetFlags;

  236.   PPVkCommandPoolResetFlags                                      = ^PVkCommandPoolResetFlags;

  237.   PVkCullModeFlags                                               = ^VkCullModeFlags;

  238.   PPVkCullModeFlags                                              = ^PVkCullModeFlags;

  239.   PVkDependencyFlags                                             = ^VkDependencyFlags;

  240.   PPVkDependencyFlags                                            = ^PVkDependencyFlags;

  241.   PVkDescriptorPoolCreateFlags                                   = ^VkDescriptorPoolCreateFlags;

  242.   PPVkDescriptorPoolCreateFlags                                  = ^PVkDescriptorPoolCreateFlags;

  243.   PVkDescriptorPoolResetFlags                                    = ^VkDescriptorPoolResetFlags;

  244.   PPVkDescriptorPoolResetFlags                                   = ^PVkDescriptorPoolResetFlags;

  245.   PVkDescriptorSetLayoutCreateFlags                              = ^VkDescriptorSetLayoutCreateFlags;

  246.   PPVkDescriptorSetLayoutCreateFlags                             = ^PVkDescriptorSetLayoutCreateFlags;

  247.   PVkDeviceCreateFlags                                           = ^VkDeviceCreateFlags;

  248.   PPVkDeviceCreateFlags                                          = ^PVkDeviceCreateFlags;

  249.   PVkDeviceQueueCreateFlags                                      = ^VkDeviceQueueCreateFlags;

  250.   PPVkDeviceQueueCreateFlags                                     = ^PVkDeviceQueueCreateFlags;

  251.   PVkEventCreateFlags                                            = ^VkEventCreateFlags;

  252.   PPVkEventCreateFlags                                           = ^PVkEventCreateFlags;

  253.   PVkFenceCreateFlags                                            = ^VkFenceCreateFlags;

  254.   PPVkFenceCreateFlags                                           = ^PVkFenceCreateFlags;

  255.   PVkFormatFeatureFlags                                          = ^VkFormatFeatureFlags;

  256.   PPVkFormatFeatureFlags                                         = ^PVkFormatFeatureFlags;

  257.   PVkFramebufferCreateFlags                                      = ^VkFramebufferCreateFlags;

  258.   PPVkFramebufferCreateFlags                                     = ^PVkFramebufferCreateFlags;

  259.   PVkImageAspectFlags                                            = ^VkImageAspectFlags;

  260.   PPVkImageAspectFlags                                           = ^PVkImageAspectFlags;

  261.   PVkImageCreateFlags                                            = ^VkImageCreateFlags;

  262.   PPVkImageCreateFlags                                           = ^PVkImageCreateFlags;

  263.   PVkImageUsageFlags                                             = ^VkImageUsageFlags;

  264.   PPVkImageUsageFlags                                            = ^PVkImageUsageFlags;

  265.   PVkImageViewCreateFlags                                        = ^VkImageViewCreateFlags;

  266.   PPVkImageViewCreateFlags                                       = ^PVkImageViewCreateFlags;

  267.   PVkInstanceCreateFlags                                         = ^VkInstanceCreateFlags;

  268.   PPVkInstanceCreateFlags                                        = ^PVkInstanceCreateFlags;

  269.   PVkMemoryHeapFlags                                             = ^VkMemoryHeapFlags;

  270.   PPVkMemoryHeapFlags                                            = ^PVkMemoryHeapFlags;

  271.   PVkMemoryMapFlags                                              = ^VkMemoryMapFlags;

  272.   PPVkMemoryMapFlags                                             = ^PVkMemoryMapFlags;

  273.   PVkMemoryPropertyFlags                                         = ^VkMemoryPropertyFlags;

  274.   PPVkMemoryPropertyFlags                                        = ^PVkMemoryPropertyFlags;

  275.   PVkPipelineCacheCreateFlags                                    = ^VkPipelineCacheCreateFlags;

  276.   PPVkPipelineCacheCreateFlags                                   = ^PVkPipelineCacheCreateFlags;

  277.   PVkPipelineColorBlendStateCreateFlags                          = ^VkPipelineColorBlendStateCreateFlags;

  278.   PPVkPipelineColorBlendStateCreateFlags                         = ^PVkPipelineColorBlendStateCreateFlags;

  279.   PVkPipelineCreateFlags                                         = ^VkPipelineCreateFlags;

  280.   PPVkPipelineCreateFlags                                        = ^PVkPipelineCreateFlags;

  281.   PVkPipelineDepthStencilStateCreateFlags                        = ^VkPipelineDepthStencilStateCreateFlags;

  282.   PPVkPipelineDepthStencilStateCreateFlags                       = ^PVkPipelineDepthStencilStateCreateFlags;

  283.   PVkPipelineDynamicStateCreateFlags                             = ^VkPipelineDynamicStateCreateFlags;

  284.   PPVkPipelineDynamicStateCreateFlags                            = ^PVkPipelineDynamicStateCreateFlags;

  285.   PVkPipelineInputAssemblyStateCreateFlags                       = ^VkPipelineInputAssemblyStateCreateFlags;

  286.   PPVkPipelineInputAssemblyStateCreateFlags                      = ^PVkPipelineInputAssemblyStateCreateFlags;

  287.   PVkPipelineLayoutCreateFlags                                   = ^VkPipelineLayoutCreateFlags;

  288.   PPVkPipelineLayoutCreateFlags                                  = ^PVkPipelineLayoutCreateFlags;

  289.   PVkPipelineMultisampleStateCreateFlags                         = ^VkPipelineMultisampleStateCreateFlags;

  290.   PPVkPipelineMultisampleStateCreateFlags                        = ^PVkPipelineMultisampleStateCreateFlags;

  291.   PVkPipelineRasterizationStateCreateFlags                       = ^VkPipelineRasterizationStateCreateFlags;

  292.   PPVkPipelineRasterizationStateCreateFlags                      = ^PVkPipelineRasterizationStateCreateFlags;

  293.   PVkPipelineShaderStageCreateFlags                              = ^VkPipelineShaderStageCreateFlags;

  294.   PPVkPipelineShaderStageCreateFlags                             = ^PVkPipelineShaderStageCreateFlags;

  295.   PVkPipelineStageFlags                                          = ^VkPipelineStageFlags;

  296.   PPVkPipelineStageFlags                                         = ^PVkPipelineStageFlags;

  297.   PVkPipelineTessellationStateCreateFlags                        = ^VkPipelineTessellationStateCreateFlags;

  298.   PPVkPipelineTessellationStateCreateFlags                       = ^PVkPipelineTessellationStateCreateFlags;

  299.   PVkPipelineVertexInputStateCreateFlags                         = ^VkPipelineVertexInputStateCreateFlags;

  300.   PPVkPipelineVertexInputStateCreateFlags                        = ^PVkPipelineVertexInputStateCreateFlags;

  301.   PVkPipelineViewportStateCreateFlags                            = ^VkPipelineViewportStateCreateFlags;

  302.   PPVkPipelineViewportStateCreateFlags                           = ^PVkPipelineViewportStateCreateFlags;

  303.   PVkQueryControlFlags                                           = ^VkQueryControlFlags;

  304.   PPVkQueryControlFlags                                          = ^PVkQueryControlFlags;

  305.   PVkQueryPipelineStatisticFlags                                 = ^VkQueryPipelineStatisticFlags;

  306.   PPVkQueryPipelineStatisticFlags                                = ^PVkQueryPipelineStatisticFlags;

  307.   PVkQueryPoolCreateFlags                                        = ^VkQueryPoolCreateFlags;

  308.   PPVkQueryPoolCreateFlags                                       = ^PVkQueryPoolCreateFlags;

  309.   PVkQueryResultFlags                                            = ^VkQueryResultFlags;

  310.   PPVkQueryResultFlags                                           = ^PVkQueryResultFlags;

  311.   PVkQueueFlags                                                  = ^VkQueueFlags;

  312.   PPVkQueueFlags                                                 = ^PVkQueueFlags;

  313.   PVkRenderPassCreateFlags                                       = ^VkRenderPassCreateFlags;

  314.   PPVkRenderPassCreateFlags                                      = ^PVkRenderPassCreateFlags;

  315.   PVkSampleCountFlags                                            = ^VkSampleCountFlags;

  316.   PPVkSampleCountFlags                                           = ^PVkSampleCountFlags;

  317.   PVkSamplerCreateFlags                                          = ^VkSamplerCreateFlags;

  318.   PPVkSamplerCreateFlags                                         = ^PVkSamplerCreateFlags;

  319.   PVkSemaphoreCreateFlags                                        = ^VkSemaphoreCreateFlags;

  320.   PPVkSemaphoreCreateFlags                                       = ^PVkSemaphoreCreateFlags;

  321.   PVkShaderModuleCreateFlags                                     = ^VkShaderModuleCreateFlags;

  322.   PPVkShaderModuleCreateFlags                                    = ^PVkShaderModuleCreateFlags;

  323.   PVkShaderStageFlags                                            = ^VkShaderStageFlags;

  324.   PPVkShaderStageFlags                                           = ^PVkShaderStageFlags;

  325.   PVkSparseImageFormatFlags                                      = ^VkSparseImageFormatFlags;

  326.   PPVkSparseImageFormatFlags                                     = ^PVkSparseImageFormatFlags;

  327.   PVkSparseMemoryBindFlags                                       = ^VkSparseMemoryBindFlags;

  328.   PPVkSparseMemoryBindFlags                                      = ^PVkSparseMemoryBindFlags;

  329.   PVkStencilFaceFlags                                            = ^VkStencilFaceFlags;

  330.   PPVkStencilFaceFlags                                           = ^PVkStencilFaceFlags;

  331.   PVkSubpassDescriptionFlags                                     = ^VkSubpassDescriptionFlags;

  332.   PPVkSubpassDescriptionFlags                                    = ^PVkSubpassDescriptionFlags;

  333. 

  334. type { handles }

  335.   VkBuffer                                                       = VkHandle;

  336.   VkBufferView                                                   = VkHandle;

  337.   VkCommandBuffer                                                = VkHandle;

  338.   VkCommandPool                                                  = VkHandle;

  339.   VkDescriptorPool                                               = VkHandle;

  340.   VkDescriptorSet                                                = VkHandle;

  341.   VkDescriptorSetLayout                                          = VkHandle;

  342.   VkDevice                                                       = VkHandle;

  343.   VkDeviceMemory                                                 = VkHandle;

  344.   VkEvent                                                        = VkHandle;

  345.   VkFence                                                        = VkHandle;

  346.   VkFramebuffer                                                  = VkHandle;

  347.   VkImage                                                        = VkHandle;

  348.   VkImageView                                                    = VkHandle;

  349.   VkInstance                                                     = VkHandle;

  350.   VkPhysicalDevice                                               = VkHandle;

  351.   VkPipeline                                                     = VkHandle;

  352.   VkPipelineCache                                                = VkHandle;

  353.   VkPipelineLayout                                               = VkHandle;

  354.   VkQueryPool                                                    = VkHandle;

  355.   VkQueue                                                        = VkHandle;

  356.   VkRenderPass                                                   = VkHandle;

  357.   VkSampler                                                      = VkHandle;

  358.   VkSemaphore                                                    = VkHandle;

  359.   VkShaderModule                                                 = VkHandle;

  360. 

  361. type { handle pointers }

  362.   PVkBuffer                                                      = ^VkBuffer;

  363.   PPVkBuffer                                                     = ^PVkBuffer;

  364.   PVkBufferView                                                  = ^VkBufferView;

  365.   PPVkBufferView                                                 = ^PVkBufferView;

  366.   PVkCommandBuffer                                               = ^VkCommandBuffer;

  367.   PPVkCommandBuffer                                              = ^PVkCommandBuffer;

  368.   PVkCommandPool                                                 = ^VkCommandPool;

  369.   PPVkCommandPool                                                = ^PVkCommandPool;

  370.   PVkDescriptorPool                                              = ^VkDescriptorPool;

  371.   PPVkDescriptorPool                                             = ^PVkDescriptorPool;

  372.   PVkDescriptorSet                                               = ^VkDescriptorSet;

  373.   PPVkDescriptorSet                                              = ^PVkDescriptorSet;

  374.   PVkDescriptorSetLayout                                         = ^VkDescriptorSetLayout;

  375.   PPVkDescriptorSetLayout                                        = ^PVkDescriptorSetLayout;

  376.   PVkDevice                                                      = ^VkDevice;

  377.   PPVkDevice                                                     = ^PVkDevice;

  378.   PVkDeviceMemory                                                = ^VkDeviceMemory;

  379.   PPVkDeviceMemory                                               = ^PVkDeviceMemory;

  380.   PVkEvent                                                       = ^VkEvent;

  381.   PPVkEvent                                                      = ^PVkEvent;

  382.   PVkFence                                                       = ^VkFence;

  383.   PPVkFence                                                      = ^PVkFence;

  384.   PVkFramebuffer                                                 = ^VkFramebuffer;

  385.   PPVkFramebuffer                                                = ^PVkFramebuffer;

  386.   PVkImage                                                       = ^VkImage;

  387.   PPVkImage                                                      = ^PVkImage;

  388.   PVkImageView                                                   = ^VkImageView;

  389.   PPVkImageView                                                  = ^PVkImageView;

  390.   PVkInstance                                                    = ^VkInstance;

  391.   PPVkInstance                                                   = ^PVkInstance;

  392.   PVkPhysicalDevice                                              = ^VkPhysicalDevice;

  393.   PPVkPhysicalDevice                                             = ^PVkPhysicalDevice;

  394.   PVkPipeline                                                    = ^VkPipeline;

  395.   PPVkPipeline                                                   = ^PVkPipeline;

  396.   PVkPipelineCache                                               = ^VkPipelineCache;

  397.   PPVkPipelineCache                                              = ^PVkPipelineCache;

  398.   PVkPipelineLayout                                              = ^VkPipelineLayout;

  399.   PPVkPipelineLayout                                             = ^PVkPipelineLayout;

  400.   PVkQueryPool                                                   = ^VkQueryPool;

  401.   PPVkQueryPool                                                  = ^PVkQueryPool;

  402.   PVkQueue                                                       = ^VkQueue;

  403.   PPVkQueue                                                      = ^PVkQueue;

  404.   PVkRenderPass                                                  = ^VkRenderPass;

  405.   PPVkRenderPass                                                 = ^PVkRenderPass;

  406.   PVkSampler                                                     = ^VkSampler;

  407.   PPVkSampler                                                    = ^PVkSampler;

  408.   PVkSemaphore                                                   = ^VkSemaphore;

  409.   PPVkSemaphore                                                  = ^PVkSemaphore;

  410.   PVkShaderModule                                                = ^VkShaderModule;

  411.   PPVkShaderModule                                               = ^PVkShaderModule;

  412. 

  413. type { enums }

  414.   TVkAttachmentLoadOp = (

  415.     VK_ATTACHMENT_LOAD_OP_LOAD                                   = 0,

  416.     VK_ATTACHMENT_LOAD_OP_CLEAR                                  = 1,

  417.     VK_ATTACHMENT_LOAD_OP_DONT_CARE                              = 2

  418.   );

  419.   PVkAttachmentLoadOp = ^TVkAttachmentLoadOp;

  420. 

  421.   TVkAttachmentStoreOp = (

  422.     VK_ATTACHMENT_STORE_OP_STORE                                 = 0,

  423.     VK_ATTACHMENT_STORE_OP_DONT_CARE                             = 1

  424.   );

  425.   PVkAttachmentStoreOp = ^TVkAttachmentStoreOp;

  426. 

  427.   TVkBlendFactor = (

  428.     VK_BLEND_FACTOR_ZERO                                         = 0,

  429.     VK_BLEND_FACTOR_ONE                                          = 1,

  430.     VK_BLEND_FACTOR_SRC_COLOR                                    = 2,

  431.     VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR                          = 3,

  432.     VK_BLEND_FACTOR_DST_COLOR                                    = 4,

  433.     VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR                          = 5,

  434.     VK_BLEND_FACTOR_SRC_ALPHA                                    = 6,

  435.     VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA                          = 7,

  436.     VK_BLEND_FACTOR_DST_ALPHA                                    = 8,

  437.     VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA                          = 9,

  438.     VK_BLEND_FACTOR_CONSTANT_COLOR                               = 10,

  439.     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR                     = 11,

  440.     VK_BLEND_FACTOR_CONSTANT_ALPHA                               = 12,

  441.     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA                     = 13,

  442.     VK_BLEND_FACTOR_SRC_ALPHA_SATURATE                           = 14,

  443.     VK_BLEND_FACTOR_SRC1_COLOR                                   = 15,

  444.     VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR                         = 16,

  445.     VK_BLEND_FACTOR_SRC1_ALPHA                                   = 17,

  446.     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA                         = 18

  447.   );

  448.   PVkBlendFactor = ^TVkBlendFactor;

  449. 

  450.   TVkBlendOp = (

  451.     VK_BLEND_OP_ADD                                              = 0,

  452.     VK_BLEND_OP_SUBTRACT                                         = 1,

  453.     VK_BLEND_OP_REVERSE_SUBTRACT                                 = 2,

  454.     VK_BLEND_OP_MIN                                              = 3,

  455.     VK_BLEND_OP_MAX                                              = 4

  456.   );

  457.   PVkBlendOp = ^TVkBlendOp;

  458. 

  459.   TVkBorderColor = (

  460.     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK                      = 0,

  461.     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK                        = 1,

  462.     VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK                           = 2,

  463.     VK_BORDER_COLOR_INT_OPAQUE_BLACK                             = 3,

  464.     VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE                           = 4,

  465.     VK_BORDER_COLOR_INT_OPAQUE_WHITE                             = 5

  466.   );

  467.   PVkBorderColor = ^TVkBorderColor;

  468. 

  469.   TVkCommandBufferLevel = (

  470.     VK_COMMAND_BUFFER_LEVEL_PRIMARY                              = 0,

  471.     VK_COMMAND_BUFFER_LEVEL_SECONDARY                            = 1

  472.   );

  473.   PVkCommandBufferLevel = ^TVkCommandBufferLevel;

  474. 

  475.   TVkCompareOp = (

  476.     VK_COMPARE_OP_NEVER                                          = 0,

  477.     VK_COMPARE_OP_LESS                                           = 1,

  478.     VK_COMPARE_OP_EQUAL                                          = 2,

  479.     VK_COMPARE_OP_LESS_OR_EQUAL                                  = 3,

  480.     VK_COMPARE_OP_GREATER                                        = 4,

  481.     VK_COMPARE_OP_NOT_EQUAL                                      = 5,

  482.     VK_COMPARE_OP_GREATER_OR_EQUAL                               = 6,

  483.     VK_COMPARE_OP_ALWAYS                                         = 7

  484.   );

  485.   PVkCompareOp = ^TVkCompareOp;

  486. 

  487.   TVkComponentSwizzle = (

  488.     VK_COMPONENT_SWIZZLE_IDENTITY                                = 0,

  489.     VK_COMPONENT_SWIZZLE_ZERO                                    = 1,

  490.     VK_COMPONENT_SWIZZLE_ONE                                     = 2,

  491.     VK_COMPONENT_SWIZZLE_R                                       = 3,

  492.     VK_COMPONENT_SWIZZLE_G                                       = 4,

  493.     VK_COMPONENT_SWIZZLE_B                                       = 5,

  494.     VK_COMPONENT_SWIZZLE_A                                       = 6

  495.   );

  496.   PVkComponentSwizzle = ^TVkComponentSwizzle;

  497. 

  498.   TVkDescriptorType = (

  499.     VK_DESCRIPTOR_TYPE_SAMPLER                                   = 0,

  500.     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER                    = 1,

  501.     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE                             = 2,

  502.     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE                             = 3,

  503.     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER                      = 4,

  504.     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER                      = 5,

  505.     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER                            = 6,

  506.     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER                            = 7,

  507.     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC                    = 8,

  508.     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC                    = 9,

  509.     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT                          = 10

  510.   );

  511.   PVkDescriptorType = ^TVkDescriptorType;

  512. 

  513.   TVkDynamicState = (

  514.     VK_DYNAMIC_STATE_VIEWPORT                                    = 0,

  515.     VK_DYNAMIC_STATE_SCISSOR                                     = 1,

  516.     VK_DYNAMIC_STATE_LINE_WIDTH                                  = 2,

  517.     VK_DYNAMIC_STATE_DEPTH_BIAS                                  = 3,

  518.     VK_DYNAMIC_STATE_BLEND_CONSTANTS                             = 4,

  519.     VK_DYNAMIC_STATE_DEPTH_BOUNDS                                = 5,

  520.     VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK                        = 6,

  521.     VK_DYNAMIC_STATE_STENCIL_WRITE_MASK                          = 7,

  522.     VK_DYNAMIC_STATE_STENCIL_REFERENCE                           = 8

  523.   );

  524.   PVkDynamicState = ^TVkDynamicState;

  525. 

  526.   TVkFilter = (

  527.     VK_FILTER_NEAREST                                            = 0,

  528.     VK_FILTER_LINEAR                                             = 1

  529.   );

  530.   PVkFilter = ^TVkFilter;

  531. 

  532.   TVkFormat = (

  533.     VK_FORMAT_UNDEFINED                                          = 0,

  534.     VK_FORMAT_R4G4_UNORM_PACK8                                   = 1,

  535.     VK_FORMAT_R4G4B4A4_UNORM_PACK16                              = 2,

  536.     VK_FORMAT_B4G4R4A4_UNORM_PACK16                              = 3,

  537.     VK_FORMAT_R5G6B5_UNORM_PACK16                                = 4,

  538.     VK_FORMAT_B5G6R5_UNORM_PACK16                                = 5,

  539.     VK_FORMAT_R5G5B5A1_UNORM_PACK16                              = 6,

  540.     VK_FORMAT_B5G5R5A1_UNORM_PACK16                              = 7,

  541.     VK_FORMAT_A1R5G5B5_UNORM_PACK16                              = 8,

  542.     VK_FORMAT_R8_UNORM                                           = 9,

  543.     VK_FORMAT_R8_SNORM                                           = 10,

  544.     VK_FORMAT_R8_USCALED                                         = 11,

  545.     VK_FORMAT_R8_SSCALED                                         = 12,

  546.     VK_FORMAT_R8_UINT                                            = 13,

  547.     VK_FORMAT_R8_SINT                                            = 14,

  548.     VK_FORMAT_R8_SRGB                                            = 15,

  549.     VK_FORMAT_R8G8_UNORM                                         = 16,

  550.     VK_FORMAT_R8G8_SNORM                                         = 17,

  551.     VK_FORMAT_R8G8_USCALED                                       = 18,

  552.     VK_FORMAT_R8G8_SSCALED                                       = 19,

  553.     VK_FORMAT_R8G8_UINT                                          = 20,

  554.     VK_FORMAT_R8G8_SINT                                          = 21,

  555.     VK_FORMAT_R8G8_SRGB                                          = 22,

  556.     VK_FORMAT_R8G8B8_UNORM                                       = 23,

  557.     VK_FORMAT_R8G8B8_SNORM                                       = 24,

  558.     VK_FORMAT_R8G8B8_USCALED                                     = 25,

  559.     VK_FORMAT_R8G8B8_SSCALED                                     = 26,

  560.     VK_FORMAT_R8G8B8_UINT                                        = 27,

  561.     VK_FORMAT_R8G8B8_SINT                                        = 28,

  562.     VK_FORMAT_R8G8B8_SRGB                                        = 29,

  563.     VK_FORMAT_B8G8R8_UNORM                                       = 30,

  564.     VK_FORMAT_B8G8R8_SNORM                                       = 31,

  565.     VK_FORMAT_B8G8R8_USCALED                                     = 32,

  566.     VK_FORMAT_B8G8R8_SSCALED                                     = 33,

  567.     VK_FORMAT_B8G8R8_UINT                                        = 34,

  568.     VK_FORMAT_B8G8R8_SINT                                        = 35,

  569.     VK_FORMAT_B8G8R8_SRGB                                        = 36,

  570.     VK_FORMAT_R8G8B8A8_UNORM                                     = 37,

  571.     VK_FORMAT_R8G8B8A8_SNORM                                     = 38,

  572.     VK_FORMAT_R8G8B8A8_USCALED                                   = 39,

  573.     VK_FORMAT_R8G8B8A8_SSCALED                                   = 40,

  574.     VK_FORMAT_R8G8B8A8_UINT                                      = 41,

  575.     VK_FORMAT_R8G8B8A8_SINT                                      = 42,

  576.     VK_FORMAT_R8G8B8A8_SRGB                                      = 43,

  577.     VK_FORMAT_B8G8R8A8_UNORM                                     = 44,

  578.     VK_FORMAT_B8G8R8A8_SNORM                                     = 45,

  579.     VK_FORMAT_B8G8R8A8_USCALED                                   = 46,

  580.     VK_FORMAT_B8G8R8A8_SSCALED                                   = 47,

  581.     VK_FORMAT_B8G8R8A8_UINT                                      = 48,

  582.     VK_FORMAT_B8G8R8A8_SINT                                      = 49,

  583.     VK_FORMAT_B8G8R8A8_SRGB                                      = 50,

  584.     VK_FORMAT_A8B8G8R8_UNORM_PACK32                              = 51,

  585.     VK_FORMAT_A8B8G8R8_SNORM_PACK32                              = 52,

  586.     VK_FORMAT_A8B8G8R8_USCALED_PACK32                            = 53,

  587.     VK_FORMAT_A8B8G8R8_SSCALED_PACK32                            = 54,

  588.     VK_FORMAT_A8B8G8R8_UINT_PACK32                               = 55,

  589.     VK_FORMAT_A8B8G8R8_SINT_PACK32                               = 56,

  590.     VK_FORMAT_A8B8G8R8_SRGB_PACK32                               = 57,

  591.     VK_FORMAT_A2R10G10B10_UNORM_PACK32                           = 58,

  592.     VK_FORMAT_A2R10G10B10_SNORM_PACK32                           = 59,

  593.     VK_FORMAT_A2R10G10B10_USCALED_PACK32                         = 60,

  594.     VK_FORMAT_A2R10G10B10_SSCALED_PACK32                         = 61,

  595.     VK_FORMAT_A2R10G10B10_UINT_PACK32                            = 62,

  596.     VK_FORMAT_A2R10G10B10_SINT_PACK32                            = 63,

  597.     VK_FORMAT_A2B10G10R10_UNORM_PACK32                           = 64,

  598.     VK_FORMAT_A2B10G10R10_SNORM_PACK32                           = 65,

  599.     VK_FORMAT_A2B10G10R10_USCALED_PACK32                         = 66,

  600.     VK_FORMAT_A2B10G10R10_SSCALED_PACK32                         = 67,

  601.     VK_FORMAT_A2B10G10R10_UINT_PACK32                            = 68,

  602.     VK_FORMAT_A2B10G10R10_SINT_PACK32                            = 69,

  603.     VK_FORMAT_R16_UNORM                                          = 70,

  604.     VK_FORMAT_R16_SNORM                                          = 71,

  605.     VK_FORMAT_R16_USCALED                                        = 72,

  606.     VK_FORMAT_R16_SSCALED                                        = 73,

  607.     VK_FORMAT_R16_UINT                                           = 74,

  608.     VK_FORMAT_R16_SINT                                           = 75,

  609.     VK_FORMAT_R16_SFLOAT                                         = 76,

  610.     VK_FORMAT_R16G16_UNORM                                       = 77,

  611.     VK_FORMAT_R16G16_SNORM                                       = 78,

  612.     VK_FORMAT_R16G16_USCALED                                     = 79,

  613.     VK_FORMAT_R16G16_SSCALED                                     = 80,

  614.     VK_FORMAT_R16G16_UINT                                        = 81,

  615.     VK_FORMAT_R16G16_SINT                                        = 82,

  616.     VK_FORMAT_R16G16_SFLOAT                                      = 83,

  617.     VK_FORMAT_R16G16B16_UNORM                                    = 84,

  618.     VK_FORMAT_R16G16B16_SNORM                                    = 85,

  619.     VK_FORMAT_R16G16B16_USCALED                                  = 86,

  620.     VK_FORMAT_R16G16B16_SSCALED                                  = 87,

  621.     VK_FORMAT_R16G16B16_UINT                                     = 88,

  622.     VK_FORMAT_R16G16B16_SINT                                     = 89,

  623.     VK_FORMAT_R16G16B16_SFLOAT                                   = 90,

  624.     VK_FORMAT_R16G16B16A16_UNORM                                 = 91,

  625.     VK_FORMAT_R16G16B16A16_SNORM                                 = 92,

  626.     VK_FORMAT_R16G16B16A16_USCALED                               = 93,

  627.     VK_FORMAT_R16G16B16A16_SSCALED                               = 94,

  628.     VK_FORMAT_R16G16B16A16_UINT                                  = 95,

  629.     VK_FORMAT_R16G16B16A16_SINT                                  = 96,

  630.     VK_FORMAT_R16G16B16A16_SFLOAT                                = 97,

  631.     VK_FORMAT_R32_UINT                                           = 98,

  632.     VK_FORMAT_R32_SINT                                           = 99,

  633.     VK_FORMAT_R32_SFLOAT                                         = 100,

  634.     VK_FORMAT_R32G32_UINT                                        = 101,

  635.     VK_FORMAT_R32G32_SINT                                        = 102,

  636.     VK_FORMAT_R32G32_SFLOAT                                      = 103,

  637.     VK_FORMAT_R32G32B32_UINT                                     = 104,

  638.     VK_FORMAT_R32G32B32_SINT                                     = 105,

  639.     VK_FORMAT_R32G32B32_SFLOAT                                   = 106,

  640.     VK_FORMAT_R32G32B32A32_UINT                                  = 107,

  641.     VK_FORMAT_R32G32B32A32_SINT                                  = 108,

  642.     VK_FORMAT_R32G32B32A32_SFLOAT                                = 109,

  643.     VK_FORMAT_R64_UINT                                           = 110,

  644.     VK_FORMAT_R64_SINT                                           = 111,

  645.     VK_FORMAT_R64_SFLOAT                                         = 112,

  646.     VK_FORMAT_R64G64_UINT                                        = 113,

  647.     VK_FORMAT_R64G64_SINT                                        = 114,

  648.     VK_FORMAT_R64G64_SFLOAT                                      = 115,

  649.     VK_FORMAT_R64G64B64_UINT                                     = 116,

  650.     VK_FORMAT_R64G64B64_SINT                                     = 117,

  651.     VK_FORMAT_R64G64B64_SFLOAT                                   = 118,

  652.     VK_FORMAT_R64G64B64A64_UINT                                  = 119,

  653.     VK_FORMAT_R64G64B64A64_SINT                                  = 120,

  654.     VK_FORMAT_R64G64B64A64_SFLOAT                                = 121,

  655.     VK_FORMAT_B10G11R11_UFLOAT_PACK32                            = 122,

  656.     VK_FORMAT_E5B9G9R9_UFLOAT_PACK32                             = 123,

  657.     VK_FORMAT_D16_UNORM                                          = 124,

  658.     VK_FORMAT_X8_D24_UNORM_PACK32                                = 125,

  659.     VK_FORMAT_D32_SFLOAT                                         = 126,

  660.     VK_FORMAT_S8_UINT                                            = 127,

  661.     VK_FORMAT_D16_UNORM_S8_UINT                                  = 128,

  662.     VK_FORMAT_D24_UNORM_S8_UINT                                  = 129,

  663.     VK_FORMAT_D32_SFLOAT_S8_UINT                                 = 130,

  664.     VK_FORMAT_BC1_RGB_UNORM_BLOCK                                = 131,

  665.     VK_FORMAT_BC1_RGB_SRGB_BLOCK                                 = 132,

  666.     VK_FORMAT_BC1_RGBA_UNORM_BLOCK                               = 133,

  667.     VK_FORMAT_BC1_RGBA_SRGB_BLOCK                                = 134,

  668.     VK_FORMAT_BC2_UNORM_BLOCK                                    = 135,

  669.     VK_FORMAT_BC2_SRGB_BLOCK                                     = 136,

  670.     VK_FORMAT_BC3_UNORM_BLOCK                                    = 137,

  671.     VK_FORMAT_BC3_SRGB_BLOCK                                     = 138,

  672.     VK_FORMAT_BC4_UNORM_BLOCK                                    = 139,

  673.     VK_FORMAT_BC4_SNORM_BLOCK                                    = 140,

  674.     VK_FORMAT_BC5_UNORM_BLOCK                                    = 141,

  675.     VK_FORMAT_BC5_SNORM_BLOCK                                    = 142,

  676.     VK_FORMAT_BC6H_UFLOAT_BLOCK                                  = 143,

  677.     VK_FORMAT_BC6H_SFLOAT_BLOCK                                  = 144,

  678.     VK_FORMAT_BC7_UNORM_BLOCK                                    = 145,

  679.     VK_FORMAT_BC7_SRGB_BLOCK                                     = 146,

  680.     VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK                            = 147,

  681.     VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK                             = 148,

  682.     VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK                          = 149,

  683.     VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK                           = 150,

  684.     VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK                          = 151,

  685.     VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK                           = 152,

  686.     VK_FORMAT_EAC_R11_UNORM_BLOCK                                = 153,

  687.     VK_FORMAT_EAC_R11_SNORM_BLOCK                                = 154,

  688.     VK_FORMAT_EAC_R11G11_UNORM_BLOCK                             = 155,

  689.     VK_FORMAT_EAC_R11G11_SNORM_BLOCK                             = 156,

  690.     VK_FORMAT_ASTC_4x4_UNORM_BLOCK                               = 157,

  691.     VK_FORMAT_ASTC_4x4_SRGB_BLOCK                                = 158,

  692.     VK_FORMAT_ASTC_5x4_UNORM_BLOCK                               = 159,

  693.     VK_FORMAT_ASTC_5x4_SRGB_BLOCK                                = 160,

  694.     VK_FORMAT_ASTC_5x5_UNORM_BLOCK                               = 161,

  695.     VK_FORMAT_ASTC_5x5_SRGB_BLOCK                                = 162,

  696.     VK_FORMAT_ASTC_6x5_UNORM_BLOCK                               = 163,

  697.     VK_FORMAT_ASTC_6x5_SRGB_BLOCK                                = 164,

  698.     VK_FORMAT_ASTC_6x6_UNORM_BLOCK                               = 165,

  699.     VK_FORMAT_ASTC_6x6_SRGB_BLOCK                                = 166,

  700.     VK_FORMAT_ASTC_8x5_UNORM_BLOCK                               = 167,

  701.     VK_FORMAT_ASTC_8x5_SRGB_BLOCK                                = 168,

  702.     VK_FORMAT_ASTC_8x6_UNORM_BLOCK                               = 169,

  703.     VK_FORMAT_ASTC_8x6_SRGB_BLOCK                                = 170,

  704.     VK_FORMAT_ASTC_8x8_UNORM_BLOCK                               = 171,

  705.     VK_FORMAT_ASTC_8x8_SRGB_BLOCK                                = 172,

  706.     VK_FORMAT_ASTC_10x5_UNORM_BLOCK                              = 173,

  707.     VK_FORMAT_ASTC_10x5_SRGB_BLOCK                               = 174,

  708.     VK_FORMAT_ASTC_10x6_UNORM_BLOCK                              = 175,

  709.     VK_FORMAT_ASTC_10x6_SRGB_BLOCK                               = 176,

  710.     VK_FORMAT_ASTC_10x8_UNORM_BLOCK                              = 177,

  711.     VK_FORMAT_ASTC_10x8_SRGB_BLOCK                               = 178,

  712.     VK_FORMAT_ASTC_10x10_UNORM_BLOCK                             = 179,

  713.     VK_FORMAT_ASTC_10x10_SRGB_BLOCK                              = 180,

  714.     VK_FORMAT_ASTC_12x10_UNORM_BLOCK                             = 181,

  715.     VK_FORMAT_ASTC_12x10_SRGB_BLOCK                              = 182,

  716.     VK_FORMAT_ASTC_12x12_UNORM_BLOCK                             = 183,

  717.     VK_FORMAT_ASTC_12x12_SRGB_BLOCK                              = 184

  718.   );

  719.   PVkFormat = ^TVkFormat;

  720. 

  721.   TVkFrontFace = (

  722.     VK_FRONT_FACE_COUNTER_CLOCKWISE                              = 0,

  723.     VK_FRONT_FACE_CLOCKWISE                                      = 1

  724.   );

  725.   PVkFrontFace = ^TVkFrontFace;

  726. 

  727.   TVkImageLayout = (

  728.     VK_IMAGE_LAYOUT_UNDEFINED                                    = 0,

  729.     VK_IMAGE_LAYOUT_GENERAL                                      = 1,

  730.     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                     = 2,

  731.     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL             = 3,

  732.     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL              = 4,

  733.     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL                     = 5,

  734.     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL                         = 6,

  735.     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL                         = 7,

  736.     VK_IMAGE_LAYOUT_PREINITIALIZED                               = 8

  737.   );

  738.   PVkImageLayout = ^TVkImageLayout;

  739. 

  740.   TVkImageTiling = (

  741.     VK_IMAGE_TILING_OPTIMAL                                      = 0,

  742.     VK_IMAGE_TILING_LINEAR                                       = 1

  743.   );

  744.   PVkImageTiling = ^TVkImageTiling;

  745. 

  746.   TVkImageType = (

  747.     VK_IMAGE_TYPE_1D                                             = 0,

  748.     VK_IMAGE_TYPE_2D                                             = 1,

  749.     VK_IMAGE_TYPE_3D                                             = 2

  750.   );

  751.   PVkImageType = ^TVkImageType;

  752. 

  753.   TVkImageViewType = (

  754.     VK_IMAGE_VIEW_TYPE_1D                                        = 0,

  755.     VK_IMAGE_VIEW_TYPE_2D                                        = 1,

  756.     VK_IMAGE_VIEW_TYPE_3D                                        = 2,

  757.     VK_IMAGE_VIEW_TYPE_CUBE                                      = 3,

  758.     VK_IMAGE_VIEW_TYPE_1D_ARRAY                                  = 4,

  759.     VK_IMAGE_VIEW_TYPE_2D_ARRAY                                  = 5,

  760.     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY                                = 6

  761.   );

  762.   PVkImageViewType = ^TVkImageViewType;

  763. 

  764.   TVkIndexType = (

  765.     VK_INDEX_TYPE_UINT16                                         = 0,

  766.     VK_INDEX_TYPE_UINT32                                         = 1

  767.   );

  768.   PVkIndexType = ^TVkIndexType;

  769. 

  770.   TVkInternalAllocationType = (

  771.     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE                       = 0

  772.   );

  773.   PVkInternalAllocationType = ^TVkInternalAllocationType;

  774. 

  775.   TVkLogicOp = (

  776.     VK_LOGIC_OP_CLEAR                                            = 0,

  777.     VK_LOGIC_OP_AND                                              = 1,

  778.     VK_LOGIC_OP_AND_REVERSE                                      = 2,

  779.     VK_LOGIC_OP_COPY                                             = 3,

  780.     VK_LOGIC_OP_AND_INVERTED                                     = 4,

  781.     VK_LOGIC_OP_NO_OP                                            = 5,

  782.     VK_LOGIC_OP_XOR                                              = 6,

  783.     VK_LOGIC_OP_OR                                               = 7,

  784.     VK_LOGIC_OP_NOR                                              = 8,

  785.     VK_LOGIC_OP_EQUIVALENT                                       = 9,

  786.     VK_LOGIC_OP_INVERT                                           = 10,

  787.     VK_LOGIC_OP_OR_REVERSE                                       = 11,

  788.     VK_LOGIC_OP_COPY_INVERTED                                    = 12,

  789.     VK_LOGIC_OP_OR_INVERTED                                      = 13,

  790.     VK_LOGIC_OP_NAND                                             = 14,

  791.     VK_LOGIC_OP_SET                                              = 15

  792.   );

  793.   PVkLogicOp = ^TVkLogicOp;

  794. 

  795.   TVkPhysicalDeviceType = (

  796.     VK_PHYSICAL_DEVICE_TYPE_OTHER                                = 0,

  797.     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU                       = 1,

  798.     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU                         = 2,

  799.     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU                          = 3,

  800.     VK_PHYSICAL_DEVICE_TYPE_CPU                                  = 4

  801.   );

  802.   PVkPhysicalDeviceType = ^TVkPhysicalDeviceType;

  803. 

  804.   TVkPipelineBindPoint = (

  805.     VK_PIPELINE_BIND_POINT_GRAPHICS                              = 0,

  806.     VK_PIPELINE_BIND_POINT_COMPUTE                               = 1

  807.   );

  808.   PVkPipelineBindPoint = ^TVkPipelineBindPoint;

  809. 

  810.   TVkPipelineCacheHeaderVersion = (

  811.     VK_PIPELINE_CACHE_HEADER_VERSION_ONE                         = 1

  812.   );

  813.   PVkPipelineCacheHeaderVersion = ^TVkPipelineCacheHeaderVersion;

  814. 

  815.   TVkPipelineStageFlagBits = (

  816.     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT                            = (1 shl 0),

  817.     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT                          = (1 shl 1),

  818.     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT                           = (1 shl 2),

  819.     VK_PIPELINE_STAGE_VERTEX_SHADER_BIT                          = (1 shl 3),

  820.     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT            = (1 shl 4),

  821.     VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT         = (1 shl 5),

  822.     VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT                        = (1 shl 6),

  823.     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT                        = (1 shl 7),

  824.     VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT                   = (1 shl 8),

  825.     VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT                    = (1 shl 9),

  826.     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT                = (1 shl 10),

  827.     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT                         = (1 shl 11),

  828.     VK_PIPELINE_STAGE_TRANSFER_BIT                               = (1 shl 12),

  829.     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT                         = (1 shl 13),

  830.     VK_PIPELINE_STAGE_HOST_BIT                                   = (1 shl 14),

  831.     VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT                           = (1 shl 15),

  832.     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT                           = (1 shl 16)

  833.   );

  834.   PVkPipelineStageFlagBits = ^TVkPipelineStageFlagBits;

  835. 

  836.   TVkPolygonMode = (

  837.     VK_POLYGON_MODE_FILL                                         = 0,

  838.     VK_POLYGON_MODE_LINE                                         = 1,

  839.     VK_POLYGON_MODE_POINT                                        = 2

  840.   );

  841.   PVkPolygonMode = ^TVkPolygonMode;

  842. 

  843.   TVkPrimitiveTopology = (

  844.     VK_PRIMITIVE_TOPOLOGY_POINT_LIST                             = 0,

  845.     VK_PRIMITIVE_TOPOLOGY_LINE_LIST                              = 1,

  846.     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP                             = 2,

  847.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST                          = 3,

  848.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP                         = 4,

  849.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN                           = 5,

  850.     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY               = 6,

  851.     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY              = 7,

  852.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY           = 8,

  853.     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY          = 9,

  854.     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST                             = 10

  855.   );

  856.   PVkPrimitiveTopology = ^TVkPrimitiveTopology;

  857. 

  858.   TVkQueryType = (

  859.     VK_QUERY_TYPE_OCCLUSION                                      = 0,

  860.     VK_QUERY_TYPE_PIPELINE_STATISTICS                            = 1,

  861.     VK_QUERY_TYPE_TIMESTAMP                                      = 2

  862.   );

  863.   PVkQueryType = ^TVkQueryType;

  864. 

  865.   TVkResult = (

  866.     VK_SUCCESS                                                   = 0,

  867.     VK_NOT_READY                                                 = 1,

  868.     VK_TIMEOUT                                                   = 2,

  869.     VK_EVENT_SET                                                 = 3,

  870.     VK_EVENT_RESET                                               = 4,

  871.     VK_INCOMPLETE                                                = 5,

  872.     VK_ERROR_OUT_OF_HOST_MEMORY                                  = -1,

  873.     VK_ERROR_OUT_OF_DEVICE_MEMORY                                = -2,

  874.     VK_ERROR_INITIALIZATION_FAILED                               = -3,

  875.     VK_ERROR_DEVICE_LOST                                         = -4,

  876.     VK_ERROR_MEMORY_MAP_FAILED                                   = -5,

  877.     VK_ERROR_LAYER_NOT_PRESENT                                   = -6,

  878.     VK_ERROR_EXTENSION_NOT_PRESENT                               = -7,

  879.     VK_ERROR_FEATURE_NOT_PRESENT                                 = -8,

  880.     VK_ERROR_INCOMPATIBLE_DRIVER                                 = -9,

  881.     VK_ERROR_TOO_MANY_OBJECTS                                    = -10,

  882.     VK_ERROR_FORMAT_NOT_SUPPORTED                                = -11

  883.   );

  884.   PVkResult = ^TVkResult;

  885. 

  886.   TVkSampleCountFlagBits = (

  887.     VK_SAMPLE_COUNT_1_BIT                                        = (1 shl 0),

  888.     VK_SAMPLE_COUNT_2_BIT                                        = (1 shl 1),

  889.     VK_SAMPLE_COUNT_4_BIT                                        = (1 shl 2),

  890.     VK_SAMPLE_COUNT_8_BIT                                        = (1 shl 3),

  891.     VK_SAMPLE_COUNT_16_BIT                                       = (1 shl 4),

  892.     VK_SAMPLE_COUNT_32_BIT                                       = (1 shl 5),

  893.     VK_SAMPLE_COUNT_64_BIT                                       = (1 shl 6)

  894.   );

  895.   PVkSampleCountFlagBits = ^TVkSampleCountFlagBits;

  896. 

  897.   TVkSamplerAddressMode = (

  898.     VK_SAMPLER_ADDRESS_MODE_REPEAT                               = 0,

  899.     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT                      = 1,

  900.     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE                        = 2,

  901.     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER                      = 3,

  902.     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE                 = 4

  903.   );

  904.   PVkSamplerAddressMode = ^TVkSamplerAddressMode;

  905. 

  906.   TVkSamplerMipmapMode = (

  907.     VK_SAMPLER_MIPMAP_MODE_NEAREST                               = 0,

  908.     VK_SAMPLER_MIPMAP_MODE_LINEAR                                = 1

  909.   );

  910.   PVkSamplerMipmapMode = ^TVkSamplerMipmapMode;

  911. 

  912.   TVkShaderStageFlagBits = (

  913.     VK_SHADER_STAGE_VERTEX_BIT                                   = (1 shl 0),

  914.     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT                     = (1 shl 1),

  915.     VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT                  = (1 shl 2),

  916.     VK_SHADER_STAGE_GEOMETRY_BIT                                 = (1 shl 3),

  917.     VK_SHADER_STAGE_FRAGMENT_BIT                                 = (1 shl 4),

  918.     VK_SHADER_STAGE_COMPUTE_BIT                                  = (1 shl 5),

  919.     VK_SHADER_STAGE_ALL_GRAPHICS                                 = $1F,

  920.     VK_SHADER_STAGE_ALL                                          = $7FFFFFFF

  921.   );

  922.   PVkShaderStageFlagBits = ^TVkShaderStageFlagBits;

  923. 

  924.   TVkSharingMode = (

  925.     VK_SHARING_MODE_EXCLUSIVE                                    = 0,

  926.     VK_SHARING_MODE_CONCURRENT                                   = 1

  927.   );

  928.   PVkSharingMode = ^TVkSharingMode;

  929. 

  930.   TVkStencilOp = (

  931.     VK_STENCIL_OP_KEEP                                           = 0,

  932.     VK_STENCIL_OP_ZERO                                           = 1,

  933.     VK_STENCIL_OP_REPLACE                                        = 2,

  934.     VK_STENCIL_OP_INCREMENT_AND_CLAMP                            = 3,

  935.     VK_STENCIL_OP_DECREMENT_AND_CLAMP                            = 4,

  936.     VK_STENCIL_OP_INVERT                                         = 5,

  937.     VK_STENCIL_OP_INCREMENT_AND_WRAP                             = 6,

  938.     VK_STENCIL_OP_DECREMENT_AND_WRAP                             = 7

  939.   );

  940.   PVkStencilOp = ^TVkStencilOp;

  941. 

  942.   TVkStructureType = (

  943.     VK_STRUCTURE_TYPE_APPLICATION_INFO                           = 0,

  944.     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO                       = 1,

  945.     VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO                   = 2,

  946.     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO                         = 3,

  947.     VK_STRUCTURE_TYPE_SUBMIT_INFO                                = 4,

  948.     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO                       = 5,

  949.     VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE                        = 6,

  950.     VK_STRUCTURE_TYPE_BIND_SPARSE_INFO                           = 7,

  951.     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO                          = 8,

  952.     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO                      = 9,

  953.     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO                          = 10,

  954.     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO                     = 11,

  955.     VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO                         = 12,

  956.     VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO                    = 13,

  957.     VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO                          = 14,

  958.     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO                     = 15,

  959.     VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO                  = 16,

  960.     VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO                 = 17,

  961.     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO          = 18,

  962.     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO    = 19,

  963.     VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO  = 20,

  964.     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO    = 21,

  965.     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO        = 22,

  966.     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO   = 23,

  967.     VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO     = 24,

  968.     VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO   = 25,

  969.     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO     = 26,

  970.     VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO         = 27,

  971.     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO              = 28,

  972.     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO               = 29,

  973.     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO                = 30,

  974.     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO                        = 31,

  975.     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO          = 32,

  976.     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO                = 33,

  977.     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO               = 34,

  978.     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET                       = 35,

  979.     VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET                        = 36,

  980.     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO                    = 37,

  981.     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO                    = 38,

  982.     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO                   = 39,

  983.     VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO               = 40,

  984.     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO            = 41,

  985.     VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO                  = 42,

  986.     VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO                     = 43,

  987.     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER                      = 44,

  988.     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER                       = 45,

  989.     VK_STRUCTURE_TYPE_MEMORY_BARRIER                             = 46,

  990.     VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO                = 47,

  991.     VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO                  = 48

  992.   );

  993.   PVkStructureType = ^TVkStructureType;

  994. 

  995.   TVkSubpassContents = (

  996.     VK_SUBPASS_CONTENTS_INLINE                                   = 0,

  997.     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS                = 1

  998.   );

  999.   PVkSubpassContents = ^TVkSubpassContents;

  1000. 

  1001.   TVkSystemAllocationScope = (

  1002.     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND                           = 0,

  1003.     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT                            = 1,

  1004.     VK_SYSTEM_ALLOCATION_SCOPE_CACHE                             = 2,

  1005.     VK_SYSTEM_ALLOCATION_SCOPE_DEVICE                            = 3,

  1006.     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE                          = 4

  1007.   );

  1008.   PVkSystemAllocationScope = ^TVkSystemAllocationScope;

  1009. 

  1010.   TVkVertexInputRate = (

  1011.     VK_VERTEX_INPUT_RATE_VERTEX                                  = 0,

  1012.     VK_VERTEX_INPUT_RATE_INSTANCE                                = 1

  1013.   );

  1014.   PVkVertexInputRate = ^TVkVertexInputRate;

  1015. 

  1016. type { funcptrs }

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

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

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

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

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

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

  1023. 

  1024. type { structs }

  1025.   TVkViewport = record

  1026.     x:                                                VkFloat;

  1027.     y:                                                VkFloat;

  1028.     width:                                            VkFloat;

  1029.     height:                                           VkFloat;

  1030.     minDepth:                                         VkFloat;

  1031.     maxDepth:                                         VkFloat;

  1032.   end;

  1033.   PVkViewport = ^TVkViewport;

  1034.   PPVkViewport = ^PVkViewport;

  1035. 

  1036.   TVkOffset2D = record

  1037.     x:                                                VkInt32;

  1038.     y:                                                VkInt32;

  1039.   end;

  1040.   PVkOffset2D = ^TVkOffset2D;

  1041.   PPVkOffset2D = ^PVkOffset2D;

  1042. 

  1043.   TVkOffset3D = record

  1044.     x:                                                VkInt32;

  1045.     y:                                                VkInt32;

  1046.     z:                                                VkInt32;

  1047.   end;

  1048.   PVkOffset3D = ^TVkOffset3D;

  1049.   PPVkOffset3D = ^PVkOffset3D;

  1050. 

  1051.   TVkClearColorValue = record

  1052.     case Integer of

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

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

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

  1056.   end;

  1057.   PVkClearColorValue = ^TVkClearColorValue;

  1058.   PPVkClearColorValue = ^PVkClearColorValue;

  1059. 

  1060.   TVkClearDepthStencilValue = record

  1061.     depth:                                            VkFloat;

  1062.     stencil:                                          VkUint32;

  1063.   end;

  1064.   PVkClearDepthStencilValue = ^TVkClearDepthStencilValue;

  1065.   PPVkClearDepthStencilValue = ^PVkClearDepthStencilValue;

  1066. 

  1067.   TVkDispatchIndirectCommand = record

  1068.     x:                                                VkUint32;

  1069.     y:                                                VkUint32;

  1070.     z:                                                VkUint32;

  1071.   end;

  1072.   PVkDispatchIndirectCommand = ^TVkDispatchIndirectCommand;

  1073.   PPVkDispatchIndirectCommand = ^PVkDispatchIndirectCommand;

  1074. 

  1075.   TVkDrawIndexedIndirectCommand = record

  1076.     indexCount:                                       VkUint32;

  1077.     instanceCount:                                    VkUint32;

  1078.     firstIndex:                                       VkUint32;

  1079.     vertexOffset:                                     VkInt32;

  1080.     firstInstance:                                    VkUint32;

  1081.   end;

  1082.   PVkDrawIndexedIndirectCommand = ^TVkDrawIndexedIndirectCommand;

  1083.   PPVkDrawIndexedIndirectCommand = ^PVkDrawIndexedIndirectCommand;

  1084. 

  1085.   TVkDrawIndirectCommand = record

  1086.     vertexCount:                                      VkUint32;

  1087.     instanceCount:                                    VkUint32;

  1088.     firstVertex:                                      VkUint32;

  1089.     firstInstance:                                    VkUint32;

  1090.   end;

  1091.   PVkDrawIndirectCommand = ^TVkDrawIndirectCommand;

  1092.   PPVkDrawIndirectCommand = ^PVkDrawIndirectCommand;

  1093. 

  1094.   TVkExtensionProperties = record

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

  1096.     specVersion:                                      VkUint32;

  1097.   end;

  1098.   PVkExtensionProperties = ^TVkExtensionProperties;

  1099.   PPVkExtensionProperties = ^PVkExtensionProperties;

  1100. 

  1101.   TVkExtent2D = record

  1102.     width:                                            VkUint32;

  1103.     height:                                           VkUint32;

  1104.   end;

  1105.   PVkExtent2D = ^TVkExtent2D;

  1106.   PPVkExtent2D = ^PVkExtent2D;

  1107. 

  1108.   TVkExtent3D = record

  1109.     width:                                            VkUint32;

  1110.     height:                                           VkUint32;

  1111.     depth:                                            VkUint32;

  1112.   end;

  1113.   PVkExtent3D = ^TVkExtent3D;

  1114.   PPVkExtent3D = ^PVkExtent3D;

  1115. 

  1116.   TVkLayerProperties = record

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

  1118.     specVersion:                                      VkUint32;

  1119.     implementationVersion:                            VkUint32;

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

  1121.   end;

  1122.   PVkLayerProperties = ^TVkLayerProperties;

  1123.   PPVkLayerProperties = ^PVkLayerProperties;

  1124. 

  1125.   TVkSpecializationMapEntry = record

  1126.     constantID:                                       VkUint32;

  1127.     offset:                                           VkUint32;

  1128.     size:                                             VkSize;

  1129.   end;

  1130.   PVkSpecializationMapEntry = ^TVkSpecializationMapEntry;

  1131.   PPVkSpecializationMapEntry = ^PVkSpecializationMapEntry;

  1132. 

  1133.   TVkPhysicalDeviceFeatures = record

  1134.     robustBufferAccess:                               VkBool32;

  1135.     fullDrawIndexUint32:                              VkBool32;

  1136.     imageCubeArray:                                   VkBool32;

  1137.     independentBlend:                                 VkBool32;

  1138.     geometryShader:                                   VkBool32;

  1139.     tessellationShader:                               VkBool32;

  1140.     sampleRateShading:                                VkBool32;

  1141.     dualSrcBlend:                                     VkBool32;

  1142.     logicOp:                                          VkBool32;

  1143.     multiDrawIndirect:                                VkBool32;

  1144.     drawIndirectFirstInstance:                        VkBool32;

  1145.     depthClamp:                                       VkBool32;

  1146.     depthBiasClamp:                                   VkBool32;

  1147.     fillModeNonSolid:                                 VkBool32;

  1148.     depthBounds:                                      VkBool32;

  1149.     wideLines:                                        VkBool32;

  1150.     largePoints:                                      VkBool32;

  1151.     alphaToOne:                                       VkBool32;

  1152.     multiViewport:                                    VkBool32;

  1153.     samplerAnisotropy:                                VkBool32;

  1154.     textureCompressionETC2:                           VkBool32;

  1155.     textureCompressionASTC_LDR:                       VkBool32;

  1156.     textureCompressionBC:                             VkBool32;

  1157.     occlusionQueryPrecise:                            VkBool32;

  1158.     pipelineStatisticsQuery:                          VkBool32;

  1159.     vertexPipelineStoresAndAtomics:                   VkBool32;

  1160.     fragmentStoresAndAtomics:                         VkBool32;

  1161.     shaderTessellationAndGeometryPointSize:           VkBool32;

  1162.     shaderImageGatherExtended:                        VkBool32;

  1163.     shaderStorageImageExtendedFormats:                VkBool32;

  1164.     shaderStorageImageMultisample:                    VkBool32;

  1165.     shaderStorageImageReadWithoutFormat:              VkBool32;

  1166.     shaderStorageImageWriteWithoutFormat:             VkBool32;

  1167.     shaderUniformBufferArrayDynamicIndexing:          VkBool32;

  1168.     shaderSampledImageArrayDynamicIndexing:           VkBool32;

  1169.     shaderStorageBufferArrayDynamicIndexing:          VkBool32;

  1170.     shaderStorageImageArrayDynamicIndexing:           VkBool32;

  1171.     shaderClipDistance:                               VkBool32;

  1172.     shaderCullDistance:                               VkBool32;

  1173.     shaderFloat64:                                    VkBool32;

  1174.     shaderInt64:                                      VkBool32;

  1175.     shaderInt16:                                      VkBool32;

  1176.     shaderResourceResidency:                          VkBool32;

  1177.     shaderResourceMinLod:                             VkBool32;

  1178.     sparseBinding:                                    VkBool32;

  1179.     sparseResidencyBuffer:                            VkBool32;

  1180.     sparseResidencyImage2D:                           VkBool32;

  1181.     sparseResidencyImage3D:                           VkBool32;

  1182.     sparseResidency2Samples:                          VkBool32;

  1183.     sparseResidency4Samples:                          VkBool32;

  1184.     sparseResidency8Samples:                          VkBool32;

  1185.     sparseResidency16Samples:                         VkBool32;

  1186.     sparseResidencyAliased:                           VkBool32;

  1187.     variableMultisampleRate:                          VkBool32;

  1188.     inheritedQueries:                                 VkBool32;

  1189.   end;

  1190.   PVkPhysicalDeviceFeatures = ^TVkPhysicalDeviceFeatures;

  1191.   PPVkPhysicalDeviceFeatures = ^PVkPhysicalDeviceFeatures;

  1192. 

  1193.   TVkPhysicalDeviceSparseProperties = record

  1194.     residencyStandard2DBlockShape:                    VkBool32;

  1195.     residencyStandard2DMultisampleBlockShape:         VkBool32;

  1196.     residencyStandard3DBlockShape:                    VkBool32;

  1197.     residencyAlignedMipSize:                          VkBool32;

  1198.     residencyNonResidentStrict:                       VkBool32;

  1199.   end;

  1200.   PVkPhysicalDeviceSparseProperties = ^TVkPhysicalDeviceSparseProperties;

  1201.   PPVkPhysicalDeviceSparseProperties = ^PVkPhysicalDeviceSparseProperties;

  1202. 

  1203.   TVkBufferCopy = record

  1204.     srcOffset:                                        VkDeviceSize;

  1205.     dstOffset:                                        VkDeviceSize;

  1206.     size:                                             VkDeviceSize;

  1207.   end;

  1208.   PVkBufferCopy = ^TVkBufferCopy;

  1209.   PPVkBufferCopy = ^PVkBufferCopy;

  1210. 

  1211.   TVkMemoryRequirements = record

  1212.     size:                                             VkDeviceSize;

  1213.     alignment:                                        VkDeviceSize;

  1214.     memoryTypeBits:                                   VkUint32;

  1215.   end;

  1216.   PVkMemoryRequirements = ^TVkMemoryRequirements;

  1217.   PPVkMemoryRequirements = ^PVkMemoryRequirements;

  1218. 

  1219.   TVkSubresourceLayout = record

  1220.     offset:                                           VkDeviceSize;

  1221.     size:                                             VkDeviceSize;

  1222.     rowPitch:                                         VkDeviceSize;

  1223.     arrayPitch:                                       VkDeviceSize;

  1224.     depthPitch:                                       VkDeviceSize;

  1225.   end;

  1226.   PVkSubresourceLayout = ^TVkSubresourceLayout;

  1227.   PPVkSubresourceLayout = ^PVkSubresourceLayout;

  1228. 

  1229.   TVkFormatProperties = record

  1230.     linearTilingFeatures:                             VkFormatFeatureFlags;

  1231.     optimalTilingFeatures:                            VkFormatFeatureFlags;

  1232.     bufferFeatures:                                   VkFormatFeatureFlags;

  1233.   end;

  1234.   PVkFormatProperties = ^TVkFormatProperties;

  1235.   PPVkFormatProperties = ^PVkFormatProperties;

  1236. 

  1237.   TVkImageSubresource = record

  1238.     aspectMask:                                       VkImageAspectFlags;

  1239.     mipLevel:                                         VkUint32;

  1240.     arrayLayer:                                       VkUint32;

  1241.   end;

  1242.   PVkImageSubresource = ^TVkImageSubresource;

  1243.   PPVkImageSubresource = ^PVkImageSubresource;

  1244. 

  1245.   TVkImageSubresourceLayers = record

  1246.     aspectMask:                                       VkImageAspectFlags;

  1247.     mipLevel:                                         VkUint32;

  1248.     baseArrayLayer:                                   VkUint32;

  1249.     layerCount:                                       VkUint32;

  1250.   end;

  1251.   PVkImageSubresourceLayers = ^TVkImageSubresourceLayers;

  1252.   PPVkImageSubresourceLayers = ^PVkImageSubresourceLayers;

  1253. 

  1254.   TVkImageSubresourceRange = record

  1255.     aspectMask:                                       VkImageAspectFlags;

  1256.     baseMipLevel:                                     VkUint32;

  1257.     levelCount:                                       VkUint32;

  1258.     baseArrayLayer:                                   VkUint32;

  1259.     layerCount:                                       VkUint32;

  1260.   end;

  1261.   PVkImageSubresourceRange = ^TVkImageSubresourceRange;

  1262.   PPVkImageSubresourceRange = ^PVkImageSubresourceRange;

  1263. 

  1264.   TVkMemoryHeap = record

  1265.     size:                                             VkDeviceSize;

  1266.     flags:                                            VkMemoryHeapFlags;

  1267.   end;

  1268.   PVkMemoryHeap = ^TVkMemoryHeap;

  1269.   PPVkMemoryHeap = ^PVkMemoryHeap;

  1270. 

  1271.   TVkMemoryType = record

  1272.     propertyFlags:                                    VkMemoryPropertyFlags;

  1273.     heapIndex:                                        VkUint32;

  1274.   end;

  1275.   PVkMemoryType = ^TVkMemoryType;

  1276.   PPVkMemoryType = ^PVkMemoryType;

  1277. 

  1278.   TVkSubpassDependency = record

  1279.     srcSubpass:                                       VkUint32;

  1280.     dstSubpass:                                       VkUint32;

  1281.     srcStageMask:                                     VkPipelineStageFlags;

  1282.     dstStageMask:                                     VkPipelineStageFlags;

  1283.     srcAccessMask:                                    VkAccessFlags;

  1284.     dstAccessMask:                                    VkAccessFlags;

  1285.     dependencyFlags:                                  VkDependencyFlags;

  1286.   end;

  1287.   PVkSubpassDependency = ^TVkSubpassDependency;

  1288.   PPVkSubpassDependency = ^PVkSubpassDependency;

  1289. 

  1290.   TVkPhysicalDeviceLimits = record

  1291.     maxImageDimension1D:                              VkUint32;

  1292.     maxImageDimension2D:                              VkUint32;

  1293.     maxImageDimension3D:                              VkUint32;

  1294.     maxImageDimensionCube:                            VkUint32;

  1295.     maxImageArrayLayers:                              VkUint32;

  1296.     maxTexelBufferElements:                           VkUint32;

  1297.     maxUniformBufferRange:                            VkUint32;

  1298.     maxStorageBufferRange:                            VkUint32;

  1299.     maxPushConstantsSize:                             VkUint32;

  1300.     maxMemoryAllocationCount:                         VkUint32;

  1301.     maxSamplerAllocationCount:                        VkUint32;

  1302.     bufferImageGranularity:                           VkDeviceSize;

  1303.     sparseAddressSpaceSize:                           VkDeviceSize;

  1304.     maxBoundDescriptorSets:                           VkUint32;

  1305.     maxPerStageDescriptorSamplers:                    VkUint32;

  1306.     maxPerStageDescriptorUniformBuffers:              VkUint32;

  1307.     maxPerStageDescriptorStorageBuffers:              VkUint32;

  1308.     maxPerStageDescriptorSampledImages:               VkUint32;

  1309.     maxPerStageDescriptorStorageImages:               VkUint32;

  1310.     maxPerStageDescriptorInputAttachments:            VkUint32;

  1311.     maxPerStageResources:                             VkUint32;

  1312.     maxDescriptorSetSamplers:                         VkUint32;

  1313.     maxDescriptorSetUniformBuffers:                   VkUint32;

  1314.     maxDescriptorSetUniformBuffersDynamic:            VkUint32;

  1315.     maxDescriptorSetStorageBuffers:                   VkUint32;

  1316.     maxDescriptorSetStorageBuffersDynamic:            VkUint32;

  1317.     maxDescriptorSetSampledImages:                    VkUint32;

  1318.     maxDescriptorSetStorageImages:                    VkUint32;

  1319.     maxDescriptorSetInputAttachments:                 VkUint32;

  1320.     maxVertexInputAttributes:                         VkUint32;

  1321.     maxVertexInputBindings:                           VkUint32;

  1322.     maxVertexInputAttributeOffset:                    VkUint32;

  1323.     maxVertexInputBindingStride:                      VkUint32;

  1324.     maxVertexOutputComponents:                        VkUint32;

  1325.     maxTessellationGenerationLevel:                   VkUint32;

  1326.     maxTessellationPatchSize:                         VkUint32;

  1327.     maxTessellationControlPerVertexInputComponents:   VkUint32;

  1328.     maxTessellationControlPerVertexOutputComponents:  VkUint32;

  1329.     maxTessellationControlPerPatchOutputComponents:   VkUint32;

  1330.     maxTessellationControlTotalOutputComponents:      VkUint32;

  1331.     maxTessellationEvaluationInputComponents:         VkUint32;

  1332.     maxTessellationEvaluationOutputComponents:        VkUint32;

  1333.     maxGeometryShaderInvocations:                     VkUint32;

  1334.     maxGeometryInputComponents:                       VkUint32;

  1335.     maxGeometryOutputComponents:                      VkUint32;

  1336.     maxGeometryOutputVertices:                        VkUint32;

  1337.     maxGeometryTotalOutputComponents:                 VkUint32;

  1338.     maxFragmentInputComponents:                       VkUint32;

  1339.     maxFragmentOutputAttachments:                     VkUint32;

  1340.     maxFragmentDualSrcAttachments:                    VkUint32;

  1341.     maxFragmentCombinedOutputResources:               VkUint32;

  1342.     maxComputeSharedMemorySize:                       VkUint32;

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

  1344.     maxComputeWorkGroupInvocations:                   VkUint32;

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

  1346.     subPixelPrecisionBits:                            VkUint32;

  1347.     subTexelPrecisionBits:                            VkUint32;

  1348.     mipmapPrecisionBits:                              VkUint32;

  1349.     maxDrawIndexedIndexValue:                         VkUint32;

  1350.     maxDrawIndirectCount:                             VkUint32;

  1351.     maxSamplerLodBias:                                VkFloat;

  1352.     maxSamplerAnisotropy:                             VkFloat;

  1353.     maxViewports:                                     VkUint32;

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

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

  1356.     viewportSubPixelBits:                             VkUint32;

  1357.     minMemoryMapAlignment:                            VkSize;

  1358.     minTexelBufferOffsetAlignment:                    VkDeviceSize;

  1359.     minUniformBufferOffsetAlignment:                  VkDeviceSize;

  1360.     minStorageBufferOffsetAlignment:                  VkDeviceSize;

  1361.     minTexelOffset:                                   VkInt32;

  1362.     maxTexelOffset:                                   VkUint32;

  1363.     minTexelGatherOffset:                             VkInt32;

  1364.     maxTexelGatherOffset:                             VkUint32;

  1365.     minInterpolationOffset:                           VkFloat;

  1366.     maxInterpolationOffset:                           VkFloat;

  1367.     subPixelInterpolationOffsetBits:                  VkUint32;

  1368.     maxFramebufferWidth:                              VkUint32;

  1369.     maxFramebufferHeight:                             VkUint32;

  1370.     maxFramebufferLayers:                             VkUint32;

  1371.     framebufferColorSampleCounts:                     VkSampleCountFlags;

  1372.     framebufferDepthSampleCounts:                     VkSampleCountFlags;

  1373.     framebufferStencilSampleCounts:                   VkSampleCountFlags;

  1374.     framebufferNoAttachmentsSampleCounts:             VkSampleCountFlags;

  1375.     maxColorAttachments:                              VkUint32;

  1376.     sampledImageColorSampleCounts:                    VkSampleCountFlags;

  1377.     sampledImageIntegerSampleCounts:                  VkSampleCountFlags;

  1378.     sampledImageDepthSampleCounts:                    VkSampleCountFlags;

  1379.     sampledImageStencilSampleCounts:                  VkSampleCountFlags;

  1380.     storageImageSampleCounts:                         VkSampleCountFlags;

  1381.     maxSampleMaskWords:                               VkUint32;

  1382.     timestampComputeAndGraphics:                      VkBool32;

  1383.     timestampPeriod:                                  VkFloat;

  1384.     maxClipDistances:                                 VkUint32;

  1385.     maxCullDistances:                                 VkUint32;

  1386.     maxCombinedClipAndCullDistances:                  VkUint32;

  1387.     discreteQueuePriorities:                          VkUint32;

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

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

  1390.     pointSizeGranularity:                             VkFloat;

  1391.     lineWidthGranularity:                             VkFloat;

  1392.     strictLines:                                      VkBool32;

  1393.     standardSampleLocations:                          VkBool32;

  1394.     optimalBufferCopyOffsetAlignment:                 VkDeviceSize;

  1395.     optimalBufferCopyRowPitchAlignment:               VkDeviceSize;

  1396.     nonCoherentAtomSize:                              VkDeviceSize;

  1397.   end;

  1398.   PVkPhysicalDeviceLimits = ^TVkPhysicalDeviceLimits;

  1399.   PPVkPhysicalDeviceLimits = ^PVkPhysicalDeviceLimits;

  1400. 

  1401.   TVkPushConstantRange = record

  1402.     stageFlags:                                       VkShaderStageFlags;

  1403.     offset:                                           VkUint32;

  1404.     size:                                             VkUint32;

  1405.   end;

  1406.   PVkPushConstantRange = ^TVkPushConstantRange;

  1407.   PPVkPushConstantRange = ^PVkPushConstantRange;

  1408. 

  1409.   TVkRect2D = record

  1410.     offset:                                           TVkOffset2D;

  1411.     extent:                                           TVkExtent2D;

  1412.   end;

  1413.   PVkRect2D = ^TVkRect2D;

  1414.   PPVkRect2D = ^PVkRect2D;

  1415. 

  1416.   TVkDescriptorBufferInfo = record

  1417.     buffer:                                           VkBuffer;

  1418.     offset:                                           VkDeviceSize;

  1419.     range:                                            VkDeviceSize;

  1420.   end;

  1421.   PVkDescriptorBufferInfo = ^TVkDescriptorBufferInfo;

  1422.   PPVkDescriptorBufferInfo = ^PVkDescriptorBufferInfo;

  1423. 

  1424.   TVkQueueFamilyProperties = record

  1425.     queueFlags:                                       VkQueueFlags;

  1426.     queueCount:                                       VkUint32;

  1427.     timestampValidBits:                               VkUint32;

  1428.     minImageTransferGranularity:                      TVkExtent3D;

  1429.   end;

  1430.   PVkQueueFamilyProperties = ^TVkQueueFamilyProperties;

  1431.   PPVkQueueFamilyProperties = ^PVkQueueFamilyProperties;

  1432. 

  1433.   TVkImageFormatProperties = record

  1434.     maxExtent:                                        TVkExtent3D;

  1435.     maxMipLevels:                                     VkUint32;

  1436.     maxArrayLayers:                                   VkUint32;

  1437.     sampleCounts:                                     VkSampleCountFlags;

  1438.     maxResourceSize:                                  VkDeviceSize;

  1439.   end;

  1440.   PVkImageFormatProperties = ^TVkImageFormatProperties;

  1441.   PPVkImageFormatProperties = ^PVkImageFormatProperties;

  1442. 

  1443.   TVkSparseImageFormatProperties = record

  1444.     aspectMask:                                       VkImageAspectFlags;

  1445.     imageGranularity:                                 TVkExtent3D;

  1446.     flags:                                            VkSparseImageFormatFlags;

  1447.   end;

  1448.   PVkSparseImageFormatProperties = ^TVkSparseImageFormatProperties;

  1449.   PPVkSparseImageFormatProperties = ^PVkSparseImageFormatProperties;

  1450. 

  1451.   TVkSparseMemoryBind = record

  1452.     resourceOffset:                                   VkDeviceSize;

  1453.     size:                                             VkDeviceSize;

  1454.     memory:                                           VkDeviceMemory;

  1455.     memoryOffset:                                     VkDeviceSize;

  1456.     flags:                                            VkSparseMemoryBindFlags;

  1457.   end;

  1458.   PVkSparseMemoryBind = ^TVkSparseMemoryBind;

  1459.   PPVkSparseMemoryBind = ^PVkSparseMemoryBind;

  1460. 

  1461.   TVkComponentMapping = record

  1462.     r:                                                TVkComponentSwizzle;

  1463.     g:                                                TVkComponentSwizzle;

  1464.     b:                                                TVkComponentSwizzle;

  1465.     a:                                                TVkComponentSwizzle;

  1466.   end;

  1467.   PVkComponentMapping = ^TVkComponentMapping;

  1468.   PPVkComponentMapping = ^PVkComponentMapping;

  1469. 

  1470.   TVkAttachmentReference = record

  1471.     attachment:                                       VkUint32;

  1472.     layout:                                           TVkImageLayout;

  1473.   end;

  1474.   PVkAttachmentReference = ^TVkAttachmentReference;

  1475.   PPVkAttachmentReference = ^PVkAttachmentReference;

  1476. 

  1477.   TVkDescriptorPoolSize = record

  1478.     dType:                                            TVkDescriptorType;

  1479.     descriptorCount:                                  VkUint32;

  1480.   end;

  1481.   PVkDescriptorPoolSize = ^TVkDescriptorPoolSize;

  1482.   PPVkDescriptorPoolSize = ^PVkDescriptorPoolSize;

  1483. 

  1484.   TVkStencilOpState = record

  1485.     failOp:                                           TVkStencilOp;

  1486.     passOp:                                           TVkStencilOp;

  1487.     depthFailOp:                                      TVkStencilOp;

  1488.     compareOp:                                        TVkCompareOp;

  1489.     compareMask:                                      VkUint32;

  1490.     writeMask:                                        VkUint32;

  1491.     reference:                                        VkUint32;

  1492.   end;

  1493.   PVkStencilOpState = ^TVkStencilOpState;

  1494.   PPVkStencilOpState = ^PVkStencilOpState;

  1495. 

  1496.   TVkVertexInputAttributeDescription = record

  1497.     location:                                         VkUint32;

  1498.     binding:                                          VkUint32;

  1499.     format:                                           TVkFormat;

  1500.     offset:                                           VkUint32;

  1501.   end;

  1502.   PVkVertexInputAttributeDescription = ^TVkVertexInputAttributeDescription;

  1503.   PPVkVertexInputAttributeDescription = ^PVkVertexInputAttributeDescription;

  1504. 

  1505.   TVkVertexInputBindingDescription = record

  1506.     binding:                                          VkUint32;

  1507.     stride:                                           VkUint32;

  1508.     inputRate:                                        TVkVertexInputRate;

  1509.   end;

  1510.   PVkVertexInputBindingDescription = ^TVkVertexInputBindingDescription;

  1511.   PPVkVertexInputBindingDescription = ^PVkVertexInputBindingDescription;

  1512. 

  1513.   TVkApplicationInfo = record

  1514.     sType:                                            TVkStructureType;

  1515.     pNext:                                            PVkVoid;

  1516.     pApplicationName:                                 PVkChar;

  1517.     applicationVersion:                               VkUint32;

  1518.     pEngineName:                                      PVkChar;

  1519.     engineVersion:                                    VkUint32;

  1520.     apiVersion:                                       VkUint32;

  1521.   end;

  1522.   PVkApplicationInfo = ^TVkApplicationInfo;

  1523.   PPVkApplicationInfo = ^PVkApplicationInfo;

  1524. 

  1525.   TVkCommandBufferAllocateInfo = record

  1526.     sType:                                            TVkStructureType;

  1527.     pNext:                                            PVkVoid;

  1528.     commandPool:                                      VkCommandPool;

  1529.     level:                                            TVkCommandBufferLevel;

  1530.     commandBufferCount:                               VkUint32;

  1531.   end;

  1532.   PVkCommandBufferAllocateInfo = ^TVkCommandBufferAllocateInfo;

  1533.   PPVkCommandBufferAllocateInfo = ^PVkCommandBufferAllocateInfo;

  1534. 

  1535.   TVkCopyDescriptorSet = record

  1536.     sType:                                            TVkStructureType;

  1537.     pNext:                                            PVkVoid;

  1538.     srcSet:                                           VkDescriptorSet;

  1539.     srcBinding:                                       VkUint32;

  1540.     srcArrayElement:                                  VkUint32;

  1541.     dstSet:                                           VkDescriptorSet;

  1542.     dstBinding:                                       VkUint32;

  1543.     dstArrayElement:                                  VkUint32;

  1544.     descriptorCount:                                  VkUint32;

  1545.   end;

  1546.   PVkCopyDescriptorSet = ^TVkCopyDescriptorSet;

  1547.   PPVkCopyDescriptorSet = ^PVkCopyDescriptorSet;

  1548. 

  1549.   TVkDescriptorSetAllocateInfo = record

  1550.     sType:                                            TVkStructureType;

  1551.     pNext:                                            PVkVoid;

  1552.     descriptorPool:                                   VkDescriptorPool;

  1553.     descriptorSetCount:                               VkUint32;

  1554.     pSetLayouts:                                      PVkDescriptorSetLayout;

  1555.   end;

  1556.   PVkDescriptorSetAllocateInfo = ^TVkDescriptorSetAllocateInfo;

  1557.   PPVkDescriptorSetAllocateInfo = ^PVkDescriptorSetAllocateInfo;

  1558. 

  1559.   TVkDescriptorImageInfo = record

  1560.     sampler:                                          VkSampler;

  1561.     imageView:                                        VkImageView;

  1562.     imageLayout:                                      TVkImageLayout;

  1563.   end;

  1564.   PVkDescriptorImageInfo = ^TVkDescriptorImageInfo;

  1565.   PPVkDescriptorImageInfo = ^PVkDescriptorImageInfo;

  1566. 

  1567.   TVkClearValue = record

  1568.     case Integer of

  1569.       000: (color:                                    TVkClearColorValue);

  1570.       001: (depthStencil:                             TVkClearDepthStencilValue);

  1571.   end;

  1572.   PVkClearValue = ^TVkClearValue;

  1573.   PPVkClearValue = ^PVkClearValue;

  1574. 

  1575.   TVkSpecializationInfo = record

  1576.     mapEntryCount:                                    VkUint32;

  1577.     pMapEntries:                                      PVkSpecializationMapEntry;

  1578.     dataSize:                                         VkSize;

  1579.     pData:                                            PVkVoid;

  1580.   end;

  1581.   PVkSpecializationInfo = ^TVkSpecializationInfo;

  1582.   PPVkSpecializationInfo = ^PVkSpecializationInfo;

  1583. 

  1584.   TVkBufferMemoryBarrier = record

  1585.     sType:                                            TVkStructureType;

  1586.     pNext:                                            PVkVoid;

  1587.     srcAccessMask:                                    VkAccessFlags;

  1588.     dstAccessMask:                                    VkAccessFlags;

  1589.     srcQueueFamilyIndex:                              VkUint32;

  1590.     dstQueueFamilyIndex:                              VkUint32;

  1591.     buffer:                                           VkBuffer;

  1592.     offset:                                           VkDeviceSize;

  1593.     size:                                             VkDeviceSize;

  1594.   end;

  1595.   PVkBufferMemoryBarrier = ^TVkBufferMemoryBarrier;

  1596.   PPVkBufferMemoryBarrier = ^PVkBufferMemoryBarrier;

  1597. 

  1598.   TVkBufferCreateInfo = record

  1599.     sType:                                            TVkStructureType;

  1600.     pNext:                                            PVkVoid;

  1601.     flags:                                            VkBufferCreateFlags;

  1602.     size:                                             VkDeviceSize;

  1603.     usage:                                            VkBufferUsageFlags;

  1604.     sharingMode:                                      TVkSharingMode;

  1605.     queueFamilyIndexCount:                            VkUint32;

  1606.     pQueueFamilyIndices:                              PVkUint32;

  1607.   end;

  1608.   PVkBufferCreateInfo = ^TVkBufferCreateInfo;

  1609.   PPVkBufferCreateInfo = ^PVkBufferCreateInfo;

  1610. 

  1611.   TVkBufferViewCreateInfo = record

  1612.     sType:                                            TVkStructureType;

  1613.     pNext:                                            PVkVoid;

  1614.     flags:                                            VkBufferViewCreateFlags;

  1615.     buffer:                                           VkBuffer;

  1616.     format:                                           TVkFormat;

  1617.     offset:                                           VkDeviceSize;

  1618.     range:                                            VkDeviceSize;

  1619.   end;

  1620.   PVkBufferViewCreateInfo = ^TVkBufferViewCreateInfo;

  1621.   PPVkBufferViewCreateInfo = ^PVkBufferViewCreateInfo;

  1622. 

  1623.   TVkPipelineColorBlendAttachmentState = record

  1624.     blendEnable:                                      VkBool32;

  1625.     srcColorBlendFactor:                              TVkBlendFactor;

  1626.     dstColorBlendFactor:                              TVkBlendFactor;

  1627.     colorBlendOp:                                     TVkBlendOp;

  1628.     srcAlphaBlendFactor:                              TVkBlendFactor;

  1629.     dstAlphaBlendFactor:                              TVkBlendFactor;

  1630.     alphaBlendOp:                                     TVkBlendOp;

  1631.     colorWriteMask:                                   VkColorComponentFlags;

  1632.   end;

  1633.   PVkPipelineColorBlendAttachmentState = ^TVkPipelineColorBlendAttachmentState;

  1634.   PPVkPipelineColorBlendAttachmentState = ^PVkPipelineColorBlendAttachmentState;

  1635. 

  1636.   TVkCommandPoolCreateInfo = record

  1637.     sType:                                            TVkStructureType;

  1638.     pNext:                                            PVkVoid;

  1639.     flags:                                            VkCommandPoolCreateFlags;

  1640.     queueFamilyIndex:                                 VkUint32;

  1641.   end;

  1642.   PVkCommandPoolCreateInfo = ^TVkCommandPoolCreateInfo;

  1643.   PPVkCommandPoolCreateInfo = ^PVkCommandPoolCreateInfo;

  1644. 

  1645.   TVkDeviceQueueCreateInfo = record

  1646.     sType:                                            TVkStructureType;

  1647.     pNext:                                            PVkVoid;

  1648.     flags:                                            VkDeviceQueueCreateFlags;

  1649.     queueFamilyIndex:                                 VkUint32;

  1650.     queueCount:                                       VkUint32;

  1651.     pQueuePriorities:                                 PVkFloat;

  1652.   end;

  1653.   PVkDeviceQueueCreateInfo = ^TVkDeviceQueueCreateInfo;

  1654.   PPVkDeviceQueueCreateInfo = ^PVkDeviceQueueCreateInfo;

  1655. 

  1656.   TVkCommandBufferInheritanceInfo = record

  1657.     sType:                                            TVkStructureType;

  1658.     pNext:                                            PVkVoid;

  1659.     renderPass:                                       VkRenderPass;

  1660.     subpass:                                          VkUint32;

  1661.     framebuffer:                                      VkFramebuffer;

  1662.     occlusionQueryEnable:                             VkBool32;

  1663.     queryFlags:                                       VkQueryControlFlags;

  1664.     pipelineStatistics:                               VkQueryPipelineStatisticFlags;

  1665.   end;

  1666.   PVkCommandBufferInheritanceInfo = ^TVkCommandBufferInheritanceInfo;

  1667.   PPVkCommandBufferInheritanceInfo = ^PVkCommandBufferInheritanceInfo;

  1668. 

  1669.   TVkDescriptorSetLayoutBinding = record

  1670.     binding:                                          VkUint32;

  1671.     descriptorType:                                   TVkDescriptorType;

  1672.     descriptorCount:                                  VkUint32;

  1673.     stageFlags:                                       VkShaderStageFlags;

  1674.     pImmutableSamplers:                               PVkSampler;

  1675.   end;

  1676.   PVkDescriptorSetLayoutBinding = ^TVkDescriptorSetLayoutBinding;

  1677.   PPVkDescriptorSetLayoutBinding = ^PVkDescriptorSetLayoutBinding;

  1678. 

  1679.   TVkSparseImageMemoryBind = record

  1680.     subresource:                                      TVkImageSubresource;

  1681.     offset:                                           TVkOffset3D;

  1682.     extent:                                           TVkExtent3D;

  1683.     memory:                                           VkDeviceMemory;

  1684.     memoryOffset:                                     VkDeviceSize;

  1685.     flags:                                            VkSparseMemoryBindFlags;

  1686.   end;

  1687.   PVkSparseImageMemoryBind = ^TVkSparseImageMemoryBind;

  1688.   PPVkSparseImageMemoryBind = ^PVkSparseImageMemoryBind;

  1689. 

  1690.   TVkBufferImageCopy = record

  1691.     bufferOffset:                                     VkDeviceSize;

  1692.     bufferRowLength:                                  VkUint32;

  1693.     bufferImageHeight:                                VkUint32;

  1694.     imageSubresource:                                 TVkImageSubresourceLayers;

  1695.     imageOffset:                                      TVkOffset3D;

  1696.     imageExtent:                                      TVkExtent3D;

  1697.   end;

  1698.   PVkBufferImageCopy = ^TVkBufferImageCopy;

  1699.   PPVkBufferImageCopy = ^PVkBufferImageCopy;

  1700. 

  1701.   TVkImageBlit = record

  1702.     srcSubresource:                                   TVkImageSubresourceLayers;

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

  1704.     dstSubresource:                                   TVkImageSubresourceLayers;

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

  1706.   end;

  1707.   PVkImageBlit = ^TVkImageBlit;

  1708.   PPVkImageBlit = ^PVkImageBlit;

  1709. 

  1710.   TVkImageCopy = record

  1711.     srcSubresource:                                   TVkImageSubresourceLayers;

  1712.     srcOffset:                                        TVkOffset3D;

  1713.     dstSubresource:                                   TVkImageSubresourceLayers;

  1714.     dstOffset:                                        TVkOffset3D;

  1715.     extent:                                           TVkExtent3D;

  1716.   end;

  1717.   PVkImageCopy = ^TVkImageCopy;

  1718.   PPVkImageCopy = ^PVkImageCopy;

  1719. 

  1720.   TVkImageResolve = record

  1721.     srcSubresource:                                   TVkImageSubresourceLayers;

  1722.     srcOffset:                                        TVkOffset3D;

  1723.     dstSubresource:                                   TVkImageSubresourceLayers;

  1724.     dstOffset:                                        TVkOffset3D;

  1725.     extent:                                           TVkExtent3D;

  1726.   end;

  1727.   PVkImageResolve = ^TVkImageResolve;

  1728.   PPVkImageResolve = ^PVkImageResolve;

  1729. 

  1730.   TVkPhysicalDeviceMemoryProperties = record

  1731.     memoryTypeCount:                                  VkUint32;

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

  1733.     memoryHeapCount:                                  VkUint32;

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

  1735.   end;

  1736.   PVkPhysicalDeviceMemoryProperties = ^TVkPhysicalDeviceMemoryProperties;

  1737.   PPVkPhysicalDeviceMemoryProperties = ^PVkPhysicalDeviceMemoryProperties;

  1738. 

  1739.   TVkPhysicalDeviceProperties = record

  1740.     apiVersion:                                       VkUint32;

  1741.     driverVersion:                                    VkUint32;

  1742.     vendorID:                                         VkUint32;

  1743.     deviceID:                                         VkUint32;

  1744.     deviceType:                                       TVkPhysicalDeviceType;

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

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

  1747.     limits:                                           TVkPhysicalDeviceLimits;

  1748.     sparseProperties:                                 TVkPhysicalDeviceSparseProperties;

  1749.   end;

  1750.   PVkPhysicalDeviceProperties = ^TVkPhysicalDeviceProperties;

  1751.   PPVkPhysicalDeviceProperties = ^PVkPhysicalDeviceProperties;

  1752. 

  1753.   TVkClearRect = record

  1754.     rect:                                             TVkRect2D;

  1755.     baseArrayLayer:                                   VkUint32;

  1756.     layerCount:                                       VkUint32;

  1757.   end;

  1758.   PVkClearRect = ^TVkClearRect;

  1759.   PPVkClearRect = ^PVkClearRect;

  1760. 

  1761.   TVkSparseImageMemoryRequirements = record

  1762.     formatProperties:                                 TVkSparseImageFormatProperties;

  1763.     imageMipTailFirstLod:                             VkUint32;

  1764.     imageMipTailSize:                                 VkDeviceSize;

  1765.     imageMipTailOffset:                               VkDeviceSize;

  1766.     imageMipTailStride:                               VkDeviceSize;

  1767.   end;

  1768.   PVkSparseImageMemoryRequirements = ^TVkSparseImageMemoryRequirements;

  1769.   PPVkSparseImageMemoryRequirements = ^PVkSparseImageMemoryRequirements;

  1770. 

  1771.   TVkSparseBufferMemoryBindInfo = record

  1772.     buffer:                                           VkBuffer;

  1773.     bindCount:                                        VkUint32;

  1774.     pBinds:                                           PVkSparseMemoryBind;

  1775.   end;

  1776.   PVkSparseBufferMemoryBindInfo = ^TVkSparseBufferMemoryBindInfo;

  1777.   PPVkSparseBufferMemoryBindInfo = ^PVkSparseBufferMemoryBindInfo;

  1778. 

  1779.   TVkSparseImageOpaqueMemoryBindInfo = record

  1780.     image:                                            VkImage;

  1781.     bindCount:                                        VkUint32;

  1782.     pBinds:                                           PVkSparseMemoryBind;

  1783.   end;

  1784.   PVkSparseImageOpaqueMemoryBindInfo = ^TVkSparseImageOpaqueMemoryBindInfo;

  1785.   PPVkSparseImageOpaqueMemoryBindInfo = ^PVkSparseImageOpaqueMemoryBindInfo;

  1786. 

  1787.   TVkSubpassDescription = record

  1788.     flags:                                            VkSubpassDescriptionFlags;

  1789.     pipelineBindPoint:                                TVkPipelineBindPoint;

  1790.     inputAttachmentCount:                             VkUint32;

  1791.     pInputAttachments:                                PVkAttachmentReference;

  1792.     colorAttachmentCount:                             VkUint32;

  1793.     pColorAttachments:                                PVkAttachmentReference;

  1794.     pResolveAttachments:                              PVkAttachmentReference;

  1795.     pDepthStencilAttachment:                          PVkAttachmentReference;

  1796.     preserveAttachmentCount:                          VkUint32;

  1797.     pPreserveAttachments:                             PVkUint32;

  1798.   end;

  1799.   PVkSubpassDescription = ^TVkSubpassDescription;

  1800.   PPVkSubpassDescription = ^PVkSubpassDescription;

  1801. 

  1802.   TVkDescriptorPoolCreateInfo = record

  1803.     sType:                                            TVkStructureType;

  1804.     pNext:                                            PVkVoid;

  1805.     flags:                                            VkDescriptorPoolCreateFlags;

  1806.     maxSets:                                          VkUint32;

  1807.     poolSizeCount:                                    VkUint32;

  1808.     pPoolSizes:                                       PVkDescriptorPoolSize;

  1809.   end;

  1810.   PVkDescriptorPoolCreateInfo = ^TVkDescriptorPoolCreateInfo;

  1811.   PPVkDescriptorPoolCreateInfo = ^PVkDescriptorPoolCreateInfo;

  1812. 

  1813.   TVkAllocationCallbacks = record

  1814.     pUserData:                                        PVkVoid;

  1815.     pfnAllocation:                                    TvkAllocationFunction;

  1816.     pfnReallocation:                                  TvkReallocationFunction;

  1817.     pfnFree:                                          TvkFreeFunction;

  1818.     pfnInternalAllocation:                            TvkInternalAllocationNotification;

  1819.     pfnInternalFree:                                  TvkInternalFreeNotification;

  1820.   end;

  1821.   PVkAllocationCallbacks = ^TVkAllocationCallbacks;

  1822.   PPVkAllocationCallbacks = ^PVkAllocationCallbacks;

  1823. 

  1824.   TVkClearAttachment = record

  1825.     aspectMask:                                       VkImageAspectFlags;

  1826.     colorAttachment:                                  VkUint32;

  1827.     clearValue:                                       TVkClearValue;

  1828.   end;

  1829.   PVkClearAttachment = ^TVkClearAttachment;

  1830.   PPVkClearAttachment = ^PVkClearAttachment;

  1831. 

  1832.   TVkDeviceCreateInfo = record

  1833.     sType:                                            TVkStructureType;

  1834.     pNext:                                            PVkVoid;

  1835.     flags:                                            VkDeviceCreateFlags;

  1836.     queueCreateInfoCount:                             VkUint32;

  1837.     pQueueCreateInfos:                                PVkDeviceQueueCreateInfo;

  1838.     enabledLayerCount:                                VkUint32;

  1839.     ppEnabledLayerNames:                              PPVkChar;

  1840.     enabledExtensionCount:                            VkUint32;

  1841.     ppEnabledExtensionNames:                          PPVkChar;

  1842.     pEnabledFeatures:                                 PVkPhysicalDeviceFeatures;

  1843.   end;

  1844.   PVkDeviceCreateInfo = ^TVkDeviceCreateInfo;

  1845.   PPVkDeviceCreateInfo = ^PVkDeviceCreateInfo;

  1846. 

  1847.   TVkCommandBufferBeginInfo = record

  1848.     sType:                                            TVkStructureType;

  1849.     pNext:                                            PVkVoid;

  1850.     flags:                                            VkCommandBufferUsageFlags;

  1851.     pInheritanceInfo:                                 PVkCommandBufferInheritanceInfo;

  1852.   end;

  1853.   PVkCommandBufferBeginInfo = ^TVkCommandBufferBeginInfo;

  1854.   PPVkCommandBufferBeginInfo = ^PVkCommandBufferBeginInfo;

  1855. 

  1856.   TVkDescriptorSetLayoutCreateInfo = record

  1857.     sType:                                            TVkStructureType;

  1858.     pNext:                                            PVkVoid;

  1859.     flags:                                            VkDescriptorSetLayoutCreateFlags;

  1860.     bindingCount:                                     VkUint32;

  1861.     pBindings:                                        PVkDescriptorSetLayoutBinding;

  1862.   end;

  1863.   PVkDescriptorSetLayoutCreateInfo = ^TVkDescriptorSetLayoutCreateInfo;

  1864.   PPVkDescriptorSetLayoutCreateInfo = ^PVkDescriptorSetLayoutCreateInfo;

  1865. 

  1866.   TVkSparseImageMemoryBindInfo = record

  1867.     image:                                            VkImage;

  1868.     bindCount:                                        VkUint32;

  1869.     pBinds:                                           PVkSparseImageMemoryBind;

  1870.   end;

  1871.   PVkSparseImageMemoryBindInfo = ^TVkSparseImageMemoryBindInfo;

  1872.   PPVkSparseImageMemoryBindInfo = ^PVkSparseImageMemoryBindInfo;

  1873. 

  1874.   TVkBindSparseInfo = record

  1875.     sType:                                            TVkStructureType;

  1876.     pNext:                                            PVkVoid;

  1877.     waitSemaphoreCount:                               VkUint32;

  1878.     pWaitSemaphores:                                  PVkSemaphore;

  1879.     bufferBindCount:                                  VkUint32;

  1880.     pBufferBinds:                                     PVkSparseBufferMemoryBindInfo;

  1881.     imageOpaqueBindCount:                             VkUint32;

  1882.     pImageOpaqueBinds:                                PVkSparseImageOpaqueMemoryBindInfo;

  1883.     imageBindCount:                                   VkUint32;

  1884.     pImageBinds:                                      PVkSparseImageMemoryBindInfo;

  1885.     signalSemaphoreCount:                             VkUint32;

  1886.     pSignalSemaphores:                                PVkSemaphore;

  1887.   end;

  1888.   PVkBindSparseInfo = ^TVkBindSparseInfo;

  1889.   PPVkBindSparseInfo = ^PVkBindSparseInfo;

  1890. 

  1891.   TVkMappedMemoryRange = record

  1892.     sType:                                            TVkStructureType;

  1893.     pNext:                                            PVkVoid;

  1894.     memory:                                           VkDeviceMemory;

  1895.     offset:                                           VkDeviceSize;

  1896.     size:                                             VkDeviceSize;

  1897.   end;

  1898.   PVkMappedMemoryRange = ^TVkMappedMemoryRange;

  1899.   PPVkMappedMemoryRange = ^PVkMappedMemoryRange;

  1900. 

  1901.   TVkMemoryAllocateInfo = record

  1902.     sType:                                            TVkStructureType;

  1903.     pNext:                                            PVkVoid;

  1904.     allocationSize:                                   VkDeviceSize;

  1905.     memoryTypeIndex:                                  VkUint32;

  1906.   end;

  1907.   PVkMemoryAllocateInfo = ^TVkMemoryAllocateInfo;

  1908.   PPVkMemoryAllocateInfo = ^PVkMemoryAllocateInfo;

  1909. 

  1910.   TVkMemoryBarrier = record

  1911.     sType:                                            TVkStructureType;

  1912.     pNext:                                            PVkVoid;

  1913.     srcAccessMask:                                    VkAccessFlags;

  1914.     dstAccessMask:                                    VkAccessFlags;

  1915.   end;

  1916.   PVkMemoryBarrier = ^TVkMemoryBarrier;

  1917.   PPVkMemoryBarrier = ^PVkMemoryBarrier;

  1918. 

  1919.   TVkAttachmentDescription = record

  1920.     flags:                                            VkAttachmentDescriptionFlags;

  1921.     format:                                           TVkFormat;

  1922.     samples:                                          TVkSampleCountFlagBits;

  1923.     loadOp:                                           TVkAttachmentLoadOp;

  1924.     storeOp:                                          TVkAttachmentStoreOp;

  1925.     stencilLoadOp:                                    TVkAttachmentLoadOp;

  1926.     stencilStoreOp:                                   TVkAttachmentStoreOp;

  1927.     initialLayout:                                    TVkImageLayout;

  1928.     finalLayout:                                      TVkImageLayout;

  1929.   end;

  1930.   PVkAttachmentDescription = ^TVkAttachmentDescription;

  1931.   PPVkAttachmentDescription = ^PVkAttachmentDescription;

  1932. 

  1933.   TVkEventCreateInfo = record

  1934.     sType:                                            TVkStructureType;

  1935.     pNext:                                            PVkVoid;

  1936.     flags:                                            VkEventCreateFlags;

  1937.   end;

  1938.   PVkEventCreateInfo = ^TVkEventCreateInfo;

  1939.   PPVkEventCreateInfo = ^PVkEventCreateInfo;

  1940. 

  1941.   TVkFenceCreateInfo = record

  1942.     sType:                                            TVkStructureType;

  1943.     pNext:                                            PVkVoid;

  1944.     flags:                                            VkFenceCreateFlags;

  1945.   end;

  1946.   PVkFenceCreateInfo = ^TVkFenceCreateInfo;

  1947.   PPVkFenceCreateInfo = ^PVkFenceCreateInfo;

  1948. 

  1949.   TVkFramebufferCreateInfo = record

  1950.     sType:                                            TVkStructureType;

  1951.     pNext:                                            PVkVoid;

  1952.     flags:                                            VkFramebufferCreateFlags;

  1953.     renderPass:                                       VkRenderPass;

  1954.     attachmentCount:                                  VkUint32;

  1955.     pAttachments:                                     PVkImageView;

  1956.     width:                                            VkUint32;

  1957.     height:                                           VkUint32;

  1958.     layers:                                           VkUint32;

  1959.   end;

  1960.   PVkFramebufferCreateInfo = ^TVkFramebufferCreateInfo;

  1961.   PPVkFramebufferCreateInfo = ^PVkFramebufferCreateInfo;

  1962. 

  1963.   TVkImageCreateInfo = record

  1964.     sType:                                            TVkStructureType;

  1965.     pNext:                                            PVkVoid;

  1966.     flags:                                            VkImageCreateFlags;

  1967.     imageType:                                        TVkImageType;

  1968.     format:                                           TVkFormat;

  1969.     extent:                                           TVkExtent3D;

  1970.     mipLevels:                                        VkUint32;

  1971.     arrayLayers:                                      VkUint32;

  1972.     samples:                                          TVkSampleCountFlagBits;

  1973.     tiling:                                           TVkImageTiling;

  1974.     usage:                                            VkImageUsageFlags;

  1975.     sharingMode:                                      TVkSharingMode;

  1976.     queueFamilyIndexCount:                            VkUint32;

  1977.     pQueueFamilyIndices:                              PVkUint32;

  1978.     initialLayout:                                    TVkImageLayout;

  1979.   end;

  1980.   PVkImageCreateInfo = ^TVkImageCreateInfo;

  1981.   PPVkImageCreateInfo = ^PVkImageCreateInfo;

  1982. 

  1983.   TVkPipelineCacheCreateInfo = record

  1984.     sType:                                            TVkStructureType;

  1985.     pNext:                                            PVkVoid;

  1986.     flags:                                            VkPipelineCacheCreateFlags;

  1987.     initialDataSize:                                  VkSize;

  1988.     pInitialData:                                     PVkVoid;

  1989.   end;

  1990.   PVkPipelineCacheCreateInfo = ^TVkPipelineCacheCreateInfo;

  1991.   PPVkPipelineCacheCreateInfo = ^PVkPipelineCacheCreateInfo;

  1992. 

  1993.   TVkPipelineDynamicStateCreateInfo = record

  1994.     sType:                                            TVkStructureType;

  1995.     pNext:                                            PVkVoid;

  1996.     flags:                                            VkPipelineDynamicStateCreateFlags;

  1997.     dynamicStateCount:                                VkUint32;

  1998.     pDynamicStates:                                   PVkDynamicState;

  1999.   end;

  2000.   PVkPipelineDynamicStateCreateInfo = ^TVkPipelineDynamicStateCreateInfo;

  2001.   PPVkPipelineDynamicStateCreateInfo = ^PVkPipelineDynamicStateCreateInfo;

  2002. 

  2003.   TVkPipelineInputAssemblyStateCreateInfo = record

  2004.     sType:                                            TVkStructureType;

  2005.     pNext:                                            PVkVoid;

  2006.     flags:                                            VkPipelineInputAssemblyStateCreateFlags;

  2007.     topology:                                         TVkPrimitiveTopology;

  2008.     primitiveRestartEnable:                           VkBool32;

  2009.   end;

  2010.   PVkPipelineInputAssemblyStateCreateInfo = ^TVkPipelineInputAssemblyStateCreateInfo;

  2011.   PPVkPipelineInputAssemblyStateCreateInfo = ^PVkPipelineInputAssemblyStateCreateInfo;

  2012. 

  2013.   TVkPipelineMultisampleStateCreateInfo = record

  2014.     sType:                                            TVkStructureType;

  2015.     pNext:                                            PVkVoid;

  2016.     flags:                                            VkPipelineMultisampleStateCreateFlags;

  2017.     rasterizationSamples:                             TVkSampleCountFlagBits;

  2018.     sampleShadingEnable:                              VkBool32;

  2019.     minSampleShading:                                 VkFloat;

  2020.     pSampleMask:                                      PVkSampleMask;

  2021.     alphaToCoverageEnable:                            VkBool32;

  2022.     alphaToOneEnable:                                 VkBool32;

  2023.   end;

  2024.   PVkPipelineMultisampleStateCreateInfo = ^TVkPipelineMultisampleStateCreateInfo;

  2025.   PPVkPipelineMultisampleStateCreateInfo = ^PVkPipelineMultisampleStateCreateInfo;

  2026. 

  2027.   TVkPipelineRasterizationStateCreateInfo = record

  2028.     sType:                                            TVkStructureType;

  2029.     pNext:                                            PVkVoid;

  2030.     flags:                                            VkPipelineRasterizationStateCreateFlags;

  2031.     depthClampEnable:                                 VkBool32;

  2032.     rasterizerDiscardEnable:                          VkBool32;

  2033.     polygonMode:                                      TVkPolygonMode;

  2034.     cullMode:                                         VkCullModeFlags;

  2035.     frontFace:                                        TVkFrontFace;

  2036.     depthBiasEnable:                                  VkBool32;

  2037.     depthBiasConstantFactor:                          VkFloat;

  2038.     depthBiasClamp:                                   VkFloat;

  2039.     depthBiasSlopeFactor:                             VkFloat;

  2040.     lineWidth:                                        VkFloat;

  2041.   end;

  2042.   PVkPipelineRasterizationStateCreateInfo = ^TVkPipelineRasterizationStateCreateInfo;

  2043.   PPVkPipelineRasterizationStateCreateInfo = ^PVkPipelineRasterizationStateCreateInfo;

  2044. 

  2045.   TVkSubmitInfo = record

  2046.     sType:                                            TVkStructureType;

  2047.     pNext:                                            PVkVoid;

  2048.     waitSemaphoreCount:                               VkUint32;

  2049.     pWaitSemaphores:                                  PVkSemaphore;

  2050.     pWaitDstStageMask:                                PVkPipelineStageFlags;

  2051.     commandBufferCount:                               VkUint32;

  2052.     pCommandBuffers:                                  PVkCommandBuffer;

  2053.     signalSemaphoreCount:                             VkUint32;

  2054.     pSignalSemaphores:                                PVkSemaphore;

  2055.   end;

  2056.   PVkSubmitInfo = ^TVkSubmitInfo;

  2057.   PPVkSubmitInfo = ^PVkSubmitInfo;

  2058. 

  2059.   TVkPipelineTessellationStateCreateInfo = record

  2060.     sType:                                            TVkStructureType;

  2061.     pNext:                                            PVkVoid;

  2062.     flags:                                            VkPipelineTessellationStateCreateFlags;

  2063.     patchControlPoints:                               VkUint32;

  2064.   end;

  2065.   PVkPipelineTessellationStateCreateInfo = ^TVkPipelineTessellationStateCreateInfo;

  2066.   PPVkPipelineTessellationStateCreateInfo = ^PVkPipelineTessellationStateCreateInfo;

  2067. 

  2068.   TVkQueryPoolCreateInfo = record

  2069.     sType:                                            TVkStructureType;

  2070.     pNext:                                            PVkVoid;

  2071.     flags:                                            VkQueryPoolCreateFlags;

  2072.     queryType:                                        TVkQueryType;

  2073.     queryCount:                                       VkUint32;

  2074.     pipelineStatistics:                               VkQueryPipelineStatisticFlags;

  2075.   end;

  2076.   PVkQueryPoolCreateInfo = ^TVkQueryPoolCreateInfo;

  2077.   PPVkQueryPoolCreateInfo = ^PVkQueryPoolCreateInfo;

  2078. 

  2079.   TVkSamplerCreateInfo = record

  2080.     sType:                                            TVkStructureType;

  2081.     pNext:                                            PVkVoid;

  2082.     flags:                                            VkSamplerCreateFlags;

  2083.     magFilter:                                        TVkFilter;

  2084.     minFilter:                                        TVkFilter;

  2085.     mipmapMode:                                       TVkSamplerMipmapMode;

  2086.     addressModeU:                                     TVkSamplerAddressMode;

  2087.     addressModeV:                                     TVkSamplerAddressMode;

  2088.     addressModeW:                                     TVkSamplerAddressMode;

  2089.     mipLodBias:                                       VkFloat;

  2090.     anisotropyEnable:                                 VkBool32;

  2091.     maxAnisotropy:                                    VkFloat;

  2092.     compareEnable:                                    VkBool32;

  2093.     compareOp:                                        TVkCompareOp;

  2094.     minLod:                                           VkFloat;

  2095.     maxLod:                                           VkFloat;

  2096.     borderColor:                                      TVkBorderColor;

  2097.     unnormalizedCoordinates:                          VkBool32;

  2098.   end;

  2099.   PVkSamplerCreateInfo = ^TVkSamplerCreateInfo;

  2100.   PPVkSamplerCreateInfo = ^PVkSamplerCreateInfo;

  2101. 

  2102.   TVkSemaphoreCreateInfo = record

  2103.     sType:                                            TVkStructureType;

  2104.     pNext:                                            PVkVoid;

  2105.     flags:                                            VkSemaphoreCreateFlags;

  2106.   end;

  2107.   PVkSemaphoreCreateInfo = ^TVkSemaphoreCreateInfo;

  2108.   PPVkSemaphoreCreateInfo = ^PVkSemaphoreCreateInfo;

  2109. 

  2110.   TVkShaderModuleCreateInfo = record

  2111.     sType:                                            TVkStructureType;

  2112.     pNext:                                            PVkVoid;

  2113.     flags:                                            VkShaderModuleCreateFlags;

  2114.     codeSize:                                         VkSize;

  2115.     pCode:                                            PVkUint32;

  2116.   end;

  2117.   PVkShaderModuleCreateInfo = ^TVkShaderModuleCreateInfo;

  2118.   PPVkShaderModuleCreateInfo = ^PVkShaderModuleCreateInfo;

  2119. 

  2120.   TVkImageMemoryBarrier = record

  2121.     sType:                                            TVkStructureType;

  2122.     pNext:                                            PVkVoid;

  2123.     srcAccessMask:                                    VkAccessFlags;

  2124.     dstAccessMask:                                    VkAccessFlags;

  2125.     oldLayout:                                        TVkImageLayout;

  2126.     newLayout:                                        TVkImageLayout;

  2127.     srcQueueFamilyIndex:                              VkUint32;

  2128.     dstQueueFamilyIndex:                              VkUint32;

  2129.     image:                                            VkImage;

  2130.     subresourceRange:                                 TVkImageSubresourceRange;

  2131.   end;

  2132.   PVkImageMemoryBarrier = ^TVkImageMemoryBarrier;

  2133.   PPVkImageMemoryBarrier = ^PVkImageMemoryBarrier;

  2134. 

  2135.   TVkPipelineLayoutCreateInfo = record

  2136.     sType:                                            TVkStructureType;

  2137.     pNext:                                            PVkVoid;

  2138.     flags:                                            VkPipelineLayoutCreateFlags;

  2139.     setLayoutCount:                                   VkUint32;

  2140.     pSetLayouts:                                      PVkDescriptorSetLayout;

  2141.     pushConstantRangeCount:                           VkUint32;

  2142.     pPushConstantRanges:                              PVkPushConstantRange;

  2143.   end;

  2144.   PVkPipelineLayoutCreateInfo = ^TVkPipelineLayoutCreateInfo;

  2145.   PPVkPipelineLayoutCreateInfo = ^PVkPipelineLayoutCreateInfo;

  2146. 

  2147.   TVkPipelineViewportStateCreateInfo = record

  2148.     sType:                                            TVkStructureType;

  2149.     pNext:                                            PVkVoid;

  2150.     flags:                                            VkPipelineViewportStateCreateFlags;

  2151.     viewportCount:                                    VkUint32;

  2152.     pViewports:                                       PVkViewport;

  2153.     scissorCount:                                     VkUint32;

  2154.     pScissors:                                        PVkRect2D;

  2155.   end;

  2156.   PVkPipelineViewportStateCreateInfo = ^TVkPipelineViewportStateCreateInfo;

  2157.   PPVkPipelineViewportStateCreateInfo = ^PVkPipelineViewportStateCreateInfo;

  2158. 

  2159.   TVkImageViewCreateInfo = record

  2160.     sType:                                            TVkStructureType;

  2161.     pNext:                                            PVkVoid;

  2162.     flags:                                            VkImageViewCreateFlags;

  2163.     image:                                            VkImage;

  2164.     viewType:                                         TVkImageViewType;

  2165.     format:                                           TVkFormat;

  2166.     components:                                       TVkComponentMapping;

  2167.     subresourceRange:                                 TVkImageSubresourceRange;

  2168.   end;

  2169.   PVkImageViewCreateInfo = ^TVkImageViewCreateInfo;

  2170.   PPVkImageViewCreateInfo = ^PVkImageViewCreateInfo;

  2171. 

  2172.   TVkPipelineDepthStencilStateCreateInfo = record

  2173.     sType:                                            TVkStructureType;

  2174.     pNext:                                            PVkVoid;

  2175.     flags:                                            VkPipelineDepthStencilStateCreateFlags;

  2176.     depthTestEnable:                                  VkBool32;

  2177.     depthWriteEnable:                                 VkBool32;

  2178.     depthCompareOp:                                   TVkCompareOp;

  2179.     depthBoundsTestEnable:                            VkBool32;

  2180.     stencilTestEnable:                                VkBool32;

  2181.     front:                                            TVkStencilOpState;

  2182.     back:                                             TVkStencilOpState;

  2183.     minDepthBounds:                                   VkFloat;

  2184.     maxDepthBounds:                                   VkFloat;

  2185.   end;

  2186.   PVkPipelineDepthStencilStateCreateInfo = ^TVkPipelineDepthStencilStateCreateInfo;

  2187.   PPVkPipelineDepthStencilStateCreateInfo = ^PVkPipelineDepthStencilStateCreateInfo;

  2188. 

  2189.   TVkPipelineVertexInputStateCreateInfo = record

  2190.     sType:                                            TVkStructureType;

  2191.     pNext:                                            PVkVoid;

  2192.     flags:                                            VkPipelineVertexInputStateCreateFlags;

  2193.     vertexBindingDescriptionCount:                    VkUint32;

  2194.     pVertexBindingDescriptions:                       PVkVertexInputBindingDescription;

  2195.     vertexAttributeDescriptionCount:                  VkUint32;

  2196.     pVertexAttributeDescriptions:                     PVkVertexInputAttributeDescription;

  2197.   end;

  2198.   PVkPipelineVertexInputStateCreateInfo = ^TVkPipelineVertexInputStateCreateInfo;

  2199.   PPVkPipelineVertexInputStateCreateInfo = ^PVkPipelineVertexInputStateCreateInfo;

  2200. 

  2201.   TVkInstanceCreateInfo = record

  2202.     sType:                                            TVkStructureType;

  2203.     pNext:                                            PVkVoid;

  2204.     flags:                                            VkInstanceCreateFlags;

  2205.     pApplicationInfo:                                 PVkApplicationInfo;

  2206.     enabledLayerCount:                                VkUint32;

  2207.     ppEnabledLayerNames:                              PPVkChar;

  2208.     enabledExtensionCount:                            VkUint32;

  2209.     ppEnabledExtensionNames:                          PPVkChar;

  2210.   end;

  2211.   PVkInstanceCreateInfo = ^TVkInstanceCreateInfo;

  2212.   PPVkInstanceCreateInfo = ^PVkInstanceCreateInfo;

  2213. 

  2214.   TVkWriteDescriptorSet = record

  2215.     sType:                                            TVkStructureType;

  2216.     pNext:                                            PVkVoid;

  2217.     dstSet:                                           VkDescriptorSet;

  2218.     dstBinding:                                       VkUint32;

  2219.     dstArrayElement:                                  VkUint32;

  2220.     descriptorCount:                                  VkUint32;

  2221.     descriptorType:                                   TVkDescriptorType;

  2222.     pImageInfo:                                       PVkDescriptorImageInfo;

  2223.     pBufferInfo:                                      PVkDescriptorBufferInfo;

  2224.     pTexelBufferView:                                 PVkBufferView;

  2225.   end;

  2226.   PVkWriteDescriptorSet = ^TVkWriteDescriptorSet;

  2227.   PPVkWriteDescriptorSet = ^PVkWriteDescriptorSet;

  2228. 

  2229.   TVkRenderPassBeginInfo = record

  2230.     sType:                                            TVkStructureType;

  2231.     pNext:                                            PVkVoid;

  2232.     renderPass:                                       VkRenderPass;

  2233.     framebuffer:                                      VkFramebuffer;

  2234.     renderArea:                                       TVkRect2D;

  2235.     clearValueCount:                                  VkUint32;

  2236.     pClearValues:                                     PVkClearValue;

  2237.   end;

  2238.   PVkRenderPassBeginInfo = ^TVkRenderPassBeginInfo;

  2239.   PPVkRenderPassBeginInfo = ^PVkRenderPassBeginInfo;

  2240. 

  2241.   TVkPipelineShaderStageCreateInfo = record

  2242.     sType:                                            TVkStructureType;

  2243.     pNext:                                            PVkVoid;

  2244.     flags:                                            VkPipelineShaderStageCreateFlags;

  2245.     stage:                                            TVkShaderStageFlagBits;

  2246.     module:                                           VkShaderModule;

  2247.     pName:                                            PVkChar;

  2248.     pSpecializationInfo:                              PVkSpecializationInfo;

  2249.   end;

  2250.   PVkPipelineShaderStageCreateInfo = ^TVkPipelineShaderStageCreateInfo;

  2251.   PPVkPipelineShaderStageCreateInfo = ^PVkPipelineShaderStageCreateInfo;

  2252. 

  2253.   TVkPipelineColorBlendStateCreateInfo = record

  2254.     sType:                                            TVkStructureType;

  2255.     pNext:                                            PVkVoid;

  2256.     flags:                                            VkPipelineColorBlendStateCreateFlags;

  2257.     logicOpEnable:                                    VkBool32;

  2258.     logicOp:                                          TVkLogicOp;

  2259.     attachmentCount:                                  VkUint32;

  2260.     pAttachments:                                     PVkPipelineColorBlendAttachmentState;

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

  2262.   end;

  2263.   PVkPipelineColorBlendStateCreateInfo = ^TVkPipelineColorBlendStateCreateInfo;

  2264.   PPVkPipelineColorBlendStateCreateInfo = ^PVkPipelineColorBlendStateCreateInfo;

  2265. 

  2266.   TVkRenderPassCreateInfo = record

  2267.     sType:                                            TVkStructureType;

  2268.     pNext:                                            PVkVoid;

  2269.     flags:                                            VkRenderPassCreateFlags;

  2270.     attachmentCount:                                  VkUint32;

  2271.     pAttachments:                                     PVkAttachmentDescription;

  2272.     subpassCount:                                     VkUint32;

  2273.     pSubpasses:                                       PVkSubpassDescription;

  2274.     dependencyCount:                                  VkUint32;

  2275.     pDependencies:                                    PVkSubpassDependency;

  2276.   end;

  2277.   PVkRenderPassCreateInfo = ^TVkRenderPassCreateInfo;

  2278.   PPVkRenderPassCreateInfo = ^PVkRenderPassCreateInfo;

  2279. 

  2280.   TVkComputePipelineCreateInfo = record

  2281.     sType:                                            TVkStructureType;

  2282.     pNext:                                            PVkVoid;

  2283.     flags:                                            VkPipelineCreateFlags;

  2284.     stage:                                            TVkPipelineShaderStageCreateInfo;

  2285.     layout:                                           VkPipelineLayout;

  2286.     basePipelineHandle:                               VkPipeline;

  2287.     basePipelineIndex:                                VkInt32;

  2288.   end;

  2289.   PVkComputePipelineCreateInfo = ^TVkComputePipelineCreateInfo;

  2290.   PPVkComputePipelineCreateInfo = ^PVkComputePipelineCreateInfo;

  2291. 

  2292.   TVkGraphicsPipelineCreateInfo = record

  2293.     sType:                                            TVkStructureType;

  2294.     pNext:                                            PVkVoid;

  2295.     flags:                                            VkPipelineCreateFlags;

  2296.     stageCount:                                       VkUint32;

  2297.     pStages:                                          PVkPipelineShaderStageCreateInfo;

  2298.     pVertexInputState:                                PVkPipelineVertexInputStateCreateInfo;

  2299.     pInputAssemblyState:                              PVkPipelineInputAssemblyStateCreateInfo;

  2300.     pTessellationState:                               PVkPipelineTessellationStateCreateInfo;

  2301.     pViewportState:                                   PVkPipelineViewportStateCreateInfo;

  2302.     pRasterizationState:                              PVkPipelineRasterizationStateCreateInfo;

  2303.     pMultisampleState:                                PVkPipelineMultisampleStateCreateInfo;

  2304.     pDepthStencilState:                               PVkPipelineDepthStencilStateCreateInfo;

  2305.     pColorBlendState:                                 PVkPipelineColorBlendStateCreateInfo;

  2306.     pDynamicState:                                    PVkPipelineDynamicStateCreateInfo;

  2307.     layout:                                           VkPipelineLayout;

  2308.     renderPass:                                       VkRenderPass;

  2309.     subpass:                                          VkUint32;

  2310.     basePipelineHandle:                               VkPipeline;

  2311.     basePipelineIndex:                                VkInt32;

  2312.   end;

  2313.   PVkGraphicsPipelineCreateInfo = ^TVkGraphicsPipelineCreateInfo;

  2314.   PPVkGraphicsPipelineCreateInfo = ^PVkGraphicsPipelineCreateInfo;

  2315. 

  2316. type { commands }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2363.   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};

  2364.   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};

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

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

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

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

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

  2370.   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};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2392.   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};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2430.   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};

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

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

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

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

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

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

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

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

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

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

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

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

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

  2444.   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};

  2445.   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};

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

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

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

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

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

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

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

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

  2454. 

  2455. var { command variables }

  2456.   vkCmdDispatch:                                     TvkCmdDispatch = nil;

  2457.   vkCmdDraw:                                         TvkCmdDraw = nil;

  2458.   vkCmdDrawIndexed:                                  TvkCmdDrawIndexed = nil;

  2459.   vkCmdEndRenderPass:                                TvkCmdEndRenderPass = nil;

  2460.   vkCmdExecuteCommands:                              TvkCmdExecuteCommands = nil;

  2461.   vkCmdSetBlendConstants:                            TvkCmdSetBlendConstants = nil;

  2462.   vkCmdSetDepthBias:                                 TvkCmdSetDepthBias = nil;

  2463.   vkDeviceWaitIdle:                                  TvkDeviceWaitIdle = nil;

  2464.   vkGetDeviceProcAddr:                               TvkGetDeviceProcAddr = nil;

  2465.   vkGetInstanceProcAddr:                             TvkGetInstanceProcAddr = nil;

  2466.   vkEnumeratePhysicalDevices:                        TvkEnumeratePhysicalDevices = nil;

  2467.   vkGetDeviceQueue:                                  TvkGetDeviceQueue = nil;

  2468.   vkQueueWaitIdle:                                   TvkQueueWaitIdle = nil;

  2469.   vkCmdSetDepthBounds:                               TvkCmdSetDepthBounds = nil;

  2470.   vkCmdSetLineWidth:                                 TvkCmdSetLineWidth = nil;

  2471.   vkEndCommandBuffer:                                TvkEndCommandBuffer = nil;

  2472.   vkFreeCommandBuffers:                              TvkFreeCommandBuffers = nil;

  2473.   vkFreeDescriptorSets:                              TvkFreeDescriptorSets = nil;

  2474.   vkUnmapMemory:                                     TvkUnmapMemory = nil;

  2475.   vkGetEventStatus:                                  TvkGetEventStatus = nil;

  2476.   vkResetEvent:                                      TvkResetEvent = nil;

  2477.   vkSetEvent:                                        TvkSetEvent = nil;

  2478.   vkGetFenceStatus:                                  TvkGetFenceStatus = nil;

  2479.   vkResetFences:                                     TvkResetFences = nil;

  2480.   vkGetPipelineCacheData:                            TvkGetPipelineCacheData = nil;

  2481.   vkMergePipelineCaches:                             TvkMergePipelineCaches = nil;

  2482.   vkCmdEndQuery:                                     TvkCmdEndQuery = nil;

  2483.   vkCmdResetQueryPool:                               TvkCmdResetQueryPool = nil;

  2484.   vkWaitForFences:                                   TvkWaitForFences = nil;

  2485.   vkGetRenderAreaGranularity:                        TvkGetRenderAreaGranularity = nil;

  2486.   vkBindBufferMemory:                                TvkBindBufferMemory = nil;

  2487.   vkBindImageMemory:                                 TvkBindImageMemory = nil;

  2488.   vkCmdBindVertexBuffers:                            TvkCmdBindVertexBuffers = nil;

  2489.   vkCmdDispatchIndirect:                             TvkCmdDispatchIndirect = nil;

  2490.   vkCmdDrawIndexedIndirect:                          TvkCmdDrawIndexedIndirect = nil;

  2491.   vkCmdDrawIndirect:                                 TvkCmdDrawIndirect = nil;

  2492.   vkCmdFillBuffer:                                   TvkCmdFillBuffer = nil;

  2493.   vkCmdUpdateBuffer:                                 TvkCmdUpdateBuffer = nil;

  2494.   vkGetDeviceMemoryCommitment:                       TvkGetDeviceMemoryCommitment = nil;

  2495.   vkResetCommandBuffer:                              TvkResetCommandBuffer = nil;

  2496.   vkResetCommandPool:                                TvkResetCommandPool = nil;

  2497.   vkResetDescriptorPool:                             TvkResetDescriptorPool = nil;

  2498.   vkMapMemory:                                       TvkMapMemory = nil;

  2499.   vkCmdResetEvent:                                   TvkCmdResetEvent = nil;

  2500.   vkCmdSetEvent:                                     TvkCmdSetEvent = nil;

  2501.   vkCmdBeginQuery:                                   TvkCmdBeginQuery = nil;

  2502.   vkCmdCopyQueryPoolResults:                         TvkCmdCopyQueryPoolResults = nil;

  2503.   vkGetQueryPoolResults:                             TvkGetQueryPoolResults = nil;

  2504.   vkCmdPushConstants:                                TvkCmdPushConstants = nil;

  2505.   vkCmdSetStencilCompareMask:                        TvkCmdSetStencilCompareMask = nil;

  2506.   vkCmdSetStencilReference:                          TvkCmdSetStencilReference = nil;

  2507.   vkCmdSetStencilWriteMask:                          TvkCmdSetStencilWriteMask = nil;

  2508.   vkCmdBindPipeline:                                 TvkCmdBindPipeline = nil;

  2509.   vkCmdBindDescriptorSets:                           TvkCmdBindDescriptorSets = nil;

  2510.   vkCmdSetViewport:                                  TvkCmdSetViewport = nil;

  2511.   vkEnumerateDeviceExtensionProperties:              TvkEnumerateDeviceExtensionProperties = nil;

  2512.   vkEnumerateInstanceExtensionProperties:            TvkEnumerateInstanceExtensionProperties = nil;

  2513.   vkEnumerateDeviceLayerProperties:                  TvkEnumerateDeviceLayerProperties = nil;

  2514.   vkEnumerateInstanceLayerProperties:                TvkEnumerateInstanceLayerProperties = nil;

  2515.   vkCmdBindIndexBuffer:                              TvkCmdBindIndexBuffer = nil;

  2516.   vkGetPhysicalDeviceFeatures:                       TvkGetPhysicalDeviceFeatures = nil;

  2517.   vkCmdCopyBuffer:                                   TvkCmdCopyBuffer = nil;

  2518.   vkGetBufferMemoryRequirements:                     TvkGetBufferMemoryRequirements = nil;

  2519.   vkGetImageMemoryRequirements:                      TvkGetImageMemoryRequirements = nil;

  2520.   vkGetPhysicalDeviceFormatProperties:               TvkGetPhysicalDeviceFormatProperties = nil;

  2521.   vkGetImageSubresourceLayout:                       TvkGetImageSubresourceLayout = nil;

  2522.   vkCmdClearColorImage:                              TvkCmdClearColorImage = nil;

  2523.   vkCmdClearDepthStencilImage:                       TvkCmdClearDepthStencilImage = nil;

  2524.   vkCmdSetScissor:                                   TvkCmdSetScissor = nil;

  2525.   vkGetPhysicalDeviceQueueFamilyProperties:          TvkGetPhysicalDeviceQueueFamilyProperties = nil;

  2526.   vkGetPhysicalDeviceImageFormatProperties:          TvkGetPhysicalDeviceImageFormatProperties = nil;

  2527.   vkAllocateCommandBuffers:                          TvkAllocateCommandBuffers = nil;

  2528.   vkAllocateDescriptorSets:                          TvkAllocateDescriptorSets = nil;

  2529.   vkCmdCopyBufferToImage:                            TvkCmdCopyBufferToImage = nil;

  2530.   vkCmdCopyImageToBuffer:                            TvkCmdCopyImageToBuffer = nil;

  2531.   vkCmdBlitImage:                                    TvkCmdBlitImage = nil;

  2532.   vkCmdCopyImage:                                    TvkCmdCopyImage = nil;

  2533.   vkCmdResolveImage:                                 TvkCmdResolveImage = nil;

  2534.   vkGetPhysicalDeviceMemoryProperties:               TvkGetPhysicalDeviceMemoryProperties = nil;

  2535.   vkGetPhysicalDeviceProperties:                     TvkGetPhysicalDeviceProperties = nil;

  2536.   vkGetImageSparseMemoryRequirements:                TvkGetImageSparseMemoryRequirements = nil;

  2537.   vkCreateBuffer:                                    TvkCreateBuffer = nil;

  2538.   vkCreateBufferView:                                TvkCreateBufferView = nil;

  2539.   vkCreateCommandPool:                               TvkCreateCommandPool = nil;

  2540.   vkCreateDescriptorPool:                            TvkCreateDescriptorPool = nil;

  2541.   vkDestroyBuffer:                                   TvkDestroyBuffer = nil;

  2542.   vkDestroyBufferView:                               TvkDestroyBufferView = nil;

  2543.   vkDestroyCommandPool:                              TvkDestroyCommandPool = nil;

  2544.   vkDestroyDescriptorPool:                           TvkDestroyDescriptorPool = nil;

  2545.   vkDestroyDescriptorSetLayout:                      TvkDestroyDescriptorSetLayout = nil;

  2546.   vkDestroyDevice:                                   TvkDestroyDevice = nil;

  2547.   vkDestroyEvent:                                    TvkDestroyEvent = nil;

  2548.   vkDestroyFence:                                    TvkDestroyFence = nil;

  2549.   vkDestroyFramebuffer:                              TvkDestroyFramebuffer = nil;

  2550.   vkDestroyImage:                                    TvkDestroyImage = nil;

  2551.   vkDestroyImageView:                                TvkDestroyImageView = nil;

  2552.   vkDestroyInstance:                                 TvkDestroyInstance = nil;

  2553.   vkDestroyPipeline:                                 TvkDestroyPipeline = nil;

  2554.   vkDestroyPipelineCache:                            TvkDestroyPipelineCache = nil;

  2555.   vkDestroyPipelineLayout:                           TvkDestroyPipelineLayout = nil;

  2556.   vkDestroyQueryPool:                                TvkDestroyQueryPool = nil;

  2557.   vkDestroyRenderPass:                               TvkDestroyRenderPass = nil;

  2558.   vkDestroySampler:                                  TvkDestroySampler = nil;

  2559.   vkDestroySemaphore:                                TvkDestroySemaphore = nil;

  2560.   vkDestroyShaderModule:                             TvkDestroyShaderModule = nil;

  2561.   vkFreeMemory:                                      TvkFreeMemory = nil;

  2562.   vkCmdClearAttachments:                             TvkCmdClearAttachments = nil;

  2563.   vkCreateDevice:                                    TvkCreateDevice = nil;

  2564.   vkBeginCommandBuffer:                              TvkBeginCommandBuffer = nil;

  2565.   vkCreateDescriptorSetLayout:                       TvkCreateDescriptorSetLayout = nil;

  2566.   vkQueueBindSparse:                                 TvkQueueBindSparse = nil;

  2567.   vkCmdNextSubpass:                                  TvkCmdNextSubpass = nil;

  2568.   vkCmdWriteTimestamp:                               TvkCmdWriteTimestamp = nil;

  2569.   vkGetPhysicalDeviceSparseImageFormatProperties:    TvkGetPhysicalDeviceSparseImageFormatProperties = nil;

  2570.   vkFlushMappedMemoryRanges:                         TvkFlushMappedMemoryRanges = nil;

  2571.   vkInvalidateMappedMemoryRanges:                    TvkInvalidateMappedMemoryRanges = nil;

  2572.   vkAllocateMemory:                                  TvkAllocateMemory = nil;

  2573.   vkCreateEvent:                                     TvkCreateEvent = nil;

  2574.   vkCreateFence:                                     TvkCreateFence = nil;

  2575.   vkCreateFramebuffer:                               TvkCreateFramebuffer = nil;

  2576.   vkCreateImage:                                     TvkCreateImage = nil;

  2577.   vkCreatePipelineCache:                             TvkCreatePipelineCache = nil;

  2578.   vkQueueSubmit:                                     TvkQueueSubmit = nil;

  2579.   vkCreateQueryPool:                                 TvkCreateQueryPool = nil;

  2580.   vkCreateSampler:                                   TvkCreateSampler = nil;

  2581.   vkCreateSemaphore:                                 TvkCreateSemaphore = nil;

  2582.   vkCreateShaderModule:                              TvkCreateShaderModule = nil;

  2583.   vkCmdPipelineBarrier:                              TvkCmdPipelineBarrier = nil;

  2584.   vkCmdWaitEvents:                                   TvkCmdWaitEvents = nil;

  2585.   vkCreatePipelineLayout:                            TvkCreatePipelineLayout = nil;

  2586.   vkCmdBeginRenderPass:                              TvkCmdBeginRenderPass = nil;

  2587.   vkCreateRenderPass:                                TvkCreateRenderPass = nil;

  2588.   vkCreateComputePipelines:                          TvkCreateComputePipelines = nil;

  2589.   vkCreateGraphicsPipelines:                         TvkCreateGraphicsPipelines = nil;

  2590.   vkCreateImageView:                                 TvkCreateImageView = nil;

  2591.   vkCreateInstance:                                  TvkCreateInstance = nil;

  2592.   vkUpdateDescriptorSets:                            TvkUpdateDescriptorSets = nil;

  2593. 

  2594. const

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

  2596. 

  2597. type

  2598.   VkVersion = VkInt32;

  2599. 

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

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

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

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

  2604. 

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

  2606. procedure FinalizeVulkan;

  2607. 

  2608. implementation

  2609. 

  2610. type

  2611. {$IF DEFINED(VK_WIN)}

  2612.   TvkLibHandle = TLibHandle;

  2613. {$ELSE}

  2614.   TvkLibHandle = Pointer;

  2615. {$ENDIF}

  2616. 

  2617. const

  2618. {$IF DEFINED(VK_WIN)}

  2619.   InvalidLibHandle = 0;

  2620. {$ELSE}

  2621.   InvalidLibHandle = nil;

  2622. {$ENDIF}

  2623. 

  2624. var

  2625.   vkLibHandle: TvkLibHandle = InvalidLibHandle;

  2626. 

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

  2628. begin

  2629.   {$IF DEFINED(VK_WIN)}

  2630.   result := LoadLibrary(aLibName);

  2631.   {$ELSE}

  2632.   result := InvalidLibHandle;

  2633.   {$ENDIF}

  2634. end;

  2635. 

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

  2637. begin

  2638.   if (aLibHandle = InvalidLibHandle) then

  2639.     aLibHandle := vkLibHandle;

  2640.   {$IF DEFINED(VK_WIN)}

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

  2642.   {$ELSE}

  2643.   result := nil;

  2644.   {$ENDIF}

  2645. end;

  2646. 

  2647. procedure vkFreeLibrary(var aLibHandle: TvkLibHandle);

  2648. begin

  2649.   if (aLibHandle <> InvalidLibHandle) then begin

  2650.     {$IF DEFINED(VK_WIN)}

  2651.     FreeLibrary(aLibHandle);

  2652.     {$ENDIF}

  2653.     aLibHandle := InvalidLibHandle;

  2654.   end;

  2655. end;

  2656. 

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

  2658. begin

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

  2660. end;

  2661. 

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

  2663. begin

  2664.   result := (aVersion shr 22);

  2665. end;

  2666. 

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

  2668. begin

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

  2670. end;

  2671. 

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

  2673. begin

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

  2675. end;

  2676. 

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

  2678. begin

  2679.   FinalizeVulkan;

  2680.   vkLibHandle := vkLoadLibrary(aLibName);

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

  2682.   if not result then

  2683.     exit;

  2684. 

  2685. {********************************* VK_VERSION_1_0 *********************************}

  2686. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2824. 

  2825. end;

  2826. 

  2827. procedure FinalizeVulkan;

  2828. begin

  2829.   vkFreeLibrary(vkLibHandle);

  2830. end;

  2831. 

  2832. initialization

  2833. 

  2834. finalization

  2835.   FinalizeVulkan;

  2836. 

  2837. end.