Vulkan/projects/Vulkan.pas

{ ============================================================================
  This file is autogenerated from vk.xml
  You may retrieve the latest version of this file at the Delphi OpenGL
  Community home page, located at http://www.delphigl.com/
  
  The contents of this file are used with permission, subject to
  the Mozilla Public License Version 1.1 (the "License"); you may
  not use this file except in compliance with the License. You may
  obtain a copy of the License at
  http://www.mozilla.org/MPL/MPL-1.1.html
  
  Software distributed under the License is distributed on an
  "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  implied. See the License for the specific language governing
  rights and limitations under the License.

Original vk.xml comment:
==============================================================================
Copyright (c) 2015-2016 The Khronos Group Inc.

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and/or associated documentation files (the
"Materials"), to deal in the Materials without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Materials, and to
permit persons to whom the Materials are furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Materials.

THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

------------------------------------------------------------------------

This file, vk.xml, is the Vulkan API Registry. It is a critically important
and normative part of the Vulkan Specification, including a canonical
machine-readable definition of the API, parameter and member validation
language incorporated into the Specification and reference pages, and other
material which is registered by Khronos, such as tags used by extension and
layer authors. The only authoritative version of vk.xml is the one
maintained in the master branch of the Khronos Vulkan Github project.

============================================================================ }
  
unit Vulkan;

{$IFDEF FPC}
  {$MODE Delphi}
  {$IFNDEF WINDOWS}
    {$LINKLIB c}
  {$ENDIF}
  {$MINENUMSIZE 4}
  {$PACKSET 4}  
{$ENDIF}

{$I Vulkan.inc}

interface

type
  VkUint8                   = Byte;
  VkUint16                  = Word;
  VkUint32                  = Cardinal;
  VkUint64                  = QWord;
  VkInt16                   = SmallInt;
  VkInt32                   = Integer;
  VkInt64                   = Int64;
  VkFloat                   = Single;
  VkDouble                  = Double;
  VkChar                    = AnsiChar;
  VkSize                    = SizeUInt;
  VkHandle                  = Pointer;
  VkNonDispatchableHandle   = {$IFDEF VK_CPU64}Pointer{$ELSE}VkUint64{$ENDIF};

const
  VK_INVALID_HANDLE:     VkHandle                = nil;
  VK_INVALID_NDP_HANDLE: VkNonDispatchableHandle = {$IFDEF VK_CPU64}nil{$ELSE}0{$ENDIF};

type
{$IFDEF VK_USE_PLATFORM_WIN32_KHR}
  HINSTANCE = VkHandle;
  HWND      = VkHandle;
{$ENDIF}

  PVkVoid   = Pointer;
  PVkHandle = ^VkHandle;
  PVkUint8  = ^VkUint8;
  PVkUint16 = ^VkUint16;
  PVkUint32 = ^VkUint32;
  PVkUint64 = ^VkUint64;
  PVkInt16  = ^VkInt16;
  PVkInt32  = ^VkInt32;
  PVkInt64  = ^VkInt64;
  PVkFloat  = ^VkFloat;
  PVkDouble = ^VkDouble;
  PVkChar   = ^VkChar;
  PVkSize   = ^VkSize;
  
  PPVkVoid   = ^PVkVoid;
  PPVkHandle = ^PVkHandle;
  PPVkUint8  = ^PVkUint8;
  PPVkUint16 = ^PVkUint16;
  PPVkUint32 = ^PVkUint32;
  PPVkUint64 = ^PVkUint64;
  PPVkInt16  = ^PVkInt16;
  PPVkInt32  = ^PVkInt32;
  PPVkInt64  = ^PVkInt64;
  PPVkFloat  = ^PVkFloat;
  PPVkDouble = ^PVkDouble;
  PPVkChar   = ^PVkChar;
  PPVkSize   = ^PVkSize;

const
  VK_API_VERSION                                                 = 4194307;
  VK_API_VERSION_MAJOR                                           = 1;
  VK_API_VERSION_MINOR                                           = 0;
  VK_API_VERSION_BUGFIX                                          = 3;

{ ========================================== VK_VERSION_1_0 ========================================== }
  VK_LOD_CLAMP_NONE                                              = 1000;
  VK_REMAINING_MIP_LEVELS                                        = $FFFFFFFF;
  VK_REMAINING_ARRAY_LAYERS                                      = $FFFFFFFF;
  VK_WHOLE_SIZE                                                  = $FFFFFFFF;
  VK_ATTACHMENT_UNUSED                                           = $FFFFFFFF;
  VK_TRUE                                                        = 1;
  VK_FALSE                                                       = 0;
  VK_QUEUE_FAMILY_IGNORED                                        = $FFFFFFFF;
  VK_SUBPASS_EXTERNAL                                            = $FFFFFFFF;
  VK_MAX_PHYSICAL_DEVICE_NAME_SIZE                               = 256;
  VK_UUID_SIZE                                                   = 16;
  VK_MAX_MEMORY_TYPES                                            = 32;
  VK_MAX_MEMORY_HEAPS                                            = 16;
  VK_MAX_EXTENSION_NAME_SIZE                                     = 256;
  VK_MAX_DESCRIPTION_SIZE                                        = 256;

{ ========================================== VK_KHR_surface ========================================== }
  VK_KHR_SURFACE_SPEC_VERSION                                    = 25;
  VK_KHR_SURFACE_EXTENSION_NAME                                  = 'VK_KHR_surface';

{ ========================================= VK_KHR_swapchain ========================================= }
  VK_KHR_SWAPCHAIN_SPEC_VERSION                                  = 67;
  VK_KHR_SWAPCHAIN_EXTENSION_NAME                                = 'VK_KHR_swapchain';

{ ========================================== VK_KHR_display ========================================== }
  VK_KHR_DISPLAY_SPEC_VERSION                                    = 21;
  VK_KHR_DISPLAY_EXTENSION_NAME                                  = 'VK_KHR_display';

{ ===================================== VK_KHR_display_swapchain ===================================== }
  VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION                          = 9;
  VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME                        = 'VK_KHR_display_swapchain';

{ ======================================= VK_KHR_xlib_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_XLIB_KHR}
  VK_KHR_XLIB_SURFACE_SPEC_VERSION                               = 6;
  VK_KHR_XLIB_SURFACE_EXTENSION_NAME                             = 'VK_KHR_xlib_surface';
{$ENDIF}

{ ======================================== VK_KHR_xcb_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_XCB_KHR}
  VK_KHR_XCB_SURFACE_SPEC_VERSION                                = 6;
  VK_KHR_XCB_SURFACE_EXTENSION_NAME                              = 'VK_KHR_xcb_surface';
{$ENDIF}

{ ====================================== VK_KHR_wayland_surface ====================================== }
{$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}
  VK_KHR_WAYLAND_SURFACE_SPEC_VERSION                            = 5;
  VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME                          = 'VK_KHR_wayland_surface';
{$ENDIF}

{ ======================================== VK_KHR_mir_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_MIR_KHR}
  VK_KHR_MIR_SURFACE_SPEC_VERSION                                = 4;
  VK_KHR_MIR_SURFACE_EXTENSION_NAME                              = 'VK_KHR_mir_surface';
{$ENDIF}

{ ====================================== VK_KHR_android_surface ====================================== }
{$IFDEF VK_USE_PLATFORM_ANDROID_KHR}
  VK_KHR_ANDROID_SURFACE_SPEC_VERSION                            = 6;
  VK_KHR_ANDROID_SURFACE_EXTENSION_NAME                          = 'VK_KHR_android_surface';
{$ENDIF}

{ ======================================= VK_KHR_win32_surface ======================================= }
{$IFDEF VK_USE_PLATFORM_WIN32_KHR}
  VK_KHR_WIN32_SURFACE_SPEC_VERSION                              = 5;
  VK_KHR_WIN32_SURFACE_EXTENSION_NAME                            = 'VK_KHR_win32_surface';
{$ENDIF}

{ ======================================= VK_EXT_debug_report ======================================== }
  VK_EXT_DEBUG_REPORT_SPEC_VERSION                               = 1;
  VK_EXT_DEBUG_REPORT_EXTENSION_NAME                             = 'VK_EXT_debug_report';

type { enumerations }

{ ========================================== VK_VERSION_1_0 ========================================== }
  TVkPipelineCacheHeaderVersion = (
    VK_PIPELINE_CACHE_HEADER_VERSION_ONE                         = 1,
    VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM                    = $7FFFFFFF
  );
  PVkPipelineCacheHeaderVersion = ^TVkPipelineCacheHeaderVersion;
  PPVkPipelineCacheHeaderVersion = ^PVkPipelineCacheHeaderVersion;

  TVkResult = (
    VK_SUCCESS                                                   = 0,
    VK_NOT_READY                                                 = 1,
    VK_TIMEOUT                                                   = 2,
    VK_EVENT_SET                                                 = 3,
    VK_EVENT_RESET                                               = 4,
    VK_INCOMPLETE                                                = 5,
    VK_ERROR_OUT_OF_HOST_MEMORY                                  = -1,
    VK_ERROR_OUT_OF_DEVICE_MEMORY                                = -2,
    VK_ERROR_INITIALIZATION_FAILED                               = -3,
    VK_ERROR_DEVICE_LOST                                         = -4,
    VK_ERROR_MEMORY_MAP_FAILED                                   = -5,
    VK_ERROR_LAYER_NOT_PRESENT                                   = -6,
    VK_ERROR_EXTENSION_NOT_PRESENT                               = -7,
    VK_ERROR_FEATURE_NOT_PRESENT                                 = -8,
    VK_ERROR_INCOMPATIBLE_DRIVER                                 = -9,
    VK_ERROR_TOO_MANY_OBJECTS                                    = -10,
    VK_ERROR_FORMAT_NOT_SUPPORTED                                = -11,
    VK_ERROR_SURFACE_LOST_KHR                                    = -1000000000,
    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR                            = -1000000001,
    VK_SUBOPTIMAL_KHR                                            = 1000001003,
    VK_ERROR_OUT_OF_DATE_KHR                                     = -1000001004,
    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR                            = -1000003001,
    VK_ERROR_VALIDATION_FAILED_EXT                               = -1000011001,
    VK__MAX_ENUM                                                 = $7FFFFFFF
  );
  PVkResult = ^TVkResult;
  PPVkResult = ^PVkResult;

  TVkStructureType = (
    VK_STRUCTURE_TYPE_APPLICATION_INFO                           = 0,
    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO                       = 1,
    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO                   = 2,
    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO                         = 3,
    VK_STRUCTURE_TYPE_SUBMIT_INFO                                = 4,
    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO                       = 5,
    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE                        = 6,
    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO                           = 7,
    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO                          = 8,
    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO                      = 9,
    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO                          = 10,
    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO                     = 11,
    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO                         = 12,
    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO                    = 13,
    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO                          = 14,
    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO                     = 15,
    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO                  = 16,
    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO                 = 17,
    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO          = 18,
    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO    = 19,
    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO  = 20,
    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO    = 21,
    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO        = 22,
    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO   = 23,
    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO     = 24,
    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO   = 25,
    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO     = 26,
    VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO         = 27,
    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO              = 28,
    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO               = 29,
    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO                = 30,
    VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO                        = 31,
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO          = 32,
    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO                = 33,
    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO               = 34,
    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET                       = 35,
    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET                        = 36,
    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO                    = 37,
    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO                    = 38,
    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO                   = 39,
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO               = 40,
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO            = 41,
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO                  = 42,
    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO                     = 43,
    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER                      = 44,
    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER                       = 45,
    VK_STRUCTURE_TYPE_MEMORY_BARRIER                             = 46,
    VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO                = 47,
    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO                  = 48,
    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR                  = 1000001000,
    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR                           = 1000001001,
    VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR               = 1000002000,
    VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR            = 1000002001,
    VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR                   = 1000003000,
    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR               = 1000004000,
    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR                = 1000005000,
    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR            = 1000006000,
    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR                = 1000007000,
    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR            = 1000008000,
    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR              = 1000009000,
    VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT               = 1000011000,
    VK_STRUCTURE_TYPE_MAX_ENUM                                   = $7FFFFFFF
  );
  PVkStructureType = ^TVkStructureType;
  PPVkStructureType = ^PVkStructureType;

  TVkSystemAllocationScope = (
    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND                           = 0,
    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT                            = 1,
    VK_SYSTEM_ALLOCATION_SCOPE_CACHE                             = 2,
    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE                            = 3,
    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE                          = 4,
    VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM                          = $7FFFFFFF
  );
  PVkSystemAllocationScope = ^TVkSystemAllocationScope;
  PPVkSystemAllocationScope = ^PVkSystemAllocationScope;

  TVkInternalAllocationType = (
    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE                       = 0,
    VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM                         = $7FFFFFFF
  );
  PVkInternalAllocationType = ^TVkInternalAllocationType;
  PPVkInternalAllocationType = ^PVkInternalAllocationType;

  TVkFormat = (
    VK_FORMAT_UNDEFINED                                          = 0,
    VK_FORMAT_R4G4_UNORM_PACK8                                   = 1,
    VK_FORMAT_R4G4B4A4_UNORM_PACK16                              = 2,
    VK_FORMAT_B4G4R4A4_UNORM_PACK16                              = 3,
    VK_FORMAT_R5G6B5_UNORM_PACK16                                = 4,
    VK_FORMAT_B5G6R5_UNORM_PACK16                                = 5,
    VK_FORMAT_R5G5B5A1_UNORM_PACK16                              = 6,
    VK_FORMAT_B5G5R5A1_UNORM_PACK16                              = 7,
    VK_FORMAT_A1R5G5B5_UNORM_PACK16                              = 8,
    VK_FORMAT_R8_UNORM                                           = 9,
    VK_FORMAT_R8_SNORM                                           = 10,
    VK_FORMAT_R8_USCALED                                         = 11,
    VK_FORMAT_R8_SSCALED                                         = 12,
    VK_FORMAT_R8_UINT                                            = 13,
    VK_FORMAT_R8_SINT                                            = 14,
    VK_FORMAT_R8_SRGB                                            = 15,
    VK_FORMAT_R8G8_UNORM                                         = 16,
    VK_FORMAT_R8G8_SNORM                                         = 17,
    VK_FORMAT_R8G8_USCALED                                       = 18,
    VK_FORMAT_R8G8_SSCALED                                       = 19,
    VK_FORMAT_R8G8_UINT                                          = 20,
    VK_FORMAT_R8G8_SINT                                          = 21,
    VK_FORMAT_R8G8_SRGB                                          = 22,
    VK_FORMAT_R8G8B8_UNORM                                       = 23,
    VK_FORMAT_R8G8B8_SNORM                                       = 24,
    VK_FORMAT_R8G8B8_USCALED                                     = 25,
    VK_FORMAT_R8G8B8_SSCALED                                     = 26,
    VK_FORMAT_R8G8B8_UINT                                        = 27,
    VK_FORMAT_R8G8B8_SINT                                        = 28,
    VK_FORMAT_R8G8B8_SRGB                                        = 29,
    VK_FORMAT_B8G8R8_UNORM                                       = 30,
    VK_FORMAT_B8G8R8_SNORM                                       = 31,
    VK_FORMAT_B8G8R8_USCALED                                     = 32,
    VK_FORMAT_B8G8R8_SSCALED                                     = 33,
    VK_FORMAT_B8G8R8_UINT                                        = 34,
    VK_FORMAT_B8G8R8_SINT                                        = 35,
    VK_FORMAT_B8G8R8_SRGB                                        = 36,
    VK_FORMAT_R8G8B8A8_UNORM                                     = 37,
    VK_FORMAT_R8G8B8A8_SNORM                                     = 38,
    VK_FORMAT_R8G8B8A8_USCALED                                   = 39,
    VK_FORMAT_R8G8B8A8_SSCALED                                   = 40,
    VK_FORMAT_R8G8B8A8_UINT                                      = 41,
    VK_FORMAT_R8G8B8A8_SINT                                      = 42,
    VK_FORMAT_R8G8B8A8_SRGB                                      = 43,
    VK_FORMAT_B8G8R8A8_UNORM                                     = 44,
    VK_FORMAT_B8G8R8A8_SNORM                                     = 45,
    VK_FORMAT_B8G8R8A8_USCALED                                   = 46,
    VK_FORMAT_B8G8R8A8_SSCALED                                   = 47,
    VK_FORMAT_B8G8R8A8_UINT                                      = 48,
    VK_FORMAT_B8G8R8A8_SINT                                      = 49,
    VK_FORMAT_B8G8R8A8_SRGB                                      = 50,
    VK_FORMAT_A8B8G8R8_UNORM_PACK32                              = 51,
    VK_FORMAT_A8B8G8R8_SNORM_PACK32                              = 52,
    VK_FORMAT_A8B8G8R8_USCALED_PACK32                            = 53,
    VK_FORMAT_A8B8G8R8_SSCALED_PACK32                            = 54,
    VK_FORMAT_A8B8G8R8_UINT_PACK32                               = 55,
    VK_FORMAT_A8B8G8R8_SINT_PACK32                               = 56,
    VK_FORMAT_A8B8G8R8_SRGB_PACK32                               = 57,
    VK_FORMAT_A2R10G10B10_UNORM_PACK32                           = 58,
    VK_FORMAT_A2R10G10B10_SNORM_PACK32                           = 59,
    VK_FORMAT_A2R10G10B10_USCALED_PACK32                         = 60,
    VK_FORMAT_A2R10G10B10_SSCALED_PACK32                         = 61,
    VK_FORMAT_A2R10G10B10_UINT_PACK32                            = 62,
    VK_FORMAT_A2R10G10B10_SINT_PACK32                            = 63,
    VK_FORMAT_A2B10G10R10_UNORM_PACK32                           = 64,
    VK_FORMAT_A2B10G10R10_SNORM_PACK32                           = 65,
    VK_FORMAT_A2B10G10R10_USCALED_PACK32                         = 66,
    VK_FORMAT_A2B10G10R10_SSCALED_PACK32                         = 67,
    VK_FORMAT_A2B10G10R10_UINT_PACK32                            = 68,
    VK_FORMAT_A2B10G10R10_SINT_PACK32                            = 69,
    VK_FORMAT_R16_UNORM                                          = 70,
    VK_FORMAT_R16_SNORM                                          = 71,
    VK_FORMAT_R16_USCALED                                        = 72,
    VK_FORMAT_R16_SSCALED                                        = 73,
    VK_FORMAT_R16_UINT                                           = 74,
    VK_FORMAT_R16_SINT                                           = 75,
    VK_FORMAT_R16_SFLOAT                                         = 76,
    VK_FORMAT_R16G16_UNORM                                       = 77,
    VK_FORMAT_R16G16_SNORM                                       = 78,
    VK_FORMAT_R16G16_USCALED                                     = 79,
    VK_FORMAT_R16G16_SSCALED                                     = 80,
    VK_FORMAT_R16G16_UINT                                        = 81,
    VK_FORMAT_R16G16_SINT                                        = 82,
    VK_FORMAT_R16G16_SFLOAT                                      = 83,
    VK_FORMAT_R16G16B16_UNORM                                    = 84,
    VK_FORMAT_R16G16B16_SNORM                                    = 85,
    VK_FORMAT_R16G16B16_USCALED                                  = 86,
    VK_FORMAT_R16G16B16_SSCALED                                  = 87,
    VK_FORMAT_R16G16B16_UINT                                     = 88,
    VK_FORMAT_R16G16B16_SINT                                     = 89,
    VK_FORMAT_R16G16B16_SFLOAT                                   = 90,
    VK_FORMAT_R16G16B16A16_UNORM                                 = 91,
    VK_FORMAT_R16G16B16A16_SNORM                                 = 92,
    VK_FORMAT_R16G16B16A16_USCALED                               = 93,
    VK_FORMAT_R16G16B16A16_SSCALED                               = 94,
    VK_FORMAT_R16G16B16A16_UINT                                  = 95,
    VK_FORMAT_R16G16B16A16_SINT                                  = 96,
    VK_FORMAT_R16G16B16A16_SFLOAT                                = 97,
    VK_FORMAT_R32_UINT                                           = 98,
    VK_FORMAT_R32_SINT                                           = 99,
    VK_FORMAT_R32_SFLOAT                                         = 100,
    VK_FORMAT_R32G32_UINT                                        = 101,
    VK_FORMAT_R32G32_SINT                                        = 102,
    VK_FORMAT_R32G32_SFLOAT                                      = 103,
    VK_FORMAT_R32G32B32_UINT                                     = 104,
    VK_FORMAT_R32G32B32_SINT                                     = 105,
    VK_FORMAT_R32G32B32_SFLOAT                                   = 106,
    VK_FORMAT_R32G32B32A32_UINT                                  = 107,
    VK_FORMAT_R32G32B32A32_SINT                                  = 108,
    VK_FORMAT_R32G32B32A32_SFLOAT                                = 109,
    VK_FORMAT_R64_UINT                                           = 110,
    VK_FORMAT_R64_SINT                                           = 111,
    VK_FORMAT_R64_SFLOAT                                         = 112,
    VK_FORMAT_R64G64_UINT                                        = 113,
    VK_FORMAT_R64G64_SINT                                        = 114,
    VK_FORMAT_R64G64_SFLOAT                                      = 115,
    VK_FORMAT_R64G64B64_UINT                                     = 116,
    VK_FORMAT_R64G64B64_SINT                                     = 117,
    VK_FORMAT_R64G64B64_SFLOAT                                   = 118,
    VK_FORMAT_R64G64B64A64_UINT                                  = 119,
    VK_FORMAT_R64G64B64A64_SINT                                  = 120,
    VK_FORMAT_R64G64B64A64_SFLOAT                                = 121,
    VK_FORMAT_B10G11R11_UFLOAT_PACK32                            = 122,
    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32                             = 123,
    VK_FORMAT_D16_UNORM                                          = 124,
    VK_FORMAT_X8_D24_UNORM_PACK32                                = 125,
    VK_FORMAT_D32_SFLOAT                                         = 126,
    VK_FORMAT_S8_UINT                                            = 127,
    VK_FORMAT_D16_UNORM_S8_UINT                                  = 128,
    VK_FORMAT_D24_UNORM_S8_UINT                                  = 129,
    VK_FORMAT_D32_SFLOAT_S8_UINT                                 = 130,
    VK_FORMAT_BC1_RGB_UNORM_BLOCK                                = 131,
    VK_FORMAT_BC1_RGB_SRGB_BLOCK                                 = 132,
    VK_FORMAT_BC1_RGBA_UNORM_BLOCK                               = 133,
    VK_FORMAT_BC1_RGBA_SRGB_BLOCK                                = 134,
    VK_FORMAT_BC2_UNORM_BLOCK                                    = 135,
    VK_FORMAT_BC2_SRGB_BLOCK                                     = 136,
    VK_FORMAT_BC3_UNORM_BLOCK                                    = 137,
    VK_FORMAT_BC3_SRGB_BLOCK                                     = 138,
    VK_FORMAT_BC4_UNORM_BLOCK                                    = 139,
    VK_FORMAT_BC4_SNORM_BLOCK                                    = 140,
    VK_FORMAT_BC5_UNORM_BLOCK                                    = 141,
    VK_FORMAT_BC5_SNORM_BLOCK                                    = 142,
    VK_FORMAT_BC6H_UFLOAT_BLOCK                                  = 143,
    VK_FORMAT_BC6H_SFLOAT_BLOCK                                  = 144,
    VK_FORMAT_BC7_UNORM_BLOCK                                    = 145,
    VK_FORMAT_BC7_SRGB_BLOCK                                     = 146,
    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK                            = 147,
    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK                             = 148,
    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK                          = 149,
    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK                           = 150,
    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK                          = 151,
    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK                           = 152,
    VK_FORMAT_EAC_R11_UNORM_BLOCK                                = 153,
    VK_FORMAT_EAC_R11_SNORM_BLOCK                                = 154,
    VK_FORMAT_EAC_R11G11_UNORM_BLOCK                             = 155,
    VK_FORMAT_EAC_R11G11_SNORM_BLOCK                             = 156,
    VK_FORMAT_ASTC_4x4_UNORM_BLOCK                               = 157,
    VK_FORMAT_ASTC_4x4_SRGB_BLOCK                                = 158,
    VK_FORMAT_ASTC_5x4_UNORM_BLOCK                               = 159,
    VK_FORMAT_ASTC_5x4_SRGB_BLOCK                                = 160,
    VK_FORMAT_ASTC_5x5_UNORM_BLOCK                               = 161,
    VK_FORMAT_ASTC_5x5_SRGB_BLOCK                                = 162,
    VK_FORMAT_ASTC_6x5_UNORM_BLOCK                               = 163,
    VK_FORMAT_ASTC_6x5_SRGB_BLOCK                                = 164,
    VK_FORMAT_ASTC_6x6_UNORM_BLOCK                               = 165,
    VK_FORMAT_ASTC_6x6_SRGB_BLOCK                                = 166,
    VK_FORMAT_ASTC_8x5_UNORM_BLOCK                               = 167,
    VK_FORMAT_ASTC_8x5_SRGB_BLOCK                                = 168,
    VK_FORMAT_ASTC_8x6_UNORM_BLOCK                               = 169,
    VK_FORMAT_ASTC_8x6_SRGB_BLOCK                                = 170,
    VK_FORMAT_ASTC_8x8_UNORM_BLOCK                               = 171,
    VK_FORMAT_ASTC_8x8_SRGB_BLOCK                                = 172,
    VK_FORMAT_ASTC_10x5_UNORM_BLOCK                              = 173,
    VK_FORMAT_ASTC_10x5_SRGB_BLOCK                               = 174,
    VK_FORMAT_ASTC_10x6_UNORM_BLOCK                              = 175,
    VK_FORMAT_ASTC_10x6_SRGB_BLOCK                               = 176,
    VK_FORMAT_ASTC_10x8_UNORM_BLOCK                              = 177,
    VK_FORMAT_ASTC_10x8_SRGB_BLOCK                               = 178,
    VK_FORMAT_ASTC_10x10_UNORM_BLOCK                             = 179,
    VK_FORMAT_ASTC_10x10_SRGB_BLOCK                              = 180,
    VK_FORMAT_ASTC_12x10_UNORM_BLOCK                             = 181,
    VK_FORMAT_ASTC_12x10_SRGB_BLOCK                              = 182,
    VK_FORMAT_ASTC_12x12_UNORM_BLOCK                             = 183,
    VK_FORMAT_ASTC_12x12_SRGB_BLOCK                              = 184,
    VK_FORMAT_MAX_ENUM                                           = $7FFFFFFF
  );
  PVkFormat = ^TVkFormat;
  PPVkFormat = ^PVkFormat;

  TVkFormatFeatureFlagBit = (
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT                          = 0,
    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT                          = 1,
    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT                   = 2,
    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT                   = 3,
    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT                   = 4,
    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT            = 5,
    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT                          = 6,
    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT                       = 7,
    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT                 = 8,
    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT               = 9,
    VK_FORMAT_FEATURE_BLIT_SRC_BIT                               = 10,
    VK_FORMAT_FEATURE_BLIT_DST_BIT                               = 11,
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT            = 12,
    VK_FORMAT_FEATURE_MAX_BIT                                    = 31
  );
  TVkFormatFeatureFlagBits = set of TVkFormatFeatureFlagBit;

  TVkImageType = (
    VK_IMAGE_TYPE_1D                                             = 0,
    VK_IMAGE_TYPE_2D                                             = 1,
    VK_IMAGE_TYPE_3D                                             = 2,
    VK_IMAGE_TYPE_MAX_ENUM                                       = $7FFFFFFF
  );
  PVkImageType = ^TVkImageType;
  PPVkImageType = ^PVkImageType;

  TVkImageTiling = (
    VK_IMAGE_TILING_OPTIMAL                                      = 0,
    VK_IMAGE_TILING_LINEAR                                       = 1,
    VK_IMAGE_TILING_MAX_ENUM                                     = $7FFFFFFF
  );
  PVkImageTiling = ^TVkImageTiling;
  PPVkImageTiling = ^PVkImageTiling;

  TVkImageUsageFlagBit = (
    VK_IMAGE_USAGE_TRANSFER_SRC_BIT                              = 0,
    VK_IMAGE_USAGE_TRANSFER_DST_BIT                              = 1,
    VK_IMAGE_USAGE_SAMPLED_BIT                                   = 2,
    VK_IMAGE_USAGE_STORAGE_BIT                                   = 3,
    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                          = 4,
    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT                  = 5,
    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT                      = 6,
    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT                          = 7,
    VK_IMAGE_USAGE_MAX_BIT                                       = 31
  );
  TVkImageUsageFlagBits = set of TVkImageUsageFlagBit;

  TVkImageCreateFlagBit = (
    VK_IMAGE_CREATE_SPARSE_BINDING_BIT                           = 0,
    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT                         = 1,
    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT                           = 2,
    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT                           = 3,
    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT                          = 4,
    VK_IMAGE_CREATE_MAX_BIT                                      = 31
  );
  TVkImageCreateFlagBits = set of TVkImageCreateFlagBit;

  TVkSampleCountFlagBit = (
    VK_SAMPLE_COUNT_1_BIT                                        = 0,
    VK_SAMPLE_COUNT_2_BIT                                        = 1,
    VK_SAMPLE_COUNT_4_BIT                                        = 2,
    VK_SAMPLE_COUNT_8_BIT                                        = 3,
    VK_SAMPLE_COUNT_16_BIT                                       = 4,
    VK_SAMPLE_COUNT_32_BIT                                       = 5,
    VK_SAMPLE_COUNT_64_BIT                                       = 6,
    VK_SAMPLE_COUNT_MAX_BIT                                      = 31
  );
  TVkSampleCountFlagBits = set of TVkSampleCountFlagBit;

  TVkPhysicalDeviceType = (
    VK_PHYSICAL_DEVICE_TYPE_OTHER                                = 0,
    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU                       = 1,
    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU                         = 2,
    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU                          = 3,
    VK_PHYSICAL_DEVICE_TYPE_CPU                                  = 4,
    VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM                             = $7FFFFFFF
  );
  PVkPhysicalDeviceType = ^TVkPhysicalDeviceType;
  PPVkPhysicalDeviceType = ^PVkPhysicalDeviceType;

  TVkQueueFlagBit = (
    VK_QUEUE_GRAPHICS_BIT                                        = 0,
    VK_QUEUE_COMPUTE_BIT                                         = 1,
    VK_QUEUE_TRANSFER_BIT                                        = 2,
    VK_QUEUE_SPARSE_BINDING_BIT                                  = 3,
    VK_QUEUE_MAX_BIT                                             = 31
  );
  TVkQueueFlagBits = set of TVkQueueFlagBit;

  TVkMemoryPropertyFlagBit = (
    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT                          = 0,
    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT                          = 1,
    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT                         = 2,
    VK_MEMORY_PROPERTY_HOST_CACHED_BIT                           = 3,
    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT                      = 4,
    VK_MEMORY_PROPERTY_MAX_BIT                                   = 31
  );
  TVkMemoryPropertyFlagBits = set of TVkMemoryPropertyFlagBit;

  TVkMemoryHeapFlagBit = (
    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT                              = 0,
    VK_MEMORY_HEAP_DEVICE_LOCAL_BITMAX_BIT                       = 31
  );
  TVkMemoryHeapFlagBits = set of TVkMemoryHeapFlagBit;

  TVkPipelineStageFlagBit = (
    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT                            = 0,
    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT                          = 1,
    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT                           = 2,
    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT                          = 3,
    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT            = 4,
    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT         = 5,
    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT                        = 6,
    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT                        = 7,
    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT                   = 8,
    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT                    = 9,
    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT                = 10,
    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT                         = 11,
    VK_PIPELINE_STAGE_TRANSFER_BIT                               = 12,
    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT                         = 13,
    VK_PIPELINE_STAGE_HOST_BIT                                   = 14,
    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT                           = 15,
    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT                           = 16,
    VK_PIPELINE_STAGE_MAX_BIT                                    = 31
  );
  TVkPipelineStageFlagBits = set of TVkPipelineStageFlagBit;

  TVkImageAspectFlagBit = (
    VK_IMAGE_ASPECT_COLOR_BIT                                    = 0,
    VK_IMAGE_ASPECT_DEPTH_BIT                                    = 1,
    VK_IMAGE_ASPECT_STENCIL_BIT                                  = 2,
    VK_IMAGE_ASPECT_METADATA_BIT                                 = 3,
    VK_IMAGE_ASPECT_MAX_BIT                                      = 31
  );
  TVkImageAspectFlagBits = set of TVkImageAspectFlagBit;

  TVkSparseImageFormatFlagBit = (
    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT                    = 0,
    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT                  = 1,
    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT            = 2,
    VK_SPARSE_IMAGE_FORMAT_MAX_BIT                               = 31
  );
  TVkSparseImageFormatFlagBits = set of TVkSparseImageFormatFlagBit;

  TVkSparseMemoryBindFlagBit = (
    VK_SPARSE_MEMORY_BIND_METADATA_BIT                           = 0,
    VK_SPARSE_MEMORY_BIND_METADATA_BITMAX_BIT                    = 31
  );
  TVkSparseMemoryBindFlagBits = set of TVkSparseMemoryBindFlagBit;

  TVkFenceCreateFlagBit = (
    VK_FENCE_CREATE_SIGNALED_BIT                                 = 0,
    VK_FENCE_CREATE_SIGNALED_BITMAX_BIT                          = 31
  );
  TVkFenceCreateFlagBits = set of TVkFenceCreateFlagBit;

  TVkQueryType = (
    VK_QUERY_TYPE_OCCLUSION                                      = 0,
    VK_QUERY_TYPE_PIPELINE_STATISTICS                            = 1,
    VK_QUERY_TYPE_TIMESTAMP                                      = 2,
    VK_QUERY_TYPE_MAX_ENUM                                       = $7FFFFFFF
  );
  PVkQueryType = ^TVkQueryType;
  PPVkQueryType = ^PVkQueryType;

  TVkQueryPipelineStatisticFlagBit = (
    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT      = 0,
    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT    = 1,
    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT    = 2,
    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT  = 3,
    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT   = 4,
    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT         = 5,
    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT          = 6,
    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT  = 7,
    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 8,
    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 9,
    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT   = 10,
    VK_QUERY_PIPELINE_STATISTIC_MAX_BIT                          = 31
  );
  TVkQueryPipelineStatisticFlagBits = set of TVkQueryPipelineStatisticFlagBit;

  TVkQueryResultFlagBit = (
    VK_QUERY_RESULT_64_BIT                                       = 0,
    VK_QUERY_RESULT_WAIT_BIT                                     = 1,
    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT                        = 2,
    VK_QUERY_RESULT_PARTIAL_BIT                                  = 3,
    VK_QUERY_RESULT_MAX_BIT                                      = 31
  );
  TVkQueryResultFlagBits = set of TVkQueryResultFlagBit;

  TVkBufferCreateFlagBit = (
    VK_BUFFER_CREATE_SPARSE_BINDING_BIT                          = 0,
    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT                        = 1,
    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT                          = 2,
    VK_BUFFER_CREATE_SPARSE_MAX_BIT                              = 31
  );
  TVkBufferCreateFlagBits = set of TVkBufferCreateFlagBit;

  TVkBufferUsageFlagBit = (
    VK_BUFFER_USAGE_TRANSFER_SRC_BIT                             = 0,
    VK_BUFFER_USAGE_TRANSFER_DST_BIT                             = 1,
    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT                     = 2,
    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT                     = 3,
    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT                           = 4,
    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT                           = 5,
    VK_BUFFER_USAGE_INDEX_BUFFER_BIT                             = 6,
    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT                            = 7,
    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT                          = 8,
    VK_BUFFER_USAGE_MAX_BIT                                      = 31
  );
  TVkBufferUsageFlagBits = set of TVkBufferUsageFlagBit;

  TVkSharingMode = (
    VK_SHARING_MODE_EXCLUSIVE                                    = 0,
    VK_SHARING_MODE_CONCURRENT                                   = 1,
    VK_SHARING_MODE_MAX_ENUM                                     = $7FFFFFFF
  );
  PVkSharingMode = ^TVkSharingMode;
  PPVkSharingMode = ^PVkSharingMode;

  TVkImageLayout = (
    VK_IMAGE_LAYOUT_UNDEFINED                                    = 0,
    VK_IMAGE_LAYOUT_GENERAL                                      = 1,
    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                     = 2,
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL             = 3,
    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL              = 4,
    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL                     = 5,
    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL                         = 6,
    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL                         = 7,
    VK_IMAGE_LAYOUT_PREINITIALIZED                               = 8,
    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR                              = 1000001002,
    VK_IMAGE_LAYOUT_MAX_ENUM                                     = $7FFFFFFF
  );
  PVkImageLayout = ^TVkImageLayout;
  PPVkImageLayout = ^PVkImageLayout;

  TVkImageViewType = (
    VK_IMAGE_VIEW_TYPE_1D                                        = 0,
    VK_IMAGE_VIEW_TYPE_2D                                        = 1,
    VK_IMAGE_VIEW_TYPE_3D                                        = 2,
    VK_IMAGE_VIEW_TYPE_CUBE                                      = 3,
    VK_IMAGE_VIEW_TYPE_1D_ARRAY                                  = 4,
    VK_IMAGE_VIEW_TYPE_2D_ARRAY                                  = 5,
    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY                                = 6,
    VK_IMAGE_VIEW_TYPE_MAX_ENUM                                  = $7FFFFFFF
  );
  PVkImageViewType = ^TVkImageViewType;
  PPVkImageViewType = ^PVkImageViewType;

  TVkComponentSwizzle = (
    VK_COMPONENT_SWIZZLE_IDENTITY                                = 0,
    VK_COMPONENT_SWIZZLE_ZERO                                    = 1,
    VK_COMPONENT_SWIZZLE_ONE                                     = 2,
    VK_COMPONENT_SWIZZLE_R                                       = 3,
    VK_COMPONENT_SWIZZLE_G                                       = 4,
    VK_COMPONENT_SWIZZLE_B                                       = 5,
    VK_COMPONENT_SWIZZLE_A                                       = 6,
    VK_COMPONENT_SWIZZLE_MAX_ENUM                                = $7FFFFFFF
  );
  PVkComponentSwizzle = ^TVkComponentSwizzle;
  PPVkComponentSwizzle = ^PVkComponentSwizzle;

  TVkPipelineCreateFlagBit = (
    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT                  = 0,
    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT                     = 1,
    VK_PIPELINE_CREATE_DERIVATIVE_BIT                            = 2,
    VK_PIPELINE_CREATE_MAX_BIT                                   = 31
  );
  TVkPipelineCreateFlagBits = set of TVkPipelineCreateFlagBit;

  TVkShaderStageFlagBit = (
    VK_SHADER_STAGE_VERTEX_BIT                                   = 0,
    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT                     = 1,
    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT                  = 2,
    VK_SHADER_STAGE_GEOMETRY_BIT                                 = 3,
    VK_SHADER_STAGE_FRAGMENT_BIT                                 = 4,
    VK_SHADER_STAGE_COMPUTE_BIT                                  = 5,
    VK_SHADER_STAGE_MAX_BIT                                      = 31
  );
  TVkShaderStageFlagBits = set of TVkShaderStageFlagBit;

  TVkVertexInputRate = (
    VK_VERTEX_INPUT_RATE_VERTEX                                  = 0,
    VK_VERTEX_INPUT_RATE_INSTANCE                                = 1,
    VK_VERTEX_INPUT_RATE_MAX_ENUM                                = $7FFFFFFF
  );
  PVkVertexInputRate = ^TVkVertexInputRate;
  PPVkVertexInputRate = ^PVkVertexInputRate;

  TVkPrimitiveTopology = (
    VK_PRIMITIVE_TOPOLOGY_POINT_LIST                             = 0,
    VK_PRIMITIVE_TOPOLOGY_LINE_LIST                              = 1,
    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP                             = 2,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST                          = 3,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP                         = 4,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN                           = 5,
    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY               = 6,
    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY              = 7,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY           = 8,
    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY          = 9,
    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST                             = 10,
    VK_PRIMITIVE_TOPOLOGY_MAX_ENUM                               = $7FFFFFFF
  );
  PVkPrimitiveTopology = ^TVkPrimitiveTopology;
  PPVkPrimitiveTopology = ^PVkPrimitiveTopology;

  TVkPolygonMode = (
    VK_POLYGON_MODE_FILL                                         = 0,
    VK_POLYGON_MODE_LINE                                         = 1,
    VK_POLYGON_MODE_POINT                                        = 2,
    VK_POLYGON_MODE_MAX_ENUM                                     = $7FFFFFFF
  );
  PVkPolygonMode = ^TVkPolygonMode;
  PPVkPolygonMode = ^PVkPolygonMode;

  TVkCullModeFlagBit = (
    VK_CULL_MODE_FRONT_BIT                                       = 0,
    VK_CULL_MODE_BACK_BIT                                        = 1,
    VK_CULL_MODE_MAX_BIT                                         = 31
  );
  TVkCullModeFlagBits = set of TVkCullModeFlagBit;

  TVkFrontFace = (
    VK_FRONT_FACE_COUNTER_CLOCKWISE                              = 0,
    VK_FRONT_FACE_CLOCKWISE                                      = 1,
    VK_FRONT_FACE_MAX_ENUM                                       = $7FFFFFFF
  );
  PVkFrontFace = ^TVkFrontFace;
  PPVkFrontFace = ^PVkFrontFace;

  TVkCompareOp = (
    VK_COMPARE_OP_NEVER                                          = 0,
    VK_COMPARE_OP_LESS                                           = 1,
    VK_COMPARE_OP_EQUAL                                          = 2,
    VK_COMPARE_OP_LESS_OR_EQUAL                                  = 3,
    VK_COMPARE_OP_GREATER                                        = 4,
    VK_COMPARE_OP_NOT_EQUAL                                      = 5,
    VK_COMPARE_OP_GREATER_OR_EQUAL                               = 6,
    VK_COMPARE_OP_ALWAYS                                         = 7,
    VK_COMPARE_OP_MAX_ENUM                                       = $7FFFFFFF
  );
  PVkCompareOp = ^TVkCompareOp;
  PPVkCompareOp = ^PVkCompareOp;

  TVkStencilOp = (
    VK_STENCIL_OP_KEEP                                           = 0,
    VK_STENCIL_OP_ZERO                                           = 1,
    VK_STENCIL_OP_REPLACE                                        = 2,
    VK_STENCIL_OP_INCREMENT_AND_CLAMP                            = 3,
    VK_STENCIL_OP_DECREMENT_AND_CLAMP                            = 4,
    VK_STENCIL_OP_INVERT                                         = 5,
    VK_STENCIL_OP_INCREMENT_AND_WRAP                             = 6,
    VK_STENCIL_OP_DECREMENT_AND_WRAP                             = 7,
    VK_STENCIL_OP_MAX_ENUM                                       = $7FFFFFFF
  );
  PVkStencilOp = ^TVkStencilOp;
  PPVkStencilOp = ^PVkStencilOp;

  TVkLogicOp = (
    VK_LOGIC_OP_CLEAR                                            = 0,
    VK_LOGIC_OP_AND                                              = 1,
    VK_LOGIC_OP_AND_REVERSE                                      = 2,
    VK_LOGIC_OP_COPY                                             = 3,
    VK_LOGIC_OP_AND_INVERTED                                     = 4,
    VK_LOGIC_OP_NO_OP                                            = 5,
    VK_LOGIC_OP_XOR                                              = 6,
    VK_LOGIC_OP_OR                                               = 7,
    VK_LOGIC_OP_NOR                                              = 8,
    VK_LOGIC_OP_EQUIVALENT                                       = 9,
    VK_LOGIC_OP_INVERT                                           = 10,
    VK_LOGIC_OP_OR_REVERSE                                       = 11,
    VK_LOGIC_OP_COPY_INVERTED                                    = 12,
    VK_LOGIC_OP_OR_INVERTED                                      = 13,
    VK_LOGIC_OP_NAND                                             = 14,
    VK_LOGIC_OP_SET                                              = 15,
    VK_LOGIC_OP_MAX_ENUM                                         = $7FFFFFFF
  );
  PVkLogicOp = ^TVkLogicOp;
  PPVkLogicOp = ^PVkLogicOp;

  TVkBlendFactor = (
    VK_BLEND_FACTOR_ZERO                                         = 0,
    VK_BLEND_FACTOR_ONE                                          = 1,
    VK_BLEND_FACTOR_SRC_COLOR                                    = 2,
    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR                          = 3,
    VK_BLEND_FACTOR_DST_COLOR                                    = 4,
    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR                          = 5,
    VK_BLEND_FACTOR_SRC_ALPHA                                    = 6,
    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA                          = 7,
    VK_BLEND_FACTOR_DST_ALPHA                                    = 8,
    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA                          = 9,
    VK_BLEND_FACTOR_CONSTANT_COLOR                               = 10,
    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR                     = 11,
    VK_BLEND_FACTOR_CONSTANT_ALPHA                               = 12,
    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA                     = 13,
    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE                           = 14,
    VK_BLEND_FACTOR_SRC1_COLOR                                   = 15,
    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR                         = 16,
    VK_BLEND_FACTOR_SRC1_ALPHA                                   = 17,
    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA                         = 18,
    VK_BLEND_FACTOR_MAX_ENUM                                     = $7FFFFFFF
  );
  PVkBlendFactor = ^TVkBlendFactor;
  PPVkBlendFactor = ^PVkBlendFactor;

  TVkBlendOp = (
    VK_BLEND_OP_ADD                                              = 0,
    VK_BLEND_OP_SUBTRACT                                         = 1,
    VK_BLEND_OP_REVERSE_SUBTRACT                                 = 2,
    VK_BLEND_OP_MIN                                              = 3,
    VK_BLEND_OP_MAX                                              = 4,
    VK_BLEND_OP_MAX_ENUM                                         = $7FFFFFFF
  );
  PVkBlendOp = ^TVkBlendOp;
  PPVkBlendOp = ^PVkBlendOp;

  TVkColorComponentFlagBit = (
    VK_COLOR_COMPONENT_R_BIT                                     = 0,
    VK_COLOR_COMPONENT_G_BIT                                     = 1,
    VK_COLOR_COMPONENT_B_BIT                                     = 2,
    VK_COLOR_COMPONENT_A_BIT                                     = 3,
    VK_COLOR_COMPONENT_MAX_BIT                                   = 31
  );
  TVkColorComponentFlagBits = set of TVkColorComponentFlagBit;

  TVkDynamicState = (
    VK_DYNAMIC_STATE_VIEWPORT                                    = 0,
    VK_DYNAMIC_STATE_SCISSOR                                     = 1,
    VK_DYNAMIC_STATE_LINE_WIDTH                                  = 2,
    VK_DYNAMIC_STATE_DEPTH_BIAS                                  = 3,
    VK_DYNAMIC_STATE_BLEND_CONSTANTS                             = 4,
    VK_DYNAMIC_STATE_DEPTH_BOUNDS                                = 5,
    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK                        = 6,
    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK                          = 7,
    VK_DYNAMIC_STATE_STENCIL_REFERENCE                           = 8,
    VK_DYNAMIC_STATE_MAX_ENUM                                    = $7FFFFFFF
  );
  PVkDynamicState = ^TVkDynamicState;
  PPVkDynamicState = ^PVkDynamicState;

  TVkFilter = (
    VK_FILTER_NEAREST                                            = 0,
    VK_FILTER_LINEAR                                             = 1,
    VK_FILTER_MAX_ENUM                                           = $7FFFFFFF
  );
  PVkFilter = ^TVkFilter;
  PPVkFilter = ^PVkFilter;

  TVkSamplerMipmapMode = (
    VK_SAMPLER_MIPMAP_MODE_NEAREST                               = 0,
    VK_SAMPLER_MIPMAP_MODE_LINEAR                                = 1,
    VK_SAMPLER_MIPMAP_MODE_MAX_ENUM                              = $7FFFFFFF
  );
  PVkSamplerMipmapMode = ^TVkSamplerMipmapMode;
  PPVkSamplerMipmapMode = ^PVkSamplerMipmapMode;

  TVkSamplerAddressMode = (
    VK_SAMPLER_ADDRESS_MODE_REPEAT                               = 0,
    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT                      = 1,
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE                        = 2,
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER                      = 3,
    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE                 = 4,
    VK_SAMPLER_ADDRESS_MODE_MAX_ENUM                             = $7FFFFFFF
  );
  PVkSamplerAddressMode = ^TVkSamplerAddressMode;
  PPVkSamplerAddressMode = ^PVkSamplerAddressMode;

  TVkBorderColor = (
    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK                      = 0,
    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK                        = 1,
    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK                           = 2,
    VK_BORDER_COLOR_INT_OPAQUE_BLACK                             = 3,
    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE                           = 4,
    VK_BORDER_COLOR_INT_OPAQUE_WHITE                             = 5,
    VK_BORDER_COLOR_MAX_ENUM                                     = $7FFFFFFF
  );
  PVkBorderColor = ^TVkBorderColor;
  PPVkBorderColor = ^PVkBorderColor;

  TVkDescriptorType = (
    VK_DESCRIPTOR_TYPE_SAMPLER                                   = 0,
    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER                    = 1,
    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE                             = 2,
    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE                             = 3,
    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER                      = 4,
    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER                      = 5,
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER                            = 6,
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER                            = 7,
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC                    = 8,
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC                    = 9,
    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT                          = 10,
    VK_DESCRIPTOR_TYPE_MAX_ENUM                                  = $7FFFFFFF
  );
  PVkDescriptorType = ^TVkDescriptorType;
  PPVkDescriptorType = ^PVkDescriptorType;

  TVkDescriptorPoolCreateFlagBit = (
    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT            = 0,
    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BITMAX_BIT     = 31
  );
  TVkDescriptorPoolCreateFlagBits = set of TVkDescriptorPoolCreateFlagBit;

  TVkAttachmentDescriptionFlagBit = (
    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT                      = 0,
    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BITMAX_BIT               = 31
  );
  TVkAttachmentDescriptionFlagBits = set of TVkAttachmentDescriptionFlagBit;

  TVkAttachmentLoadOp = (
    VK_ATTACHMENT_LOAD_OP_LOAD                                   = 0,
    VK_ATTACHMENT_LOAD_OP_CLEAR                                  = 1,
    VK_ATTACHMENT_LOAD_OP_DONT_CARE                              = 2,
    VK_ATTACHMENT_LOAD_OP_MAX_ENUM                               = $7FFFFFFF
  );
  PVkAttachmentLoadOp = ^TVkAttachmentLoadOp;
  PPVkAttachmentLoadOp = ^PVkAttachmentLoadOp;

  TVkAttachmentStoreOp = (
    VK_ATTACHMENT_STORE_OP_STORE                                 = 0,
    VK_ATTACHMENT_STORE_OP_DONT_CARE                             = 1,
    VK_ATTACHMENT_STORE_OP_MAX_ENUM                              = $7FFFFFFF
  );
  PVkAttachmentStoreOp = ^TVkAttachmentStoreOp;
  PPVkAttachmentStoreOp = ^PVkAttachmentStoreOp;

  TVkPipelineBindPoint = (
    VK_PIPELINE_BIND_POINT_GRAPHICS                              = 0,
    VK_PIPELINE_BIND_POINT_COMPUTE                               = 1,
    VK_PIPELINE_BIND_POINT_MAX_ENUM                              = $7FFFFFFF
  );
  PVkPipelineBindPoint = ^TVkPipelineBindPoint;
  PPVkPipelineBindPoint = ^PVkPipelineBindPoint;

  TVkAccessFlagBit = (
    VK_ACCESS_INDIRECT_COMMAND_READ_BIT                          = 0,
    VK_ACCESS_INDEX_READ_BIT                                     = 1,
    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT                          = 2,
    VK_ACCESS_UNIFORM_READ_BIT                                   = 3,
    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT                          = 4,
    VK_ACCESS_SHADER_READ_BIT                                    = 5,
    VK_ACCESS_SHADER_WRITE_BIT                                   = 6,
    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT                          = 7,
    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT                         = 8,
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT                  = 9,
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT                 = 10,
    VK_ACCESS_TRANSFER_READ_BIT                                  = 11,
    VK_ACCESS_TRANSFER_WRITE_BIT                                 = 12,
    VK_ACCESS_HOST_READ_BIT                                      = 13,
    VK_ACCESS_HOST_WRITE_BIT                                     = 14,
    VK_ACCESS_MEMORY_READ_BIT                                    = 15,
    VK_ACCESS_MEMORY_WRITE_BIT                                   = 16,
    VK_ACCESS_MAX_BIT                                            = 31
  );
  TVkAccessFlagBits = set of TVkAccessFlagBit;

  TVkDependencyFlagBit = (
    VK_DEPENDENCY_BY_REGION_BIT                                  = 0,
    VK_DEPENDENCY_BY_REGION_BITMAX_BIT                           = 31
  );
  TVkDependencyFlagBits = set of TVkDependencyFlagBit;

  TVkCommandPoolCreateFlagBit = (
    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT                         = 0,
    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT              = 1,
    VK_COMMAND_POOL_CREATE_MAX_BIT                               = 31
  );
  TVkCommandPoolCreateFlagBits = set of TVkCommandPoolCreateFlagBit;

  TVkCommandPoolResetFlagBit = (
    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT                  = 0,
    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BITMAX_BIT           = 31
  );
  TVkCommandPoolResetFlagBits = set of TVkCommandPoolResetFlagBit;

  TVkCommandBufferLevel = (
    VK_COMMAND_BUFFER_LEVEL_PRIMARY                              = 0,
    VK_COMMAND_BUFFER_LEVEL_SECONDARY                            = 1,
    VK_COMMAND_BUFFER_LEVEL_MAX_ENUM                             = $7FFFFFFF
  );
  PVkCommandBufferLevel = ^TVkCommandBufferLevel;
  PPVkCommandBufferLevel = ^PVkCommandBufferLevel;

  TVkCommandBufferUsageFlagBit = (
    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT                  = 0,
    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT             = 1,
    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT                 = 2,
    VK_COMMAND_BUFFER_USAGE_MAX_BIT                              = 31
  );
  TVkCommandBufferUsageFlagBits = set of TVkCommandBufferUsageFlagBit;

  TVkQueryControlFlagBit = (
    VK_QUERY_CONTROL_PRECISE_BIT                                 = 0,
    VK_QUERY_CONTROL_PRECISE_BITMAX_BIT                          = 31
  );
  TVkQueryControlFlagBits = set of TVkQueryControlFlagBit;

  TVkCommandBufferResetFlagBit = (
    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT                = 0,
    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BITMAX_BIT         = 31
  );
  TVkCommandBufferResetFlagBits = set of TVkCommandBufferResetFlagBit;

  TVkStencilFaceFlagBit = (
    VK_STENCIL_FACE_FRONT_BIT                                    = 0,
    VK_STENCIL_FACE_BACK_BIT                                     = 1,
    VK_STENCIL_FMAX_BIT                                          = 31
  );
  TVkStencilFaceFlagBits = set of TVkStencilFaceFlagBit;

  TVkIndexType = (
    VK_INDEX_TYPE_UINT16                                         = 0,
    VK_INDEX_TYPE_UINT32                                         = 1,
    VK_INDEX_TYPE_MAX_ENUM                                       = $7FFFFFFF
  );
  PVkIndexType = ^TVkIndexType;
  PPVkIndexType = ^PVkIndexType;

  TVkSubpassContents = (
    VK_SUBPASS_CONTENTS_INLINE                                   = 0,
    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS                = 1,
    VK_SUBPASS_CONTENTS_MAX_ENUM                                 = $7FFFFFFF
  );
  PVkSubpassContents = ^TVkSubpassContents;
  PPVkSubpassContents = ^PVkSubpassContents;

{ ========================================== VK_KHR_surface ========================================== }
  TVkSurfaceTransformFlagBitKHR = (
    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR                        = 0,
    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR                       = 1,
    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR                      = 2,
    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR                      = 3,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR               = 4,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR     = 5,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR    = 6,
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR    = 7,
    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR                         = 8,
    VK_SURFACE_TRANSFORM_MAX_BIT                                 = 31
  );
  TVkSurfaceTransformFlagBitsKHR = set of TVkSurfaceTransformFlagBitKHR;

  TVkCompositeAlphaFlagBitKHR = (
    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR                            = 0,
    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR                    = 1,
    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR                   = 2,
    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR                           = 3,
    VK_COMPOSITE_ALPHA_MAX_BIT                                   = 31
  );
  TVkCompositeAlphaFlagBitsKHR = set of TVkCompositeAlphaFlagBitKHR;

  TVkColorSpaceKHR = (
    VK_COLORSPACE_SRGB_NONLINEAR_KHR                             = 0,
    VK_COLORSPACE_MAX_ENUM                                       = $7FFFFFFF
  );
  PVkColorSpaceKHR = ^TVkColorSpaceKHR;
  PPVkColorSpaceKHR = ^PVkColorSpaceKHR;

  TVkPresentModeKHR = (
    VK_PRESENT_MODE_IMMEDIATE_KHR                                = 0,
    VK_PRESENT_MODE_MAILBOX_KHR                                  = 1,
    VK_PRESENT_MODE_FIFO_KHR                                     = 2,
    VK_PRESENT_MODE_FIFO_RELAXED_KHR                             = 3,
    VK_PRESENT_MODE_MAX_ENUM                                     = $7FFFFFFF
  );
  PVkPresentModeKHR = ^TVkPresentModeKHR;
  PPVkPresentModeKHR = ^PVkPresentModeKHR;

{ ========================================== VK_KHR_display ========================================== }
  TVkDisplayPlaneAlphaFlagBitKHR = (
    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR                        = 0,
    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR                        = 1,
    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR                     = 2,
    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR       = 3,
    VK_DISPLAY_PLANE_ALPHA_MAX_BIT                               = 31
  );
  TVkDisplayPlaneAlphaFlagBitsKHR = set of TVkDisplayPlaneAlphaFlagBitKHR;

{ ======================================= VK_EXT_debug_report ======================================== }
  TVkDebugReportObjectTypeEXT = (
    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT                      = 0,
    VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT                     = 1,
    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT              = 2,
    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT                       = 3,
    VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT                        = 4,
    VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT                    = 5,
    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT               = 6,
    VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT                        = 7,
    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT                = 8,
    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT                       = 9,
    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT                        = 10,
    VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT                        = 11,
    VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT                   = 12,
    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT                  = 13,
    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT                   = 14,
    VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT                = 15,
    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT               = 16,
    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT              = 17,
    VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT                  = 18,
    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT                     = 19,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT        = 20,
    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT                      = 21,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT              = 22,
    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT               = 23,
    VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT                  = 24,
    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT                 = 25,
    VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT                  = 26,
    VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT                = 27,
    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT                 = 28,
    VK_DEBUG_REPORT_OBJECT_TYPE__MAX_ENUM                        = $7FFFFFFF
  );
  PVkDebugReportObjectTypeEXT = ^TVkDebugReportObjectTypeEXT;
  PPVkDebugReportObjectTypeEXT = ^PVkDebugReportObjectTypeEXT;

  TVkDebugReportErrorEXT = (
    VK_DEBUG_REPORT_ERROR_NONE_EXT                               = 0,
    VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT                       = 1,
    VK_DEBUG_REPORT_ERROR__MAX_ENUM                              = $7FFFFFFF
  );
  PVkDebugReportErrorEXT = ^TVkDebugReportErrorEXT;
  PPVkDebugReportErrorEXT = ^PVkDebugReportErrorEXT;

  TVkDebugReportFlagBitEXT = (
    VK_DEBUG_REPORT_INFORMATION_BIT_EXT                          = 0,
    VK_DEBUG_REPORT_WARNING_BIT_EXT                              = 1,
    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT                  = 2,
    VK_DEBUG_REPORT_ERROR_BIT_EXT                                = 3,
    VK_DEBUG_REPORT_DEBUG_BIT_EXT                                = 4,
    VK_DEBUG_REPORT_MAX_BIT                                      = 31
  );
  TVkDebugReportFlagBitsEXT = set of TVkDebugReportFlagBitEXT;

type { simple types }

{ ========================================== VK_VERSION_1_0 ========================================== }
  VkFlags                                                        = VkUint32;
  PVkFlags                                                       = ^VkFlags;
  PPVkFlags                                                      = ^PVkFlags;

  VkInstanceCreateFlags                                          = VkFlags;
  PVkInstanceCreateFlags                                         = ^VkInstanceCreateFlags;
  PPVkInstanceCreateFlags                                        = ^PVkInstanceCreateFlags;

  _VkInstance                                                    = record end;
  VkInstance                                                     = ^_VkInstance;
  PVkInstance                                                    = ^VkInstance;
  PPVkInstance                                                   = ^PVkInstance;

  _VkPhysicalDevice                                              = record end;
  VkPhysicalDevice                                               = ^_VkPhysicalDevice;
  PVkPhysicalDevice                                              = ^VkPhysicalDevice;
  PPVkPhysicalDevice                                             = ^PVkPhysicalDevice;

  VkBool32                                                       = VkUint32;
  PVkBool32                                                      = ^VkBool32;
  PPVkBool32                                                     = ^PVkBool32;

  VkFormatFeatureFlags                                           = TVkFormatFeatureFlagBits;
  PVkFormatFeatureFlags                                          = ^VkFormatFeatureFlags;
  PPVkFormatFeatureFlags                                         = ^PVkFormatFeatureFlags;

  VkImageUsageFlags                                              = TVkImageUsageFlagBits;
  PVkImageUsageFlags                                             = ^VkImageUsageFlags;
  PPVkImageUsageFlags                                            = ^PVkImageUsageFlags;

  VkImageCreateFlags                                             = TVkImageCreateFlagBits;
  PVkImageCreateFlags                                            = ^VkImageCreateFlags;
  PPVkImageCreateFlags                                           = ^PVkImageCreateFlags;

  VkSampleCountFlags                                             = TVkSampleCountFlagBits;
  PVkSampleCountFlags                                            = ^VkSampleCountFlags;
  PPVkSampleCountFlags                                           = ^PVkSampleCountFlags;

  VkDeviceSize                                                   = VkUint64;
  PVkDeviceSize                                                  = ^VkDeviceSize;
  PPVkDeviceSize                                                 = ^PVkDeviceSize;

  VkQueueFlags                                                   = TVkQueueFlagBits;
  PVkQueueFlags                                                  = ^VkQueueFlags;
  PPVkQueueFlags                                                 = ^PVkQueueFlags;

  VkMemoryPropertyFlags                                          = TVkMemoryPropertyFlagBits;
  PVkMemoryPropertyFlags                                         = ^VkMemoryPropertyFlags;
  PPVkMemoryPropertyFlags                                        = ^PVkMemoryPropertyFlags;

  VkMemoryHeapFlags                                              = TVkMemoryHeapFlagBits;
  PVkMemoryHeapFlags                                             = ^VkMemoryHeapFlags;
  PPVkMemoryHeapFlags                                            = ^PVkMemoryHeapFlags;

  _VkDevice                                                      = record end;
  VkDevice                                                       = ^_VkDevice;
  PVkDevice                                                      = ^VkDevice;
  PPVkDevice                                                     = ^PVkDevice;

  VkDeviceCreateFlags                                            = VkFlags;
  PVkDeviceCreateFlags                                           = ^VkDeviceCreateFlags;
  PPVkDeviceCreateFlags                                          = ^PVkDeviceCreateFlags;

  VkDeviceQueueCreateFlags                                       = VkFlags;
  PVkDeviceQueueCreateFlags                                      = ^VkDeviceQueueCreateFlags;
  PPVkDeviceQueueCreateFlags                                     = ^PVkDeviceQueueCreateFlags;

  _VkQueue                                                       = record end;
  VkQueue                                                        = ^_VkQueue;
  PVkQueue                                                       = ^VkQueue;
  PPVkQueue                                                      = ^PVkQueue;

  _VkSemaphore                                                   = record end;
  VkSemaphore                                                    = {$IFDEF VK_CPU64}^_VkSemaphore{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkSemaphore                                                   = ^VkSemaphore;
  PPVkSemaphore                                                  = ^PVkSemaphore;

  VkPipelineStageFlags                                           = TVkPipelineStageFlagBits;
  PVkPipelineStageFlags                                          = ^VkPipelineStageFlags;
  PPVkPipelineStageFlags                                         = ^PVkPipelineStageFlags;

  _VkCommandPool                                                 = record end;
  VkCommandPool                                                  = {$IFDEF VK_CPU64}^_VkCommandPool{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkCommandPool                                                 = ^VkCommandPool;
  PPVkCommandPool                                                = ^PVkCommandPool;

  _VkCommandBuffer                                               = record end;
  VkCommandBuffer                                                = ^_VkCommandBuffer;
  PVkCommandBuffer                                               = ^VkCommandBuffer;
  PPVkCommandBuffer                                              = ^PVkCommandBuffer;

  _VkFence                                                       = record end;
  VkFence                                                        = {$IFDEF VK_CPU64}^_VkFence{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkFence                                                       = ^VkFence;
  PPVkFence                                                      = ^PVkFence;

  _VkDeviceMemory                                                = record end;
  VkDeviceMemory                                                 = {$IFDEF VK_CPU64}^_VkDeviceMemory{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkDeviceMemory                                                = ^VkDeviceMemory;
  PPVkDeviceMemory                                               = ^PVkDeviceMemory;

  VkMemoryMapFlags                                               = VkFlags;
  PVkMemoryMapFlags                                              = ^VkMemoryMapFlags;
  PPVkMemoryMapFlags                                             = ^PVkMemoryMapFlags;

  _VkBuffer                                                      = record end;
  VkBuffer                                                       = {$IFDEF VK_CPU64}^_VkBuffer{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkBuffer                                                      = ^VkBuffer;
  PPVkBuffer                                                     = ^PVkBuffer;

  _VkImage                                                       = record end;
  VkImage                                                        = {$IFDEF VK_CPU64}^_VkImage{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkImage                                                       = ^VkImage;
  PPVkImage                                                      = ^PVkImage;

  VkImageAspectFlags                                             = TVkImageAspectFlagBits;
  PVkImageAspectFlags                                            = ^VkImageAspectFlags;
  PPVkImageAspectFlags                                           = ^PVkImageAspectFlags;

  VkSparseImageFormatFlags                                       = TVkSparseImageFormatFlagBits;
  PVkSparseImageFormatFlags                                      = ^VkSparseImageFormatFlags;
  PPVkSparseImageFormatFlags                                     = ^PVkSparseImageFormatFlags;

  VkSparseMemoryBindFlags                                        = TVkSparseMemoryBindFlagBits;
  PVkSparseMemoryBindFlags                                       = ^VkSparseMemoryBindFlags;
  PPVkSparseMemoryBindFlags                                      = ^PVkSparseMemoryBindFlags;

  VkFenceCreateFlags                                             = TVkFenceCreateFlagBits;
  PVkFenceCreateFlags                                            = ^VkFenceCreateFlags;
  PPVkFenceCreateFlags                                           = ^PVkFenceCreateFlags;

  VkSemaphoreCreateFlags                                         = VkFlags;
  PVkSemaphoreCreateFlags                                        = ^VkSemaphoreCreateFlags;
  PPVkSemaphoreCreateFlags                                       = ^PVkSemaphoreCreateFlags;

  VkEventCreateFlags                                             = VkFlags;
  PVkEventCreateFlags                                            = ^VkEventCreateFlags;
  PPVkEventCreateFlags                                           = ^PVkEventCreateFlags;

  _VkEvent                                                       = record end;
  VkEvent                                                        = {$IFDEF VK_CPU64}^_VkEvent{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkEvent                                                       = ^VkEvent;
  PPVkEvent                                                      = ^PVkEvent;

  VkQueryPoolCreateFlags                                         = VkFlags;
  PVkQueryPoolCreateFlags                                        = ^VkQueryPoolCreateFlags;
  PPVkQueryPoolCreateFlags                                       = ^PVkQueryPoolCreateFlags;

  VkQueryPipelineStatisticFlags                                  = TVkQueryPipelineStatisticFlagBits;
  PVkQueryPipelineStatisticFlags                                 = ^VkQueryPipelineStatisticFlags;
  PPVkQueryPipelineStatisticFlags                                = ^PVkQueryPipelineStatisticFlags;

  _VkQueryPool                                                   = record end;
  VkQueryPool                                                    = {$IFDEF VK_CPU64}^_VkQueryPool{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkQueryPool                                                   = ^VkQueryPool;
  PPVkQueryPool                                                  = ^PVkQueryPool;

  VkQueryResultFlags                                             = TVkQueryResultFlagBits;
  PVkQueryResultFlags                                            = ^VkQueryResultFlags;
  PPVkQueryResultFlags                                           = ^PVkQueryResultFlags;

  VkBufferCreateFlags                                            = TVkBufferCreateFlagBits;
  PVkBufferCreateFlags                                           = ^VkBufferCreateFlags;
  PPVkBufferCreateFlags                                          = ^PVkBufferCreateFlags;

  VkBufferUsageFlags                                             = TVkBufferUsageFlagBits;
  PVkBufferUsageFlags                                            = ^VkBufferUsageFlags;
  PPVkBufferUsageFlags                                           = ^PVkBufferUsageFlags;

  VkBufferViewCreateFlags                                        = VkFlags;
  PVkBufferViewCreateFlags                                       = ^VkBufferViewCreateFlags;
  PPVkBufferViewCreateFlags                                      = ^PVkBufferViewCreateFlags;

  _VkBufferView                                                  = record end;
  VkBufferView                                                   = {$IFDEF VK_CPU64}^_VkBufferView{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkBufferView                                                  = ^VkBufferView;
  PPVkBufferView                                                 = ^PVkBufferView;

  VkImageViewCreateFlags                                         = VkFlags;
  PVkImageViewCreateFlags                                        = ^VkImageViewCreateFlags;
  PPVkImageViewCreateFlags                                       = ^PVkImageViewCreateFlags;

  _VkImageView                                                   = record end;
  VkImageView                                                    = {$IFDEF VK_CPU64}^_VkImageView{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkImageView                                                   = ^VkImageView;
  PPVkImageView                                                  = ^PVkImageView;

  VkShaderModuleCreateFlags                                      = VkFlags;
  PVkShaderModuleCreateFlags                                     = ^VkShaderModuleCreateFlags;
  PPVkShaderModuleCreateFlags                                    = ^PVkShaderModuleCreateFlags;

  _VkShaderModule                                                = record end;
  VkShaderModule                                                 = {$IFDEF VK_CPU64}^_VkShaderModule{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkShaderModule                                                = ^VkShaderModule;
  PPVkShaderModule                                               = ^PVkShaderModule;

  VkPipelineCacheCreateFlags                                     = VkFlags;
  PVkPipelineCacheCreateFlags                                    = ^VkPipelineCacheCreateFlags;
  PPVkPipelineCacheCreateFlags                                   = ^PVkPipelineCacheCreateFlags;

  _VkPipelineCache                                               = record end;
  VkPipelineCache                                                = {$IFDEF VK_CPU64}^_VkPipelineCache{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkPipelineCache                                               = ^VkPipelineCache;
  PPVkPipelineCache                                              = ^PVkPipelineCache;

  VkPipelineCreateFlags                                          = TVkPipelineCreateFlagBits;
  PVkPipelineCreateFlags                                         = ^VkPipelineCreateFlags;
  PPVkPipelineCreateFlags                                        = ^PVkPipelineCreateFlags;

  VkPipelineShaderStageCreateFlags                               = VkFlags;
  PVkPipelineShaderStageCreateFlags                              = ^VkPipelineShaderStageCreateFlags;
  PPVkPipelineShaderStageCreateFlags                             = ^PVkPipelineShaderStageCreateFlags;

  VkPipelineVertexInputStateCreateFlags                          = VkFlags;
  PVkPipelineVertexInputStateCreateFlags                         = ^VkPipelineVertexInputStateCreateFlags;
  PPVkPipelineVertexInputStateCreateFlags                        = ^PVkPipelineVertexInputStateCreateFlags;

  VkPipelineInputAssemblyStateCreateFlags                        = VkFlags;
  PVkPipelineInputAssemblyStateCreateFlags                       = ^VkPipelineInputAssemblyStateCreateFlags;
  PPVkPipelineInputAssemblyStateCreateFlags                      = ^PVkPipelineInputAssemblyStateCreateFlags;

  VkPipelineTessellationStateCreateFlags                         = VkFlags;
  PVkPipelineTessellationStateCreateFlags                        = ^VkPipelineTessellationStateCreateFlags;
  PPVkPipelineTessellationStateCreateFlags                       = ^PVkPipelineTessellationStateCreateFlags;

  VkPipelineViewportStateCreateFlags                             = VkFlags;
  PVkPipelineViewportStateCreateFlags                            = ^VkPipelineViewportStateCreateFlags;
  PPVkPipelineViewportStateCreateFlags                           = ^PVkPipelineViewportStateCreateFlags;

  VkPipelineRasterizationStateCreateFlags                        = VkFlags;
  PVkPipelineRasterizationStateCreateFlags                       = ^VkPipelineRasterizationStateCreateFlags;
  PPVkPipelineRasterizationStateCreateFlags                      = ^PVkPipelineRasterizationStateCreateFlags;

  VkCullModeFlags                                                = TVkCullModeFlagBits;
  PVkCullModeFlags                                               = ^VkCullModeFlags;
  PPVkCullModeFlags                                              = ^PVkCullModeFlags;

  VkPipelineMultisampleStateCreateFlags                          = VkFlags;
  PVkPipelineMultisampleStateCreateFlags                         = ^VkPipelineMultisampleStateCreateFlags;
  PPVkPipelineMultisampleStateCreateFlags                        = ^PVkPipelineMultisampleStateCreateFlags;

  VkSampleMask                                                   = VkUint32;
  PVkSampleMask                                                  = ^VkSampleMask;
  PPVkSampleMask                                                 = ^PVkSampleMask;

  VkPipelineDepthStencilStateCreateFlags                         = VkFlags;
  PVkPipelineDepthStencilStateCreateFlags                        = ^VkPipelineDepthStencilStateCreateFlags;
  PPVkPipelineDepthStencilStateCreateFlags                       = ^PVkPipelineDepthStencilStateCreateFlags;

  VkPipelineColorBlendStateCreateFlags                           = VkFlags;
  PVkPipelineColorBlendStateCreateFlags                          = ^VkPipelineColorBlendStateCreateFlags;
  PPVkPipelineColorBlendStateCreateFlags                         = ^PVkPipelineColorBlendStateCreateFlags;

  VkColorComponentFlags                                          = TVkColorComponentFlagBits;
  PVkColorComponentFlags                                         = ^VkColorComponentFlags;
  PPVkColorComponentFlags                                        = ^PVkColorComponentFlags;

  VkPipelineDynamicStateCreateFlags                              = VkFlags;
  PVkPipelineDynamicStateCreateFlags                             = ^VkPipelineDynamicStateCreateFlags;
  PPVkPipelineDynamicStateCreateFlags                            = ^PVkPipelineDynamicStateCreateFlags;

  _VkPipelineLayout                                              = record end;
  VkPipelineLayout                                               = {$IFDEF VK_CPU64}^_VkPipelineLayout{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkPipelineLayout                                              = ^VkPipelineLayout;
  PPVkPipelineLayout                                             = ^PVkPipelineLayout;

  _VkRenderPass                                                  = record end;
  VkRenderPass                                                   = {$IFDEF VK_CPU64}^_VkRenderPass{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkRenderPass                                                  = ^VkRenderPass;
  PPVkRenderPass                                                 = ^PVkRenderPass;

  _VkPipeline                                                    = record end;
  VkPipeline                                                     = {$IFDEF VK_CPU64}^_VkPipeline{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkPipeline                                                    = ^VkPipeline;
  PPVkPipeline                                                   = ^PVkPipeline;

  VkPipelineLayoutCreateFlags                                    = VkFlags;
  PVkPipelineLayoutCreateFlags                                   = ^VkPipelineLayoutCreateFlags;
  PPVkPipelineLayoutCreateFlags                                  = ^PVkPipelineLayoutCreateFlags;

  _VkDescriptorSetLayout                                         = record end;
  VkDescriptorSetLayout                                          = {$IFDEF VK_CPU64}^_VkDescriptorSetLayout{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkDescriptorSetLayout                                         = ^VkDescriptorSetLayout;
  PPVkDescriptorSetLayout                                        = ^PVkDescriptorSetLayout;

  VkShaderStageFlags                                             = TVkShaderStageFlagBits;
  PVkShaderStageFlags                                            = ^VkShaderStageFlags;
  PPVkShaderStageFlags                                           = ^PVkShaderStageFlags;

  VkSamplerCreateFlags                                           = VkFlags;
  PVkSamplerCreateFlags                                          = ^VkSamplerCreateFlags;
  PPVkSamplerCreateFlags                                         = ^PVkSamplerCreateFlags;

  _VkSampler                                                     = record end;
  VkSampler                                                      = {$IFDEF VK_CPU64}^_VkSampler{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkSampler                                                     = ^VkSampler;
  PPVkSampler                                                    = ^PVkSampler;

  VkDescriptorSetLayoutCreateFlags                               = VkFlags;
  PVkDescriptorSetLayoutCreateFlags                              = ^VkDescriptorSetLayoutCreateFlags;
  PPVkDescriptorSetLayoutCreateFlags                             = ^PVkDescriptorSetLayoutCreateFlags;

  VkDescriptorPoolCreateFlags                                    = TVkDescriptorPoolCreateFlagBits;
  PVkDescriptorPoolCreateFlags                                   = ^VkDescriptorPoolCreateFlags;
  PPVkDescriptorPoolCreateFlags                                  = ^PVkDescriptorPoolCreateFlags;

  _VkDescriptorPool                                              = record end;
  VkDescriptorPool                                               = {$IFDEF VK_CPU64}^_VkDescriptorPool{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkDescriptorPool                                              = ^VkDescriptorPool;
  PPVkDescriptorPool                                             = ^PVkDescriptorPool;

  VkDescriptorPoolResetFlags                                     = VkFlags;
  PVkDescriptorPoolResetFlags                                    = ^VkDescriptorPoolResetFlags;
  PPVkDescriptorPoolResetFlags                                   = ^PVkDescriptorPoolResetFlags;

  _VkDescriptorSet                                               = record end;
  VkDescriptorSet                                                = {$IFDEF VK_CPU64}^_VkDescriptorSet{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkDescriptorSet                                               = ^VkDescriptorSet;
  PPVkDescriptorSet                                              = ^PVkDescriptorSet;

  VkFramebufferCreateFlags                                       = VkFlags;
  PVkFramebufferCreateFlags                                      = ^VkFramebufferCreateFlags;
  PPVkFramebufferCreateFlags                                     = ^PVkFramebufferCreateFlags;

  _VkFramebuffer                                                 = record end;
  VkFramebuffer                                                  = {$IFDEF VK_CPU64}^_VkFramebuffer{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkFramebuffer                                                 = ^VkFramebuffer;
  PPVkFramebuffer                                                = ^PVkFramebuffer;

  VkRenderPassCreateFlags                                        = VkFlags;
  PVkRenderPassCreateFlags                                       = ^VkRenderPassCreateFlags;
  PPVkRenderPassCreateFlags                                      = ^PVkRenderPassCreateFlags;

  VkAttachmentDescriptionFlags                                   = TVkAttachmentDescriptionFlagBits;
  PVkAttachmentDescriptionFlags                                  = ^VkAttachmentDescriptionFlags;
  PPVkAttachmentDescriptionFlags                                 = ^PVkAttachmentDescriptionFlags;

  VkSubpassDescriptionFlags                                      = VkFlags;
  PVkSubpassDescriptionFlags                                     = ^VkSubpassDescriptionFlags;
  PPVkSubpassDescriptionFlags                                    = ^PVkSubpassDescriptionFlags;

  VkAccessFlags                                                  = TVkAccessFlagBits;
  PVkAccessFlags                                                 = ^VkAccessFlags;
  PPVkAccessFlags                                                = ^PVkAccessFlags;

  VkDependencyFlags                                              = TVkDependencyFlagBits;
  PVkDependencyFlags                                             = ^VkDependencyFlags;
  PPVkDependencyFlags                                            = ^PVkDependencyFlags;

  VkCommandPoolCreateFlags                                       = TVkCommandPoolCreateFlagBits;
  PVkCommandPoolCreateFlags                                      = ^VkCommandPoolCreateFlags;
  PPVkCommandPoolCreateFlags                                     = ^PVkCommandPoolCreateFlags;

  VkCommandPoolResetFlags                                        = TVkCommandPoolResetFlagBits;
  PVkCommandPoolResetFlags                                       = ^VkCommandPoolResetFlags;
  PPVkCommandPoolResetFlags                                      = ^PVkCommandPoolResetFlags;

  VkCommandBufferUsageFlags                                      = TVkCommandBufferUsageFlagBits;
  PVkCommandBufferUsageFlags                                     = ^VkCommandBufferUsageFlags;
  PPVkCommandBufferUsageFlags                                    = ^PVkCommandBufferUsageFlags;

  VkQueryControlFlags                                            = TVkQueryControlFlagBits;
  PVkQueryControlFlags                                           = ^VkQueryControlFlags;
  PPVkQueryControlFlags                                          = ^PVkQueryControlFlags;

  VkCommandBufferResetFlags                                      = TVkCommandBufferResetFlagBits;
  PVkCommandBufferResetFlags                                     = ^VkCommandBufferResetFlags;
  PPVkCommandBufferResetFlags                                    = ^PVkCommandBufferResetFlags;

  VkStencilFaceFlags                                             = TVkStencilFaceFlagBits;
  PVkStencilFaceFlags                                            = ^VkStencilFaceFlags;
  PPVkStencilFaceFlags                                           = ^PVkStencilFaceFlags;

{ ========================================== VK_KHR_surface ========================================== }
  _VkSurfaceKHR                                                  = record end;
  VkSurfaceKHR                                                   = {$IFDEF VK_CPU64}^_VkSurfaceKHR{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkSurfaceKHR                                                  = ^VkSurfaceKHR;
  PPVkSurfaceKHR                                                 = ^PVkSurfaceKHR;

  VkSurfaceTransformFlagsKHR                                     = TVkSurfaceTransformFlagBitsKHR;
  PVkSurfaceTransformFlagsKHR                                    = ^VkSurfaceTransformFlagsKHR;
  PPVkSurfaceTransformFlagsKHR                                   = ^PVkSurfaceTransformFlagsKHR;

  VkCompositeAlphaFlagsKHR                                       = TVkCompositeAlphaFlagBitsKHR;
  PVkCompositeAlphaFlagsKHR                                      = ^VkCompositeAlphaFlagsKHR;
  PPVkCompositeAlphaFlagsKHR                                     = ^PVkCompositeAlphaFlagsKHR;

{ ========================================= VK_KHR_swapchain ========================================= }
  VkSwapchainCreateFlagsKHR                                      = VkFlags;
  PVkSwapchainCreateFlagsKHR                                     = ^VkSwapchainCreateFlagsKHR;
  PPVkSwapchainCreateFlagsKHR                                    = ^PVkSwapchainCreateFlagsKHR;

  _VkSwapchainKHR                                                = record end;
  VkSwapchainKHR                                                 = {$IFDEF VK_CPU64}^_VkSwapchainKHR{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkSwapchainKHR                                                = ^VkSwapchainKHR;
  PPVkSwapchainKHR                                               = ^PVkSwapchainKHR;

{ ========================================== VK_KHR_display ========================================== }
  _VkDisplayKHR                                                  = record end;
  VkDisplayKHR                                                   = {$IFDEF VK_CPU64}^_VkDisplayKHR{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkDisplayKHR                                                  = ^VkDisplayKHR;
  PPVkDisplayKHR                                                 = ^PVkDisplayKHR;

  _VkDisplayModeKHR                                              = record end;
  VkDisplayModeKHR                                               = {$IFDEF VK_CPU64}^_VkDisplayModeKHR{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkDisplayModeKHR                                              = ^VkDisplayModeKHR;
  PPVkDisplayModeKHR                                             = ^PVkDisplayModeKHR;

  VkDisplayModeCreateFlagsKHR                                    = VkFlags;
  PVkDisplayModeCreateFlagsKHR                                   = ^VkDisplayModeCreateFlagsKHR;
  PPVkDisplayModeCreateFlagsKHR                                  = ^PVkDisplayModeCreateFlagsKHR;

  VkDisplayPlaneAlphaFlagsKHR                                    = TVkDisplayPlaneAlphaFlagBitsKHR;
  PVkDisplayPlaneAlphaFlagsKHR                                   = ^VkDisplayPlaneAlphaFlagsKHR;
  PPVkDisplayPlaneAlphaFlagsKHR                                  = ^PVkDisplayPlaneAlphaFlagsKHR;

  VkDisplaySurfaceCreateFlagsKHR                                 = VkFlags;
  PVkDisplaySurfaceCreateFlagsKHR                                = ^VkDisplaySurfaceCreateFlagsKHR;
  PPVkDisplaySurfaceCreateFlagsKHR                               = ^PVkDisplaySurfaceCreateFlagsKHR;

{ ======================================= VK_KHR_xlib_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_XLIB_KHR}
  VkXlibSurfaceCreateFlagsKHR                                    = VkFlags;
  PVkXlibSurfaceCreateFlagsKHR                                   = ^VkXlibSurfaceCreateFlagsKHR;
  PPVkXlibSurfaceCreateFlagsKHR                                  = ^PVkXlibSurfaceCreateFlagsKHR;
{$ENDIF}

{ ======================================== VK_KHR_xcb_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_XCB_KHR}
  VkXcbSurfaceCreateFlagsKHR                                     = VkFlags;
  PVkXcbSurfaceCreateFlagsKHR                                    = ^VkXcbSurfaceCreateFlagsKHR;
  PPVkXcbSurfaceCreateFlagsKHR                                   = ^PVkXcbSurfaceCreateFlagsKHR;
{$ENDIF}

{ ====================================== VK_KHR_wayland_surface ====================================== }
{$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}
  VkWaylandSurfaceCreateFlagsKHR                                 = VkFlags;
  PVkWaylandSurfaceCreateFlagsKHR                                = ^VkWaylandSurfaceCreateFlagsKHR;
  PPVkWaylandSurfaceCreateFlagsKHR                               = ^PVkWaylandSurfaceCreateFlagsKHR;
{$ENDIF}

{ ======================================== VK_KHR_mir_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_MIR_KHR}
  VkMirSurfaceCreateFlagsKHR                                     = VkFlags;
  PVkMirSurfaceCreateFlagsKHR                                    = ^VkMirSurfaceCreateFlagsKHR;
  PPVkMirSurfaceCreateFlagsKHR                                   = ^PVkMirSurfaceCreateFlagsKHR;
{$ENDIF}

{ ====================================== VK_KHR_android_surface ====================================== }
{$IFDEF VK_USE_PLATFORM_ANDROID_KHR}
  VkAndroidSurfaceCreateFlagsKHR                                 = VkFlags;
  PVkAndroidSurfaceCreateFlagsKHR                                = ^VkAndroidSurfaceCreateFlagsKHR;
  PPVkAndroidSurfaceCreateFlagsKHR                               = ^PVkAndroidSurfaceCreateFlagsKHR;
{$ENDIF}

{ ======================================= VK_KHR_win32_surface ======================================= }
{$IFDEF VK_USE_PLATFORM_WIN32_KHR}
  VkWin32SurfaceCreateFlagsKHR                                   = VkFlags;
  PVkWin32SurfaceCreateFlagsKHR                                  = ^VkWin32SurfaceCreateFlagsKHR;
  PPVkWin32SurfaceCreateFlagsKHR                                 = ^PVkWin32SurfaceCreateFlagsKHR;
{$ENDIF}

{ ======================================= VK_EXT_debug_report ======================================== }
  VkDebugReportFlagsEXT                                          = TVkDebugReportFlagBitsEXT;
  PVkDebugReportFlagsEXT                                         = ^VkDebugReportFlagsEXT;
  PPVkDebugReportFlagsEXT                                        = ^PVkDebugReportFlagsEXT;

  _VkDebugReportCallbackEXT                                      = record end;
  VkDebugReportCallbackEXT                                       = {$IFDEF VK_CPU64}^_VkDebugReportCallbackEXT{$ELSE}VkNonDispatchableHandle{$ENDIF};
  PVkDebugReportCallbackEXT                                      = ^VkDebugReportCallbackEXT;
  PPVkDebugReportCallbackEXT                                     = ^PVkDebugReportCallbackEXT;

type { function pointers }

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

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

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

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

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

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

{ ======================================= VK_EXT_debug_report ======================================== }
  TvkDebugReportCallbackEXT = function (
          flags:                        VkDebugReportFlagsEXT; 
          objectType:                   TVkDebugReportObjectTypeEXT; 
          uObject:                      VkUint64; 
          location:                     VkSize; 
          messageCode:                  VkInt32; 
          pLayerPrefix:                 PVkChar; 
          pMessage:                     PVkChar; 
          pUserData:                    PVkVoid
  ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

type { structures }

{ ========================================== VK_VERSION_1_0 ========================================== }
  TVkApplicationInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    pApplicationName:                                 PVkChar;
    applicationVersion:                               VkUint32;
    pEngineName:                                      PVkChar;
    engineVersion:                                    VkUint32;
    apiVersion:                                       VkUint32;
  end;
  PVkApplicationInfo = ^TVkApplicationInfo;
  PPVkApplicationInfo = ^PVkApplicationInfo;

  TVkInstanceCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkInstanceCreateFlags;
    pApplicationInfo:                                 PVkApplicationInfo;
    enabledLayerCount:                                VkUint32;
    ppEnabledLayerNames:                              PPVkChar;
    enabledExtensionCount:                            VkUint32;
    ppEnabledExtensionNames:                          PPVkChar;
  end;
  PVkInstanceCreateInfo = ^TVkInstanceCreateInfo;
  PPVkInstanceCreateInfo = ^PVkInstanceCreateInfo;

  TVkAllocationCallbacks = record
    pUserData:                                        PVkVoid;
    pfnAllocation:                                    TvkAllocationFunction;
    pfnReallocation:                                  TvkReallocationFunction;
    pfnFree:                                          TvkFreeFunction;
    pfnInternalAllocation:                            TvkInternalAllocationNotification;
    pfnInternalFree:                                  TvkInternalFreeNotification;
  end;
  PVkAllocationCallbacks = ^TVkAllocationCallbacks;
  PPVkAllocationCallbacks = ^PVkAllocationCallbacks;

  TVkPhysicalDeviceFeatures = record
    robustBufferAccess:                               VkBool32;
    fullDrawIndexUint32:                              VkBool32;
    imageCubeArray:                                   VkBool32;
    independentBlend:                                 VkBool32;
    geometryShader:                                   VkBool32;
    tessellationShader:                               VkBool32;
    sampleRateShading:                                VkBool32;
    dualSrcBlend:                                     VkBool32;
    logicOp:                                          VkBool32;
    multiDrawIndirect:                                VkBool32;
    drawIndirectFirstInstance:                        VkBool32;
    depthClamp:                                       VkBool32;
    depthBiasClamp:                                   VkBool32;
    fillModeNonSolid:                                 VkBool32;
    depthBounds:                                      VkBool32;
    wideLines:                                        VkBool32;
    largePoints:                                      VkBool32;
    alphaToOne:                                       VkBool32;
    multiViewport:                                    VkBool32;
    samplerAnisotropy:                                VkBool32;
    textureCompressionETC2:                           VkBool32;
    textureCompressionASTC_LDR:                       VkBool32;
    textureCompressionBC:                             VkBool32;
    occlusionQueryPrecise:                            VkBool32;
    pipelineStatisticsQuery:                          VkBool32;
    vertexPipelineStoresAndAtomics:                   VkBool32;
    fragmentStoresAndAtomics:                         VkBool32;
    shaderTessellationAndGeometryPointSize:           VkBool32;
    shaderImageGatherExtended:                        VkBool32;
    shaderStorageImageExtendedFormats:                VkBool32;
    shaderStorageImageMultisample:                    VkBool32;
    shaderStorageImageReadWithoutFormat:              VkBool32;
    shaderStorageImageWriteWithoutFormat:             VkBool32;
    shaderUniformBufferArrayDynamicIndexing:          VkBool32;
    shaderSampledImageArrayDynamicIndexing:           VkBool32;
    shaderStorageBufferArrayDynamicIndexing:          VkBool32;
    shaderStorageImageArrayDynamicIndexing:           VkBool32;
    shaderClipDistance:                               VkBool32;
    shaderCullDistance:                               VkBool32;
    shaderFloat64:                                    VkBool32;
    shaderInt64:                                      VkBool32;
    shaderInt16:                                      VkBool32;
    shaderResourceResidency:                          VkBool32;
    shaderResourceMinLod:                             VkBool32;
    sparseBinding:                                    VkBool32;
    sparseResidencyBuffer:                            VkBool32;
    sparseResidencyImage2D:                           VkBool32;
    sparseResidencyImage3D:                           VkBool32;
    sparseResidency2Samples:                          VkBool32;
    sparseResidency4Samples:                          VkBool32;
    sparseResidency8Samples:                          VkBool32;
    sparseResidency16Samples:                         VkBool32;
    sparseResidencyAliased:                           VkBool32;
    variableMultisampleRate:                          VkBool32;
    inheritedQueries:                                 VkBool32;
  end;
  PVkPhysicalDeviceFeatures = ^TVkPhysicalDeviceFeatures;
  PPVkPhysicalDeviceFeatures = ^PVkPhysicalDeviceFeatures;

  TVkFormatProperties = record
    linearTilingFeatures:                             VkFormatFeatureFlags;
    optimalTilingFeatures:                            VkFormatFeatureFlags;
    bufferFeatures:                                   VkFormatFeatureFlags;
  end;
  PVkFormatProperties = ^TVkFormatProperties;
  PPVkFormatProperties = ^PVkFormatProperties;

  TVkExtent3D = record
    width:                                            VkUint32;
    height:                                           VkUint32;
    depth:                                            VkUint32;
  end;
  PVkExtent3D = ^TVkExtent3D;
  PPVkExtent3D = ^PVkExtent3D;

  TVkImageFormatProperties = record
    maxExtent:                                        TVkExtent3D;
    maxMipLevels:                                     VkUint32;
    maxArrayLayers:                                   VkUint32;
    sampleCounts:                                     VkSampleCountFlags;
    maxResourceSize:                                  VkDeviceSize;
  end;
  PVkImageFormatProperties = ^TVkImageFormatProperties;
  PPVkImageFormatProperties = ^PVkImageFormatProperties;

  TVkPhysicalDeviceLimits = record
    maxImageDimension1D:                              VkUint32;
    maxImageDimension2D:                              VkUint32;
    maxImageDimension3D:                              VkUint32;
    maxImageDimensionCube:                            VkUint32;
    maxImageArrayLayers:                              VkUint32;
    maxTexelBufferElements:                           VkUint32;
    maxUniformBufferRange:                            VkUint32;
    maxStorageBufferRange:                            VkUint32;
    maxPushConstantsSize:                             VkUint32;
    maxMemoryAllocationCount:                         VkUint32;
    maxSamplerAllocationCount:                        VkUint32;
    bufferImageGranularity:                           VkDeviceSize;
    sparseAddressSpaceSize:                           VkDeviceSize;
    maxBoundDescriptorSets:                           VkUint32;
    maxPerStageDescriptorSamplers:                    VkUint32;
    maxPerStageDescriptorUniformBuffers:              VkUint32;
    maxPerStageDescriptorStorageBuffers:              VkUint32;
    maxPerStageDescriptorSampledImages:               VkUint32;
    maxPerStageDescriptorStorageImages:               VkUint32;
    maxPerStageDescriptorInputAttachments:            VkUint32;
    maxPerStageResources:                             VkUint32;
    maxDescriptorSetSamplers:                         VkUint32;
    maxDescriptorSetUniformBuffers:                   VkUint32;
    maxDescriptorSetUniformBuffersDynamic:            VkUint32;
    maxDescriptorSetStorageBuffers:                   VkUint32;
    maxDescriptorSetStorageBuffersDynamic:            VkUint32;
    maxDescriptorSetSampledImages:                    VkUint32;
    maxDescriptorSetStorageImages:                    VkUint32;
    maxDescriptorSetInputAttachments:                 VkUint32;
    maxVertexInputAttributes:                         VkUint32;
    maxVertexInputBindings:                           VkUint32;
    maxVertexInputAttributeOffset:                    VkUint32;
    maxVertexInputBindingStride:                      VkUint32;
    maxVertexOutputComponents:                        VkUint32;
    maxTessellationGenerationLevel:                   VkUint32;
    maxTessellationPatchSize:                         VkUint32;
    maxTessellationControlPerVertexInputComponents:   VkUint32;
    maxTessellationControlPerVertexOutputComponents:  VkUint32;
    maxTessellationControlPerPatchOutputComponents:   VkUint32;
    maxTessellationControlTotalOutputComponents:      VkUint32;
    maxTessellationEvaluationInputComponents:         VkUint32;
    maxTessellationEvaluationOutputComponents:        VkUint32;
    maxGeometryShaderInvocations:                     VkUint32;
    maxGeometryInputComponents:                       VkUint32;
    maxGeometryOutputComponents:                      VkUint32;
    maxGeometryOutputVertices:                        VkUint32;
    maxGeometryTotalOutputComponents:                 VkUint32;
    maxFragmentInputComponents:                       VkUint32;
    maxFragmentOutputAttachments:                     VkUint32;
    maxFragmentDualSrcAttachments:                    VkUint32;
    maxFragmentCombinedOutputResources:               VkUint32;
    maxComputeSharedMemorySize:                       VkUint32;
    maxComputeWorkGroupCount:                         array[0..3] of VkUint32;
    maxComputeWorkGroupInvocations:                   VkUint32;
    maxComputeWorkGroupSize:                          array[0..3] of VkUint32;
    subPixelPrecisionBits:                            VkUint32;
    subTexelPrecisionBits:                            VkUint32;
    mipmapPrecisionBits:                              VkUint32;
    maxDrawIndexedIndexValue:                         VkUint32;
    maxDrawIndirectCount:                             VkUint32;
    maxSamplerLodBias:                                VkFloat;
    maxSamplerAnisotropy:                             VkFloat;
    maxViewports:                                     VkUint32;
    maxViewportDimensions:                            array[0..2] of VkUint32;
    viewportBoundsRange:                              array[0..2] of VkFloat;
    viewportSubPixelBits:                             VkUint32;
    minMemoryMapAlignment:                            VkSize;
    minTexelBufferOffsetAlignment:                    VkDeviceSize;
    minUniformBufferOffsetAlignment:                  VkDeviceSize;
    minStorageBufferOffsetAlignment:                  VkDeviceSize;
    minTexelOffset:                                   VkInt32;
    maxTexelOffset:                                   VkUint32;
    minTexelGatherOffset:                             VkInt32;
    maxTexelGatherOffset:                             VkUint32;
    minInterpolationOffset:                           VkFloat;
    maxInterpolationOffset:                           VkFloat;
    subPixelInterpolationOffsetBits:                  VkUint32;
    maxFramebufferWidth:                              VkUint32;
    maxFramebufferHeight:                             VkUint32;
    maxFramebufferLayers:                             VkUint32;
    framebufferColorSampleCounts:                     VkSampleCountFlags;
    framebufferDepthSampleCounts:                     VkSampleCountFlags;
    framebufferStencilSampleCounts:                   VkSampleCountFlags;
    framebufferNoAttachmentsSampleCounts:             VkSampleCountFlags;
    maxColorAttachments:                              VkUint32;
    sampledImageColorSampleCounts:                    VkSampleCountFlags;
    sampledImageIntegerSampleCounts:                  VkSampleCountFlags;
    sampledImageDepthSampleCounts:                    VkSampleCountFlags;
    sampledImageStencilSampleCounts:                  VkSampleCountFlags;
    storageImageSampleCounts:                         VkSampleCountFlags;
    maxSampleMaskWords:                               VkUint32;
    timestampComputeAndGraphics:                      VkBool32;
    timestampPeriod:                                  VkFloat;
    maxClipDistances:                                 VkUint32;
    maxCullDistances:                                 VkUint32;
    maxCombinedClipAndCullDistances:                  VkUint32;
    discreteQueuePriorities:                          VkUint32;
    pointSizeRange:                                   array[0..2] of VkFloat;
    lineWidthRange:                                   array[0..2] of VkFloat;
    pointSizeGranularity:                             VkFloat;
    lineWidthGranularity:                             VkFloat;
    strictLines:                                      VkBool32;
    standardSampleLocations:                          VkBool32;
    optimalBufferCopyOffsetAlignment:                 VkDeviceSize;
    optimalBufferCopyRowPitchAlignment:               VkDeviceSize;
    nonCoherentAtomSize:                              VkDeviceSize;
  end;
  PVkPhysicalDeviceLimits = ^TVkPhysicalDeviceLimits;
  PPVkPhysicalDeviceLimits = ^PVkPhysicalDeviceLimits;

  TVkPhysicalDeviceSparseProperties = record
    residencyStandard2DBlockShape:                    VkBool32;
    residencyStandard2DMultisampleBlockShape:         VkBool32;
    residencyStandard3DBlockShape:                    VkBool32;
    residencyAlignedMipSize:                          VkBool32;
    residencyNonResidentStrict:                       VkBool32;
  end;
  PVkPhysicalDeviceSparseProperties = ^TVkPhysicalDeviceSparseProperties;
  PPVkPhysicalDeviceSparseProperties = ^PVkPhysicalDeviceSparseProperties;

  TVkPhysicalDeviceProperties = record
    apiVersion:                                       VkUint32;
    driverVersion:                                    VkUint32;
    vendorID:                                         VkUint32;
    deviceID:                                         VkUint32;
    deviceType:                                       TVkPhysicalDeviceType;
    deviceName:                                       array[0..VK_MAX_PHYSICAL_DEVICE_NAME_SIZE-1] of VkChar;
    pipelineCacheUUID:                                array[0..VK_UUID_SIZE-1] of VkUint8;
    limits:                                           TVkPhysicalDeviceLimits;
    sparseProperties:                                 TVkPhysicalDeviceSparseProperties;
  end;
  PVkPhysicalDeviceProperties = ^TVkPhysicalDeviceProperties;
  PPVkPhysicalDeviceProperties = ^PVkPhysicalDeviceProperties;

  TVkQueueFamilyProperties = record
    queueFlags:                                       VkQueueFlags;
    queueCount:                                       VkUint32;
    timestampValidBits:                               VkUint32;
    minImageTransferGranularity:                      TVkExtent3D;
  end;
  PVkQueueFamilyProperties = ^TVkQueueFamilyProperties;
  PPVkQueueFamilyProperties = ^PVkQueueFamilyProperties;

  TVkMemoryType = record
    propertyFlags:                                    VkMemoryPropertyFlags;
    heapIndex:                                        VkUint32;
  end;
  PVkMemoryType = ^TVkMemoryType;
  PPVkMemoryType = ^PVkMemoryType;

  TVkMemoryHeap = record
    size:                                             VkDeviceSize;
    flags:                                            VkMemoryHeapFlags;
  end;
  PVkMemoryHeap = ^TVkMemoryHeap;
  PPVkMemoryHeap = ^PVkMemoryHeap;

  TVkPhysicalDeviceMemoryProperties = record
    memoryTypeCount:                                  VkUint32;
    memoryTypes:                                      array[0..VK_MAX_MEMORY_TYPES-1] of TVkMemoryType;
    memoryHeapCount:                                  VkUint32;
    memoryHeaps:                                      array[0..VK_MAX_MEMORY_HEAPS-1] of TVkMemoryHeap;
  end;
  PVkPhysicalDeviceMemoryProperties = ^TVkPhysicalDeviceMemoryProperties;
  PPVkPhysicalDeviceMemoryProperties = ^PVkPhysicalDeviceMemoryProperties;

  TVkDeviceQueueCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkDeviceQueueCreateFlags;
    queueFamilyIndex:                                 VkUint32;
    queueCount:                                       VkUint32;
    pQueuePriorities:                                 PVkFloat;
  end;
  PVkDeviceQueueCreateInfo = ^TVkDeviceQueueCreateInfo;
  PPVkDeviceQueueCreateInfo = ^PVkDeviceQueueCreateInfo;

  TVkDeviceCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkDeviceCreateFlags;
    queueCreateInfoCount:                             VkUint32;
    pQueueCreateInfos:                                PVkDeviceQueueCreateInfo;
    enabledLayerCount:                                VkUint32;
    ppEnabledLayerNames:                              PPVkChar;
    enabledExtensionCount:                            VkUint32;
    ppEnabledExtensionNames:                          PPVkChar;
    pEnabledFeatures:                                 PVkPhysicalDeviceFeatures;
  end;
  PVkDeviceCreateInfo = ^TVkDeviceCreateInfo;
  PPVkDeviceCreateInfo = ^PVkDeviceCreateInfo;

  TVkExtensionProperties = record
    extensionName:                                    array[0..VK_MAX_EXTENSION_NAME_SIZE-1] of VkChar;
    specVersion:                                      VkUint32;
  end;
  PVkExtensionProperties = ^TVkExtensionProperties;
  PPVkExtensionProperties = ^PVkExtensionProperties;

  TVkLayerProperties = record
    layerName:                                        array[0..VK_MAX_EXTENSION_NAME_SIZE-1] of VkChar;
    specVersion:                                      VkUint32;
    implementationVersion:                            VkUint32;
    description:                                      array[0..VK_MAX_DESCRIPTION_SIZE-1] of VkChar;
  end;
  PVkLayerProperties = ^TVkLayerProperties;
  PPVkLayerProperties = ^PVkLayerProperties;

  TVkSubmitInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    waitSemaphoreCount:                               VkUint32;
    pWaitSemaphores:                                  PVkSemaphore;
    pWaitDstStageMask:                                PVkPipelineStageFlags;
    commandBufferCount:                               VkUint32;
    pCommandBuffers:                                  PVkCommandBuffer;
    signalSemaphoreCount:                             VkUint32;
    pSignalSemaphores:                                PVkSemaphore;
  end;
  PVkSubmitInfo = ^TVkSubmitInfo;
  PPVkSubmitInfo = ^PVkSubmitInfo;

  TVkMemoryAllocateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    allocationSize:                                   VkDeviceSize;
    memoryTypeIndex:                                  VkUint32;
  end;
  PVkMemoryAllocateInfo = ^TVkMemoryAllocateInfo;
  PPVkMemoryAllocateInfo = ^PVkMemoryAllocateInfo;

  TVkMappedMemoryRange = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    memory:                                           VkDeviceMemory;
    offset:                                           VkDeviceSize;
    size:                                             VkDeviceSize;
  end;
  PVkMappedMemoryRange = ^TVkMappedMemoryRange;
  PPVkMappedMemoryRange = ^PVkMappedMemoryRange;

  TVkMemoryRequirements = record
    size:                                             VkDeviceSize;
    alignment:                                        VkDeviceSize;
    memoryTypeBits:                                   VkUint32;
  end;
  PVkMemoryRequirements = ^TVkMemoryRequirements;
  PPVkMemoryRequirements = ^PVkMemoryRequirements;

  TVkSparseImageFormatProperties = record
    aspectMask:                                       VkImageAspectFlags;
    imageGranularity:                                 TVkExtent3D;
    flags:                                            VkSparseImageFormatFlags;
  end;
  PVkSparseImageFormatProperties = ^TVkSparseImageFormatProperties;
  PPVkSparseImageFormatProperties = ^PVkSparseImageFormatProperties;

  TVkSparseImageMemoryRequirements = record
    formatProperties:                                 TVkSparseImageFormatProperties;
    imageMipTailFirstLod:                             VkUint32;
    imageMipTailSize:                                 VkDeviceSize;
    imageMipTailOffset:                               VkDeviceSize;
    imageMipTailStride:                               VkDeviceSize;
  end;
  PVkSparseImageMemoryRequirements = ^TVkSparseImageMemoryRequirements;
  PPVkSparseImageMemoryRequirements = ^PVkSparseImageMemoryRequirements;

  TVkSparseMemoryBind = record
    resourceOffset:                                   VkDeviceSize;
    size:                                             VkDeviceSize;
    memory:                                           VkDeviceMemory;
    memoryOffset:                                     VkDeviceSize;
    flags:                                            VkSparseMemoryBindFlags;
  end;
  PVkSparseMemoryBind = ^TVkSparseMemoryBind;
  PPVkSparseMemoryBind = ^PVkSparseMemoryBind;

  TVkSparseBufferMemoryBindInfo = record
    buffer:                                           VkBuffer;
    bindCount:                                        VkUint32;
    pBinds:                                           PVkSparseMemoryBind;
  end;
  PVkSparseBufferMemoryBindInfo = ^TVkSparseBufferMemoryBindInfo;
  PPVkSparseBufferMemoryBindInfo = ^PVkSparseBufferMemoryBindInfo;

  TVkSparseImageOpaqueMemoryBindInfo = record
    image:                                            VkImage;
    bindCount:                                        VkUint32;
    pBinds:                                           PVkSparseMemoryBind;
  end;
  PVkSparseImageOpaqueMemoryBindInfo = ^TVkSparseImageOpaqueMemoryBindInfo;
  PPVkSparseImageOpaqueMemoryBindInfo = ^PVkSparseImageOpaqueMemoryBindInfo;

  TVkImageSubresource = record
    aspectMask:                                       VkImageAspectFlags;
    mipLevel:                                         VkUint32;
    arrayLayer:                                       VkUint32;
  end;
  PVkImageSubresource = ^TVkImageSubresource;
  PPVkImageSubresource = ^PVkImageSubresource;

  TVkOffset3D = record
    x:                                                VkInt32;
    y:                                                VkInt32;
    z:                                                VkInt32;
  end;
  PVkOffset3D = ^TVkOffset3D;
  PPVkOffset3D = ^PVkOffset3D;

  TVkSparseImageMemoryBind = record
    subresource:                                      TVkImageSubresource;
    offset:                                           TVkOffset3D;
    extent:                                           TVkExtent3D;
    memory:                                           VkDeviceMemory;
    memoryOffset:                                     VkDeviceSize;
    flags:                                            VkSparseMemoryBindFlags;
  end;
  PVkSparseImageMemoryBind = ^TVkSparseImageMemoryBind;
  PPVkSparseImageMemoryBind = ^PVkSparseImageMemoryBind;

  TVkSparseImageMemoryBindInfo = record
    image:                                            VkImage;
    bindCount:                                        VkUint32;
    pBinds:                                           PVkSparseImageMemoryBind;
  end;
  PVkSparseImageMemoryBindInfo = ^TVkSparseImageMemoryBindInfo;
  PPVkSparseImageMemoryBindInfo = ^PVkSparseImageMemoryBindInfo;

  TVkBindSparseInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    waitSemaphoreCount:                               VkUint32;
    pWaitSemaphores:                                  PVkSemaphore;
    bufferBindCount:                                  VkUint32;
    pBufferBinds:                                     PVkSparseBufferMemoryBindInfo;
    imageOpaqueBindCount:                             VkUint32;
    pImageOpaqueBinds:                                PVkSparseImageOpaqueMemoryBindInfo;
    imageBindCount:                                   VkUint32;
    pImageBinds:                                      PVkSparseImageMemoryBindInfo;
    signalSemaphoreCount:                             VkUint32;
    pSignalSemaphores:                                PVkSemaphore;
  end;
  PVkBindSparseInfo = ^TVkBindSparseInfo;
  PPVkBindSparseInfo = ^PVkBindSparseInfo;

  TVkFenceCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkFenceCreateFlags;
  end;
  PVkFenceCreateInfo = ^TVkFenceCreateInfo;
  PPVkFenceCreateInfo = ^PVkFenceCreateInfo;

  TVkSemaphoreCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkSemaphoreCreateFlags;
  end;
  PVkSemaphoreCreateInfo = ^TVkSemaphoreCreateInfo;
  PPVkSemaphoreCreateInfo = ^PVkSemaphoreCreateInfo;

  TVkEventCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkEventCreateFlags;
  end;
  PVkEventCreateInfo = ^TVkEventCreateInfo;
  PPVkEventCreateInfo = ^PVkEventCreateInfo;

  TVkQueryPoolCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkQueryPoolCreateFlags;
    queryType:                                        TVkQueryType;
    queryCount:                                       VkUint32;
    pipelineStatistics:                               VkQueryPipelineStatisticFlags;
  end;
  PVkQueryPoolCreateInfo = ^TVkQueryPoolCreateInfo;
  PPVkQueryPoolCreateInfo = ^PVkQueryPoolCreateInfo;

  TVkBufferCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkBufferCreateFlags;
    size:                                             VkDeviceSize;
    usage:                                            VkBufferUsageFlags;
    sharingMode:                                      TVkSharingMode;
    queueFamilyIndexCount:                            VkUint32;
    pQueueFamilyIndices:                              PVkUint32;
  end;
  PVkBufferCreateInfo = ^TVkBufferCreateInfo;
  PPVkBufferCreateInfo = ^PVkBufferCreateInfo;

  TVkBufferViewCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkBufferViewCreateFlags;
    buffer:                                           VkBuffer;
    format:                                           TVkFormat;
    offset:                                           VkDeviceSize;
    range:                                            VkDeviceSize;
  end;
  PVkBufferViewCreateInfo = ^TVkBufferViewCreateInfo;
  PPVkBufferViewCreateInfo = ^PVkBufferViewCreateInfo;

  TVkImageCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkImageCreateFlags;
    imageType:                                        TVkImageType;
    format:                                           TVkFormat;
    extent:                                           TVkExtent3D;
    mipLevels:                                        VkUint32;
    arrayLayers:                                      VkUint32;
    samples:                                          TVkSampleCountFlagBits;
    tiling:                                           TVkImageTiling;
    usage:                                            VkImageUsageFlags;
    sharingMode:                                      TVkSharingMode;
    queueFamilyIndexCount:                            VkUint32;
    pQueueFamilyIndices:                              PVkUint32;
    initialLayout:                                    TVkImageLayout;
  end;
  PVkImageCreateInfo = ^TVkImageCreateInfo;
  PPVkImageCreateInfo = ^PVkImageCreateInfo;

  TVkSubresourceLayout = record
    offset:                                           VkDeviceSize;
    size:                                             VkDeviceSize;
    rowPitch:                                         VkDeviceSize;
    arrayPitch:                                       VkDeviceSize;
    depthPitch:                                       VkDeviceSize;
  end;
  PVkSubresourceLayout = ^TVkSubresourceLayout;
  PPVkSubresourceLayout = ^PVkSubresourceLayout;

  TVkComponentMapping = record
    r:                                                TVkComponentSwizzle;
    g:                                                TVkComponentSwizzle;
    b:                                                TVkComponentSwizzle;
    a:                                                TVkComponentSwizzle;
  end;
  PVkComponentMapping = ^TVkComponentMapping;
  PPVkComponentMapping = ^PVkComponentMapping;

  TVkImageSubresourceRange = record
    aspectMask:                                       VkImageAspectFlags;
    baseMipLevel:                                     VkUint32;
    levelCount:                                       VkUint32;
    baseArrayLayer:                                   VkUint32;
    layerCount:                                       VkUint32;
  end;
  PVkImageSubresourceRange = ^TVkImageSubresourceRange;
  PPVkImageSubresourceRange = ^PVkImageSubresourceRange;

  TVkImageViewCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkImageViewCreateFlags;
    image:                                            VkImage;
    viewType:                                         TVkImageViewType;
    format:                                           TVkFormat;
    components:                                       TVkComponentMapping;
    subresourceRange:                                 TVkImageSubresourceRange;
  end;
  PVkImageViewCreateInfo = ^TVkImageViewCreateInfo;
  PPVkImageViewCreateInfo = ^PVkImageViewCreateInfo;

  TVkShaderModuleCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkShaderModuleCreateFlags;
    codeSize:                                         VkSize;
    pCode:                                            PVkUint32;
  end;
  PVkShaderModuleCreateInfo = ^TVkShaderModuleCreateInfo;
  PPVkShaderModuleCreateInfo = ^PVkShaderModuleCreateInfo;

  TVkPipelineCacheCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineCacheCreateFlags;
    initialDataSize:                                  VkSize;
    pInitialData:                                     PVkVoid;
  end;
  PVkPipelineCacheCreateInfo = ^TVkPipelineCacheCreateInfo;
  PPVkPipelineCacheCreateInfo = ^PVkPipelineCacheCreateInfo;

  TVkSpecializationMapEntry = record
    constantID:                                       VkUint32;
    offset:                                           VkUint32;
    size:                                             VkSize;
  end;
  PVkSpecializationMapEntry = ^TVkSpecializationMapEntry;
  PPVkSpecializationMapEntry = ^PVkSpecializationMapEntry;

  TVkSpecializationInfo = record
    mapEntryCount:                                    VkUint32;
    pMapEntries:                                      PVkSpecializationMapEntry;
    dataSize:                                         VkSize;
    pData:                                            PVkVoid;
  end;
  PVkSpecializationInfo = ^TVkSpecializationInfo;
  PPVkSpecializationInfo = ^PVkSpecializationInfo;

  TVkPipelineShaderStageCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineShaderStageCreateFlags;
    stage:                                            TVkShaderStageFlagBits;
    module:                                           VkShaderModule;
    pName:                                            PVkChar;
    pSpecializationInfo:                              PVkSpecializationInfo;
  end;
  PVkPipelineShaderStageCreateInfo = ^TVkPipelineShaderStageCreateInfo;
  PPVkPipelineShaderStageCreateInfo = ^PVkPipelineShaderStageCreateInfo;

  TVkVertexInputBindingDescription = record
    binding:                                          VkUint32;
    stride:                                           VkUint32;
    inputRate:                                        TVkVertexInputRate;
  end;
  PVkVertexInputBindingDescription = ^TVkVertexInputBindingDescription;
  PPVkVertexInputBindingDescription = ^PVkVertexInputBindingDescription;

  TVkVertexInputAttributeDescription = record
    location:                                         VkUint32;
    binding:                                          VkUint32;
    format:                                           TVkFormat;
    offset:                                           VkUint32;
  end;
  PVkVertexInputAttributeDescription = ^TVkVertexInputAttributeDescription;
  PPVkVertexInputAttributeDescription = ^PVkVertexInputAttributeDescription;

  TVkPipelineVertexInputStateCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineVertexInputStateCreateFlags;
    vertexBindingDescriptionCount:                    VkUint32;
    pVertexBindingDescriptions:                       PVkVertexInputBindingDescription;
    vertexAttributeDescriptionCount:                  VkUint32;
    pVertexAttributeDescriptions:                     PVkVertexInputAttributeDescription;
  end;
  PVkPipelineVertexInputStateCreateInfo = ^TVkPipelineVertexInputStateCreateInfo;
  PPVkPipelineVertexInputStateCreateInfo = ^PVkPipelineVertexInputStateCreateInfo;

  TVkPipelineInputAssemblyStateCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineInputAssemblyStateCreateFlags;
    topology:                                         TVkPrimitiveTopology;
    primitiveRestartEnable:                           VkBool32;
  end;
  PVkPipelineInputAssemblyStateCreateInfo = ^TVkPipelineInputAssemblyStateCreateInfo;
  PPVkPipelineInputAssemblyStateCreateInfo = ^PVkPipelineInputAssemblyStateCreateInfo;

  TVkPipelineTessellationStateCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineTessellationStateCreateFlags;
    patchControlPoints:                               VkUint32;
  end;
  PVkPipelineTessellationStateCreateInfo = ^TVkPipelineTessellationStateCreateInfo;
  PPVkPipelineTessellationStateCreateInfo = ^PVkPipelineTessellationStateCreateInfo;

  TVkViewport = record
    x:                                                VkFloat;
    y:                                                VkFloat;
    width:                                            VkFloat;
    height:                                           VkFloat;
    minDepth:                                         VkFloat;
    maxDepth:                                         VkFloat;
  end;
  PVkViewport = ^TVkViewport;
  PPVkViewport = ^PVkViewport;

  TVkOffset2D = record
    x:                                                VkInt32;
    y:                                                VkInt32;
  end;
  PVkOffset2D = ^TVkOffset2D;
  PPVkOffset2D = ^PVkOffset2D;

  TVkExtent2D = record
    width:                                            VkUint32;
    height:                                           VkUint32;
  end;
  PVkExtent2D = ^TVkExtent2D;
  PPVkExtent2D = ^PVkExtent2D;

  TVkRect2D = record
    offset:                                           TVkOffset2D;
    extent:                                           TVkExtent2D;
  end;
  PVkRect2D = ^TVkRect2D;
  PPVkRect2D = ^PVkRect2D;

  TVkPipelineViewportStateCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineViewportStateCreateFlags;
    viewportCount:                                    VkUint32;
    pViewports:                                       PVkViewport;
    scissorCount:                                     VkUint32;
    pScissors:                                        PVkRect2D;
  end;
  PVkPipelineViewportStateCreateInfo = ^TVkPipelineViewportStateCreateInfo;
  PPVkPipelineViewportStateCreateInfo = ^PVkPipelineViewportStateCreateInfo;

  TVkPipelineRasterizationStateCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineRasterizationStateCreateFlags;
    depthClampEnable:                                 VkBool32;
    rasterizerDiscardEnable:                          VkBool32;
    polygonMode:                                      TVkPolygonMode;
    cullMode:                                         VkCullModeFlags;
    frontFace:                                        TVkFrontFace;
    depthBiasEnable:                                  VkBool32;
    depthBiasConstantFactor:                          VkFloat;
    depthBiasClamp:                                   VkFloat;
    depthBiasSlopeFactor:                             VkFloat;
    lineWidth:                                        VkFloat;
  end;
  PVkPipelineRasterizationStateCreateInfo = ^TVkPipelineRasterizationStateCreateInfo;
  PPVkPipelineRasterizationStateCreateInfo = ^PVkPipelineRasterizationStateCreateInfo;

  TVkPipelineMultisampleStateCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineMultisampleStateCreateFlags;
    rasterizationSamples:                             TVkSampleCountFlagBits;
    sampleShadingEnable:                              VkBool32;
    minSampleShading:                                 VkFloat;
    pSampleMask:                                      PVkSampleMask;
    alphaToCoverageEnable:                            VkBool32;
    alphaToOneEnable:                                 VkBool32;
  end;
  PVkPipelineMultisampleStateCreateInfo = ^TVkPipelineMultisampleStateCreateInfo;
  PPVkPipelineMultisampleStateCreateInfo = ^PVkPipelineMultisampleStateCreateInfo;

  TVkStencilOpState = record
    failOp:                                           TVkStencilOp;
    passOp:                                           TVkStencilOp;
    depthFailOp:                                      TVkStencilOp;
    compareOp:                                        TVkCompareOp;
    compareMask:                                      VkUint32;
    writeMask:                                        VkUint32;
    reference:                                        VkUint32;
  end;
  PVkStencilOpState = ^TVkStencilOpState;
  PPVkStencilOpState = ^PVkStencilOpState;

  TVkPipelineDepthStencilStateCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineDepthStencilStateCreateFlags;
    depthTestEnable:                                  VkBool32;
    depthWriteEnable:                                 VkBool32;
    depthCompareOp:                                   TVkCompareOp;
    depthBoundsTestEnable:                            VkBool32;
    stencilTestEnable:                                VkBool32;
    front:                                            TVkStencilOpState;
    back:                                             TVkStencilOpState;
    minDepthBounds:                                   VkFloat;
    maxDepthBounds:                                   VkFloat;
  end;
  PVkPipelineDepthStencilStateCreateInfo = ^TVkPipelineDepthStencilStateCreateInfo;
  PPVkPipelineDepthStencilStateCreateInfo = ^PVkPipelineDepthStencilStateCreateInfo;

  TVkPipelineColorBlendAttachmentState = record
    blendEnable:                                      VkBool32;
    srcColorBlendFactor:                              TVkBlendFactor;
    dstColorBlendFactor:                              TVkBlendFactor;
    colorBlendOp:                                     TVkBlendOp;
    srcAlphaBlendFactor:                              TVkBlendFactor;
    dstAlphaBlendFactor:                              TVkBlendFactor;
    alphaBlendOp:                                     TVkBlendOp;
    colorWriteMask:                                   VkColorComponentFlags;
  end;
  PVkPipelineColorBlendAttachmentState = ^TVkPipelineColorBlendAttachmentState;
  PPVkPipelineColorBlendAttachmentState = ^PVkPipelineColorBlendAttachmentState;

  TVkPipelineColorBlendStateCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineColorBlendStateCreateFlags;
    logicOpEnable:                                    VkBool32;
    logicOp:                                          TVkLogicOp;
    attachmentCount:                                  VkUint32;
    pAttachments:                                     PVkPipelineColorBlendAttachmentState;
    blendConstants:                                   array[0..4] of VkFloat;
  end;
  PVkPipelineColorBlendStateCreateInfo = ^TVkPipelineColorBlendStateCreateInfo;
  PPVkPipelineColorBlendStateCreateInfo = ^PVkPipelineColorBlendStateCreateInfo;

  TVkPipelineDynamicStateCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineDynamicStateCreateFlags;
    dynamicStateCount:                                VkUint32;
    pDynamicStates:                                   PVkDynamicState;
  end;
  PVkPipelineDynamicStateCreateInfo = ^TVkPipelineDynamicStateCreateInfo;
  PPVkPipelineDynamicStateCreateInfo = ^PVkPipelineDynamicStateCreateInfo;

  TVkGraphicsPipelineCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineCreateFlags;
    stageCount:                                       VkUint32;
    pStages:                                          PVkPipelineShaderStageCreateInfo;
    pVertexInputState:                                PVkPipelineVertexInputStateCreateInfo;
    pInputAssemblyState:                              PVkPipelineInputAssemblyStateCreateInfo;
    pTessellationState:                               PVkPipelineTessellationStateCreateInfo;
    pViewportState:                                   PVkPipelineViewportStateCreateInfo;
    pRasterizationState:                              PVkPipelineRasterizationStateCreateInfo;
    pMultisampleState:                                PVkPipelineMultisampleStateCreateInfo;
    pDepthStencilState:                               PVkPipelineDepthStencilStateCreateInfo;
    pColorBlendState:                                 PVkPipelineColorBlendStateCreateInfo;
    pDynamicState:                                    PVkPipelineDynamicStateCreateInfo;
    layout:                                           VkPipelineLayout;
    renderPass:                                       VkRenderPass;
    subpass:                                          VkUint32;
    basePipelineHandle:                               VkPipeline;
    basePipelineIndex:                                VkInt32;
  end;
  PVkGraphicsPipelineCreateInfo = ^TVkGraphicsPipelineCreateInfo;
  PPVkGraphicsPipelineCreateInfo = ^PVkGraphicsPipelineCreateInfo;

  TVkComputePipelineCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineCreateFlags;
    stage:                                            TVkPipelineShaderStageCreateInfo;
    layout:                                           VkPipelineLayout;
    basePipelineHandle:                               VkPipeline;
    basePipelineIndex:                                VkInt32;
  end;
  PVkComputePipelineCreateInfo = ^TVkComputePipelineCreateInfo;
  PPVkComputePipelineCreateInfo = ^PVkComputePipelineCreateInfo;

  TVkPushConstantRange = record
    stageFlags:                                       VkShaderStageFlags;
    offset:                                           VkUint32;
    size:                                             VkUint32;
  end;
  PVkPushConstantRange = ^TVkPushConstantRange;
  PPVkPushConstantRange = ^PVkPushConstantRange;

  TVkPipelineLayoutCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkPipelineLayoutCreateFlags;
    setLayoutCount:                                   VkUint32;
    pSetLayouts:                                      PVkDescriptorSetLayout;
    pushConstantRangeCount:                           VkUint32;
    pPushConstantRanges:                              PVkPushConstantRange;
  end;
  PVkPipelineLayoutCreateInfo = ^TVkPipelineLayoutCreateInfo;
  PPVkPipelineLayoutCreateInfo = ^PVkPipelineLayoutCreateInfo;

  TVkSamplerCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkSamplerCreateFlags;
    magFilter:                                        TVkFilter;
    minFilter:                                        TVkFilter;
    mipmapMode:                                       TVkSamplerMipmapMode;
    addressModeU:                                     TVkSamplerAddressMode;
    addressModeV:                                     TVkSamplerAddressMode;
    addressModeW:                                     TVkSamplerAddressMode;
    mipLodBias:                                       VkFloat;
    anisotropyEnable:                                 VkBool32;
    maxAnisotropy:                                    VkFloat;
    compareEnable:                                    VkBool32;
    compareOp:                                        TVkCompareOp;
    minLod:                                           VkFloat;
    maxLod:                                           VkFloat;
    borderColor:                                      TVkBorderColor;
    unnormalizedCoordinates:                          VkBool32;
  end;
  PVkSamplerCreateInfo = ^TVkSamplerCreateInfo;
  PPVkSamplerCreateInfo = ^PVkSamplerCreateInfo;

  TVkDescriptorSetLayoutBinding = record
    binding:                                          VkUint32;
    descriptorType:                                   TVkDescriptorType;
    descriptorCount:                                  VkUint32;
    stageFlags:                                       VkShaderStageFlags;
    pImmutableSamplers:                               PVkSampler;
  end;
  PVkDescriptorSetLayoutBinding = ^TVkDescriptorSetLayoutBinding;
  PPVkDescriptorSetLayoutBinding = ^PVkDescriptorSetLayoutBinding;

  TVkDescriptorSetLayoutCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkDescriptorSetLayoutCreateFlags;
    bindingCount:                                     VkUint32;
    pBindings:                                        PVkDescriptorSetLayoutBinding;
  end;
  PVkDescriptorSetLayoutCreateInfo = ^TVkDescriptorSetLayoutCreateInfo;
  PPVkDescriptorSetLayoutCreateInfo = ^PVkDescriptorSetLayoutCreateInfo;

  TVkDescriptorPoolSize = record
    dType:                                            TVkDescriptorType;
    descriptorCount:                                  VkUint32;
  end;
  PVkDescriptorPoolSize = ^TVkDescriptorPoolSize;
  PPVkDescriptorPoolSize = ^PVkDescriptorPoolSize;

  TVkDescriptorPoolCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkDescriptorPoolCreateFlags;
    maxSets:                                          VkUint32;
    poolSizeCount:                                    VkUint32;
    pPoolSizes:                                       PVkDescriptorPoolSize;
  end;
  PVkDescriptorPoolCreateInfo = ^TVkDescriptorPoolCreateInfo;
  PPVkDescriptorPoolCreateInfo = ^PVkDescriptorPoolCreateInfo;

  TVkDescriptorSetAllocateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    descriptorPool:                                   VkDescriptorPool;
    descriptorSetCount:                               VkUint32;
    pSetLayouts:                                      PVkDescriptorSetLayout;
  end;
  PVkDescriptorSetAllocateInfo = ^TVkDescriptorSetAllocateInfo;
  PPVkDescriptorSetAllocateInfo = ^PVkDescriptorSetAllocateInfo;

  TVkDescriptorImageInfo = record
    sampler:                                          VkSampler;
    imageView:                                        VkImageView;
    imageLayout:                                      TVkImageLayout;
  end;
  PVkDescriptorImageInfo = ^TVkDescriptorImageInfo;
  PPVkDescriptorImageInfo = ^PVkDescriptorImageInfo;

  TVkDescriptorBufferInfo = record
    buffer:                                           VkBuffer;
    offset:                                           VkDeviceSize;
    range:                                            VkDeviceSize;
  end;
  PVkDescriptorBufferInfo = ^TVkDescriptorBufferInfo;
  PPVkDescriptorBufferInfo = ^PVkDescriptorBufferInfo;

  TVkWriteDescriptorSet = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    dstSet:                                           VkDescriptorSet;
    dstBinding:                                       VkUint32;
    dstArrayElement:                                  VkUint32;
    descriptorCount:                                  VkUint32;
    descriptorType:                                   TVkDescriptorType;
    pImageInfo:                                       PVkDescriptorImageInfo;
    pBufferInfo:                                      PVkDescriptorBufferInfo;
    pTexelBufferView:                                 PVkBufferView;
  end;
  PVkWriteDescriptorSet = ^TVkWriteDescriptorSet;
  PPVkWriteDescriptorSet = ^PVkWriteDescriptorSet;

  TVkCopyDescriptorSet = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    srcSet:                                           VkDescriptorSet;
    srcBinding:                                       VkUint32;
    srcArrayElement:                                  VkUint32;
    dstSet:                                           VkDescriptorSet;
    dstBinding:                                       VkUint32;
    dstArrayElement:                                  VkUint32;
    descriptorCount:                                  VkUint32;
  end;
  PVkCopyDescriptorSet = ^TVkCopyDescriptorSet;
  PPVkCopyDescriptorSet = ^PVkCopyDescriptorSet;

  TVkFramebufferCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkFramebufferCreateFlags;
    renderPass:                                       VkRenderPass;
    attachmentCount:                                  VkUint32;
    pAttachments:                                     PVkImageView;
    width:                                            VkUint32;
    height:                                           VkUint32;
    layers:                                           VkUint32;
  end;
  PVkFramebufferCreateInfo = ^TVkFramebufferCreateInfo;
  PPVkFramebufferCreateInfo = ^PVkFramebufferCreateInfo;

  TVkAttachmentDescription = record
    flags:                                            VkAttachmentDescriptionFlags;
    format:                                           TVkFormat;
    samples:                                          TVkSampleCountFlagBits;
    loadOp:                                           TVkAttachmentLoadOp;
    storeOp:                                          TVkAttachmentStoreOp;
    stencilLoadOp:                                    TVkAttachmentLoadOp;
    stencilStoreOp:                                   TVkAttachmentStoreOp;
    initialLayout:                                    TVkImageLayout;
    finalLayout:                                      TVkImageLayout;
  end;
  PVkAttachmentDescription = ^TVkAttachmentDescription;
  PPVkAttachmentDescription = ^PVkAttachmentDescription;

  TVkAttachmentReference = record
    attachment:                                       VkUint32;
    layout:                                           TVkImageLayout;
  end;
  PVkAttachmentReference = ^TVkAttachmentReference;
  PPVkAttachmentReference = ^PVkAttachmentReference;

  TVkSubpassDescription = record
    flags:                                            VkSubpassDescriptionFlags;
    pipelineBindPoint:                                TVkPipelineBindPoint;
    inputAttachmentCount:                             VkUint32;
    pInputAttachments:                                PVkAttachmentReference;
    colorAttachmentCount:                             VkUint32;
    pColorAttachments:                                PVkAttachmentReference;
    pResolveAttachments:                              PVkAttachmentReference;
    pDepthStencilAttachment:                          PVkAttachmentReference;
    preserveAttachmentCount:                          VkUint32;
    pPreserveAttachments:                             PVkUint32;
  end;
  PVkSubpassDescription = ^TVkSubpassDescription;
  PPVkSubpassDescription = ^PVkSubpassDescription;

  TVkSubpassDependency = record
    srcSubpass:                                       VkUint32;
    dstSubpass:                                       VkUint32;
    srcStageMask:                                     VkPipelineStageFlags;
    dstStageMask:                                     VkPipelineStageFlags;
    srcAccessMask:                                    VkAccessFlags;
    dstAccessMask:                                    VkAccessFlags;
    dependencyFlags:                                  VkDependencyFlags;
  end;
  PVkSubpassDependency = ^TVkSubpassDependency;
  PPVkSubpassDependency = ^PVkSubpassDependency;

  TVkRenderPassCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkRenderPassCreateFlags;
    attachmentCount:                                  VkUint32;
    pAttachments:                                     PVkAttachmentDescription;
    subpassCount:                                     VkUint32;
    pSubpasses:                                       PVkSubpassDescription;
    dependencyCount:                                  VkUint32;
    pDependencies:                                    PVkSubpassDependency;
  end;
  PVkRenderPassCreateInfo = ^TVkRenderPassCreateInfo;
  PPVkRenderPassCreateInfo = ^PVkRenderPassCreateInfo;

  TVkCommandPoolCreateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkCommandPoolCreateFlags;
    queueFamilyIndex:                                 VkUint32;
  end;
  PVkCommandPoolCreateInfo = ^TVkCommandPoolCreateInfo;
  PPVkCommandPoolCreateInfo = ^PVkCommandPoolCreateInfo;

  TVkCommandBufferAllocateInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    commandPool:                                      VkCommandPool;
    level:                                            TVkCommandBufferLevel;
    commandBufferCount:                               VkUint32;
  end;
  PVkCommandBufferAllocateInfo = ^TVkCommandBufferAllocateInfo;
  PPVkCommandBufferAllocateInfo = ^PVkCommandBufferAllocateInfo;

  TVkCommandBufferInheritanceInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    renderPass:                                       VkRenderPass;
    subpass:                                          VkUint32;
    framebuffer:                                      VkFramebuffer;
    occlusionQueryEnable:                             VkBool32;
    queryFlags:                                       VkQueryControlFlags;
    pipelineStatistics:                               VkQueryPipelineStatisticFlags;
  end;
  PVkCommandBufferInheritanceInfo = ^TVkCommandBufferInheritanceInfo;
  PPVkCommandBufferInheritanceInfo = ^PVkCommandBufferInheritanceInfo;

  TVkCommandBufferBeginInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkCommandBufferUsageFlags;
    pInheritanceInfo:                                 PVkCommandBufferInheritanceInfo;
  end;
  PVkCommandBufferBeginInfo = ^TVkCommandBufferBeginInfo;
  PPVkCommandBufferBeginInfo = ^PVkCommandBufferBeginInfo;

  TVkBufferCopy = record
    srcOffset:                                        VkDeviceSize;
    dstOffset:                                        VkDeviceSize;
    size:                                             VkDeviceSize;
  end;
  PVkBufferCopy = ^TVkBufferCopy;
  PPVkBufferCopy = ^PVkBufferCopy;

  TVkImageSubresourceLayers = record
    aspectMask:                                       VkImageAspectFlags;
    mipLevel:                                         VkUint32;
    baseArrayLayer:                                   VkUint32;
    layerCount:                                       VkUint32;
  end;
  PVkImageSubresourceLayers = ^TVkImageSubresourceLayers;
  PPVkImageSubresourceLayers = ^PVkImageSubresourceLayers;

  TVkImageCopy = record
    srcSubresource:                                   TVkImageSubresourceLayers;
    srcOffset:                                        TVkOffset3D;
    dstSubresource:                                   TVkImageSubresourceLayers;
    dstOffset:                                        TVkOffset3D;
    extent:                                           TVkExtent3D;
  end;
  PVkImageCopy = ^TVkImageCopy;
  PPVkImageCopy = ^PVkImageCopy;

  TVkImageBlit = record
    srcSubresource:                                   TVkImageSubresourceLayers;
    srcOffsets:                                       array[0..2] of TVkOffset3D;
    dstSubresource:                                   TVkImageSubresourceLayers;
    dstOffsets:                                       array[0..2] of TVkOffset3D;
  end;
  PVkImageBlit = ^TVkImageBlit;
  PPVkImageBlit = ^PVkImageBlit;

  TVkBufferImageCopy = record
    bufferOffset:                                     VkDeviceSize;
    bufferRowLength:                                  VkUint32;
    bufferImageHeight:                                VkUint32;
    imageSubresource:                                 TVkImageSubresourceLayers;
    imageOffset:                                      TVkOffset3D;
    imageExtent:                                      TVkExtent3D;
  end;
  PVkBufferImageCopy = ^TVkBufferImageCopy;
  PPVkBufferImageCopy = ^PVkBufferImageCopy;

  TVkClearColorValue = record
    case Integer of
      000: (float32:                                  array[0..4] of VkFloat);
      001: (int32:                                    array[0..4] of VkInt32);
      002: (uint32:                                   array[0..4] of VkUint32);
  end;
  PVkClearColorValue = ^TVkClearColorValue;
  PPVkClearColorValue = ^PVkClearColorValue;

  TVkClearDepthStencilValue = record
    depth:                                            VkFloat;
    stencil:                                          VkUint32;
  end;
  PVkClearDepthStencilValue = ^TVkClearDepthStencilValue;
  PPVkClearDepthStencilValue = ^PVkClearDepthStencilValue;

  TVkClearValue = record
    case Integer of
      000: (color:                                    TVkClearColorValue);
      001: (depthStencil:                             TVkClearDepthStencilValue);
  end;
  PVkClearValue = ^TVkClearValue;
  PPVkClearValue = ^PVkClearValue;

  TVkClearAttachment = record
    aspectMask:                                       VkImageAspectFlags;
    colorAttachment:                                  VkUint32;
    clearValue:                                       TVkClearValue;
  end;
  PVkClearAttachment = ^TVkClearAttachment;
  PPVkClearAttachment = ^PVkClearAttachment;

  TVkClearRect = record
    rect:                                             TVkRect2D;
    baseArrayLayer:                                   VkUint32;
    layerCount:                                       VkUint32;
  end;
  PVkClearRect = ^TVkClearRect;
  PPVkClearRect = ^PVkClearRect;

  TVkImageResolve = record
    srcSubresource:                                   TVkImageSubresourceLayers;
    srcOffset:                                        TVkOffset3D;
    dstSubresource:                                   TVkImageSubresourceLayers;
    dstOffset:                                        TVkOffset3D;
    extent:                                           TVkExtent3D;
  end;
  PVkImageResolve = ^TVkImageResolve;
  PPVkImageResolve = ^PVkImageResolve;

  TVkMemoryBarrier = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    srcAccessMask:                                    VkAccessFlags;
    dstAccessMask:                                    VkAccessFlags;
  end;
  PVkMemoryBarrier = ^TVkMemoryBarrier;
  PPVkMemoryBarrier = ^PVkMemoryBarrier;

  TVkBufferMemoryBarrier = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    srcAccessMask:                                    VkAccessFlags;
    dstAccessMask:                                    VkAccessFlags;
    srcQueueFamilyIndex:                              VkUint32;
    dstQueueFamilyIndex:                              VkUint32;
    buffer:                                           VkBuffer;
    offset:                                           VkDeviceSize;
    size:                                             VkDeviceSize;
  end;
  PVkBufferMemoryBarrier = ^TVkBufferMemoryBarrier;
  PPVkBufferMemoryBarrier = ^PVkBufferMemoryBarrier;

  TVkImageMemoryBarrier = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    srcAccessMask:                                    VkAccessFlags;
    dstAccessMask:                                    VkAccessFlags;
    oldLayout:                                        TVkImageLayout;
    newLayout:                                        TVkImageLayout;
    srcQueueFamilyIndex:                              VkUint32;
    dstQueueFamilyIndex:                              VkUint32;
    image:                                            VkImage;
    subresourceRange:                                 TVkImageSubresourceRange;
  end;
  PVkImageMemoryBarrier = ^TVkImageMemoryBarrier;
  PPVkImageMemoryBarrier = ^PVkImageMemoryBarrier;

  TVkRenderPassBeginInfo = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    renderPass:                                       VkRenderPass;
    framebuffer:                                      VkFramebuffer;
    renderArea:                                       TVkRect2D;
    clearValueCount:                                  VkUint32;
    pClearValues:                                     PVkClearValue;
  end;
  PVkRenderPassBeginInfo = ^TVkRenderPassBeginInfo;
  PPVkRenderPassBeginInfo = ^PVkRenderPassBeginInfo;

  TVkDispatchIndirectCommand = record
    x:                                                VkUint32;
    y:                                                VkUint32;
    z:                                                VkUint32;
  end;
  PVkDispatchIndirectCommand = ^TVkDispatchIndirectCommand;
  PPVkDispatchIndirectCommand = ^PVkDispatchIndirectCommand;

  TVkDrawIndexedIndirectCommand = record
    indexCount:                                       VkUint32;
    instanceCount:                                    VkUint32;
    firstIndex:                                       VkUint32;
    vertexOffset:                                     VkInt32;
    firstInstance:                                    VkUint32;
  end;
  PVkDrawIndexedIndirectCommand = ^TVkDrawIndexedIndirectCommand;
  PPVkDrawIndexedIndirectCommand = ^PVkDrawIndexedIndirectCommand;

  TVkDrawIndirectCommand = record
    vertexCount:                                      VkUint32;
    instanceCount:                                    VkUint32;
    firstVertex:                                      VkUint32;
    firstInstance:                                    VkUint32;
  end;
  PVkDrawIndirectCommand = ^TVkDrawIndirectCommand;
  PPVkDrawIndirectCommand = ^PVkDrawIndirectCommand;

{ ========================================== VK_KHR_surface ========================================== }
  TVkSurfaceCapabilitiesKHR = record
    minImageCount:                                    VkUint32;
    maxImageCount:                                    VkUint32;
    currentExtent:                                    TVkExtent2D;
    minImageExtent:                                   TVkExtent2D;
    maxImageExtent:                                   TVkExtent2D;
    maxImageArrayLayers:                              VkUint32;
    supportedTransforms:                              VkSurfaceTransformFlagsKHR;
    currentTransform:                                 TVkSurfaceTransformFlagBitsKHR;
    supportedCompositeAlpha:                          VkCompositeAlphaFlagsKHR;
    supportedUsageFlags:                              VkImageUsageFlags;
  end;
  PVkSurfaceCapabilitiesKHR = ^TVkSurfaceCapabilitiesKHR;
  PPVkSurfaceCapabilitiesKHR = ^PVkSurfaceCapabilitiesKHR;

  TVkSurfaceFormatKHR = record
    format:                                           TVkFormat;
    colorSpace:                                       TVkColorSpaceKHR;
  end;
  PVkSurfaceFormatKHR = ^TVkSurfaceFormatKHR;
  PPVkSurfaceFormatKHR = ^PVkSurfaceFormatKHR;

{ ========================================= VK_KHR_swapchain ========================================= }
  TVkSwapchainCreateInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkSwapchainCreateFlagsKHR;
    surface:                                          VkSurfaceKHR;
    minImageCount:                                    VkUint32;
    imageFormat:                                      TVkFormat;
    imageColorSpace:                                  TVkColorSpaceKHR;
    imageExtent:                                      TVkExtent2D;
    imageArrayLayers:                                 VkUint32;
    imageUsage:                                       VkImageUsageFlags;
    imageSharingMode:                                 TVkSharingMode;
    queueFamilyIndexCount:                            VkUint32;
    pQueueFamilyIndices:                              PVkUint32;
    preTransform:                                     TVkSurfaceTransformFlagBitsKHR;
    compositeAlpha:                                   TVkCompositeAlphaFlagBitsKHR;
    presentMode:                                      TVkPresentModeKHR;
    clipped:                                          VkBool32;
    oldSwapchain:                                     VkSwapchainKHR;
  end;
  PVkSwapchainCreateInfoKHR = ^TVkSwapchainCreateInfoKHR;
  PPVkSwapchainCreateInfoKHR = ^PVkSwapchainCreateInfoKHR;

  TVkPresentInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    waitSemaphoreCount:                               VkUint32;
    pWaitSemaphores:                                  PVkSemaphore;
    swapchainCount:                                   VkUint32;
    pSwapchains:                                      PVkSwapchainKHR;
    pImageIndices:                                    PVkUint32;
    pResults:                                         PVkResult;
  end;
  PVkPresentInfoKHR = ^TVkPresentInfoKHR;
  PPVkPresentInfoKHR = ^PVkPresentInfoKHR;

{ ========================================== VK_KHR_display ========================================== }
  TVkDisplayPropertiesKHR = record
    display:                                          VkDisplayKHR;
    displayName:                                      PVkChar;
    physicalDimensions:                               TVkExtent2D;
    physicalResolution:                               TVkExtent2D;
    supportedTransforms:                              VkSurfaceTransformFlagsKHR;
    planeReorderPossible:                             VkBool32;
    persistentContent:                                VkBool32;
  end;
  PVkDisplayPropertiesKHR = ^TVkDisplayPropertiesKHR;
  PPVkDisplayPropertiesKHR = ^PVkDisplayPropertiesKHR;

  TVkDisplayModeParametersKHR = record
    visibleRegion:                                    TVkExtent2D;
    refreshRate:                                      VkUint32;
  end;
  PVkDisplayModeParametersKHR = ^TVkDisplayModeParametersKHR;
  PPVkDisplayModeParametersKHR = ^PVkDisplayModeParametersKHR;

  TVkDisplayModePropertiesKHR = record
    displayMode:                                      VkDisplayModeKHR;
    parameters:                                       TVkDisplayModeParametersKHR;
  end;
  PVkDisplayModePropertiesKHR = ^TVkDisplayModePropertiesKHR;
  PPVkDisplayModePropertiesKHR = ^PVkDisplayModePropertiesKHR;

  TVkDisplayModeCreateInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkDisplayModeCreateFlagsKHR;
    parameters:                                       TVkDisplayModeParametersKHR;
  end;
  PVkDisplayModeCreateInfoKHR = ^TVkDisplayModeCreateInfoKHR;
  PPVkDisplayModeCreateInfoKHR = ^PVkDisplayModeCreateInfoKHR;

  TVkDisplayPlaneCapabilitiesKHR = record
    supportedAlpha:                                   VkDisplayPlaneAlphaFlagsKHR;
    minSrcPosition:                                   TVkOffset2D;
    maxSrcPosition:                                   TVkOffset2D;
    minSrcExtent:                                     TVkExtent2D;
    maxSrcExtent:                                     TVkExtent2D;
    minDstPosition:                                   TVkOffset2D;
    maxDstPosition:                                   TVkOffset2D;
    minDstExtent:                                     TVkExtent2D;
    maxDstExtent:                                     TVkExtent2D;
  end;
  PVkDisplayPlaneCapabilitiesKHR = ^TVkDisplayPlaneCapabilitiesKHR;
  PPVkDisplayPlaneCapabilitiesKHR = ^PVkDisplayPlaneCapabilitiesKHR;

  TVkDisplayPlanePropertiesKHR = record
    currentDisplay:                                   VkDisplayKHR;
    currentStackIndex:                                VkUint32;
  end;
  PVkDisplayPlanePropertiesKHR = ^TVkDisplayPlanePropertiesKHR;
  PPVkDisplayPlanePropertiesKHR = ^PVkDisplayPlanePropertiesKHR;

  TVkDisplaySurfaceCreateInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkDisplaySurfaceCreateFlagsKHR;
    displayMode:                                      VkDisplayModeKHR;
    planeIndex:                                       VkUint32;
    planeStackIndex:                                  VkUint32;
    transform:                                        TVkSurfaceTransformFlagBitsKHR;
    globalAlpha:                                      VkFloat;
    alphaMode:                                        TVkDisplayPlaneAlphaFlagBitsKHR;
    imageExtent:                                      TVkExtent2D;
  end;
  PVkDisplaySurfaceCreateInfoKHR = ^TVkDisplaySurfaceCreateInfoKHR;
  PPVkDisplaySurfaceCreateInfoKHR = ^PVkDisplaySurfaceCreateInfoKHR;

{ ===================================== VK_KHR_display_swapchain ===================================== }
  TVkDisplayPresentInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    srcRect:                                          TVkRect2D;
    dstRect:                                          TVkRect2D;
    persistent:                                       VkBool32;
  end;
  PVkDisplayPresentInfoKHR = ^TVkDisplayPresentInfoKHR;
  PPVkDisplayPresentInfoKHR = ^PVkDisplayPresentInfoKHR;

{ ======================================= VK_KHR_xlib_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_XLIB_KHR}
  TVkXlibSurfaceCreateInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkXlibSurfaceCreateFlagsKHR;
    dpy:                                              Display;
    window:                                           Window;
  end;
  PVkXlibSurfaceCreateInfoKHR = ^TVkXlibSurfaceCreateInfoKHR;
  PPVkXlibSurfaceCreateInfoKHR = ^PVkXlibSurfaceCreateInfoKHR;
{$ENDIF}

{ ======================================== VK_KHR_xcb_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_XCB_KHR}
  TVkXcbSurfaceCreateInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkXcbSurfaceCreateFlagsKHR;
    connection:                                       xcb_connection_t;
    window:                                           xcb_window_t;
  end;
  PVkXcbSurfaceCreateInfoKHR = ^TVkXcbSurfaceCreateInfoKHR;
  PPVkXcbSurfaceCreateInfoKHR = ^PVkXcbSurfaceCreateInfoKHR;
{$ENDIF}

{ ====================================== VK_KHR_wayland_surface ====================================== }
{$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}
  TVkWaylandSurfaceCreateInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkWaylandSurfaceCreateFlagsKHR;
    display:                                          wl_display;
    surface:                                          wl_surface;
  end;
  PVkWaylandSurfaceCreateInfoKHR = ^TVkWaylandSurfaceCreateInfoKHR;
  PPVkWaylandSurfaceCreateInfoKHR = ^PVkWaylandSurfaceCreateInfoKHR;
{$ENDIF}

{ ======================================== VK_KHR_mir_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_MIR_KHR}
  TVkMirSurfaceCreateInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkMirSurfaceCreateFlagsKHR;
    connection:                                       MirConnection;
    mirSurface:                                       MirSurface;
  end;
  PVkMirSurfaceCreateInfoKHR = ^TVkMirSurfaceCreateInfoKHR;
  PPVkMirSurfaceCreateInfoKHR = ^PVkMirSurfaceCreateInfoKHR;
{$ENDIF}

{ ====================================== VK_KHR_android_surface ====================================== }
{$IFDEF VK_USE_PLATFORM_ANDROID_KHR}
  TVkAndroidSurfaceCreateInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkAndroidSurfaceCreateFlagsKHR;
    window:                                           ANativeWindow;
  end;
  PVkAndroidSurfaceCreateInfoKHR = ^TVkAndroidSurfaceCreateInfoKHR;
  PPVkAndroidSurfaceCreateInfoKHR = ^PVkAndroidSurfaceCreateInfoKHR;
{$ENDIF}

{ ======================================= VK_KHR_win32_surface ======================================= }
{$IFDEF VK_USE_PLATFORM_WIN32_KHR}
  TVkWin32SurfaceCreateInfoKHR = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkWin32SurfaceCreateFlagsKHR;
    hinstance:                                        HINSTANCE;
    hwnd:                                             HWND;
  end;
  PVkWin32SurfaceCreateInfoKHR = ^TVkWin32SurfaceCreateInfoKHR;
  PPVkWin32SurfaceCreateInfoKHR = ^PVkWin32SurfaceCreateInfoKHR;
{$ENDIF}

{ ======================================= VK_EXT_debug_report ======================================== }
  TVkDebugReportCallbackCreateInfoEXT = record
    sType:                                            TVkStructureType;
    pNext:                                            PVkVoid;
    flags:                                            VkDebugReportFlagsEXT;
    pfnCallback:                                      TvkDebugReportCallbackEXT;
    pUserData:                                        PVkVoid;
  end;
  PVkDebugReportCallbackCreateInfoEXT = ^TVkDebugReportCallbackCreateInfoEXT;
  PPVkDebugReportCallbackCreateInfoEXT = ^PVkDebugReportCallbackCreateInfoEXT;

type { commands }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{ ========================================== VK_KHR_surface ========================================== }
  TvkDestroySurfaceKHR = procedure(
          instance:                     VkInstance; 
          surface:                      VkSurfaceKHR; 
    const pAllocator:                   PVkAllocationCallbacks
  ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetPhysicalDeviceSurfaceSupportKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          queueFamilyIndex:             VkUint32; 
          surface:                      VkSurfaceKHR; 
          pSupported:                   PVkBool32
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetPhysicalDeviceSurfaceCapabilitiesKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          surface:                      VkSurfaceKHR; 
          pSurfaceCapabilities:         PVkSurfaceCapabilitiesKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetPhysicalDeviceSurfaceFormatsKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          surface:                      VkSurfaceKHR; 
          pSurfaceFormatCount:          PVkUint32; 
          pSurfaceFormats:              PVkSurfaceFormatKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetPhysicalDeviceSurfacePresentModesKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          surface:                      VkSurfaceKHR; 
          pPresentModeCount:            PVkUint32; 
          pPresentModes:                PVkPresentModeKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

{ ========================================= VK_KHR_swapchain ========================================= }
  TvkCreateSwapchainKHR = function (
          device:                       VkDevice; 
    const pCreateInfo:                  PVkSwapchainCreateInfoKHR; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pSwapchain:                   PVkSwapchainKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkDestroySwapchainKHR = procedure(
          device:                       VkDevice; 
          swapchain:                    VkSwapchainKHR; 
    const pAllocator:                   PVkAllocationCallbacks
  ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetSwapchainImagesKHR = function (
          device:                       VkDevice; 
          swapchain:                    VkSwapchainKHR; 
          pSwapchainImageCount:         PVkUint32; 
          pSwapchainImages:             PVkImage
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkAcquireNextImageKHR = function (
          device:                       VkDevice; 
          swapchain:                    VkSwapchainKHR; 
          timeout:                      VkUint64; 
          semaphore:                    VkSemaphore; 
          fence:                        VkFence; 
          pImageIndex:                  PVkUint32
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkQueuePresentKHR = function (
          queue:                        VkQueue; 
    const pPresentInfo:                 PVkPresentInfoKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

{ ========================================== VK_KHR_display ========================================== }
  TvkGetPhysicalDeviceDisplayPropertiesKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          pPropertyCount:               PVkUint32; 
          pProperties:                  PVkDisplayPropertiesKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetPhysicalDeviceDisplayPlanePropertiesKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          pPropertyCount:               PVkUint32; 
          pProperties:                  PVkDisplayPlanePropertiesKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetDisplayPlaneSupportedDisplaysKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          planeIndex:                   VkUint32; 
          pDisplayCount:                PVkUint32; 
          pDisplays:                    PVkDisplayKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetDisplayModePropertiesKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          display:                      VkDisplayKHR; 
          pPropertyCount:               PVkUint32; 
          pProperties:                  PVkDisplayModePropertiesKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkCreateDisplayModeKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          display:                      VkDisplayKHR; 
    const pCreateInfo:                  PVkDisplayModeCreateInfoKHR; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pMode:                        PVkDisplayModeKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetDisplayPlaneCapabilitiesKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          mode:                         VkDisplayModeKHR; 
          planeIndex:                   VkUint32; 
          pCapabilities:                PVkDisplayPlaneCapabilitiesKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkCreateDisplayPlaneSurfaceKHR = function (
          instance:                     VkInstance; 
    const pCreateInfo:                  PVkDisplaySurfaceCreateInfoKHR; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pSurface:                     PVkSurfaceKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

{ ===================================== VK_KHR_display_swapchain ===================================== }
  TvkCreateSharedSwapchainsKHR = function (
          device:                       VkDevice; 
          swapchainCount:               VkUint32; 
    const pCreateInfos:                 PVkSwapchainCreateInfoKHR; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pSwapchains:                  PVkSwapchainKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

{ ======================================= VK_KHR_xlib_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_XLIB_KHR}
  TvkCreateXlibSurfaceKHR = function (
          instance:                     VkInstance; 
    const pCreateInfo:                  PVkXlibSurfaceCreateInfoKHR; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pSurface:                     PVkSurfaceKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetPhysicalDeviceXlibPresentationSupportKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          queueFamilyIndex:             VkUint32; 
          dpy:                          Display; 
          visualID:                     VisualID
  ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};
{$ENDIF}

{ ======================================== VK_KHR_xcb_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_XCB_KHR}
  TvkCreateXcbSurfaceKHR = function (
          instance:                     VkInstance; 
    const pCreateInfo:                  PVkXcbSurfaceCreateInfoKHR; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pSurface:                     PVkSurfaceKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetPhysicalDeviceXcbPresentationSupportKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          queueFamilyIndex:             VkUint32; 
          connection:                   xcb_connection_t; 
          visual_id:                    xcb_visualid_t
  ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};
{$ENDIF}

{ ====================================== VK_KHR_wayland_surface ====================================== }
{$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}
  TvkCreateWaylandSurfaceKHR = function (
          instance:                     VkInstance; 
    const pCreateInfo:                  PVkWaylandSurfaceCreateInfoKHR; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pSurface:                     PVkSurfaceKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetPhysicalDeviceWaylandPresentationSupportKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          queueFamilyIndex:             VkUint32; 
          display:                      wl_display
  ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};
{$ENDIF}

{ ======================================== VK_KHR_mir_surface ======================================== }
{$IFDEF VK_USE_PLATFORM_MIR_KHR}
  TvkCreateMirSurfaceKHR = function (
          instance:                     VkInstance; 
    const pCreateInfo:                  PVkMirSurfaceCreateInfoKHR; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pSurface:                     PVkSurfaceKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetPhysicalDeviceMirPresentationSupportKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          queueFamilyIndex:             VkUint32; 
          connection:                   MirConnection
  ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};
{$ENDIF}

{ ====================================== VK_KHR_android_surface ====================================== }
{$IFDEF VK_USE_PLATFORM_ANDROID_KHR}
  TvkCreateAndroidSurfaceKHR = function (
          instance:                     VkInstance; 
    const pCreateInfo:                  PVkAndroidSurfaceCreateInfoKHR; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pSurface:                     PVkSurfaceKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};
{$ENDIF}

{ ======================================= VK_KHR_win32_surface ======================================= }
{$IFDEF VK_USE_PLATFORM_WIN32_KHR}
  TvkCreateWin32SurfaceKHR = function (
          instance:                     VkInstance; 
    const pCreateInfo:                  PVkWin32SurfaceCreateInfoKHR; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pSurface:                     PVkSurfaceKHR
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkGetPhysicalDeviceWin32PresentationSupportKHR = function (
          physicalDevice:               VkPhysicalDevice; 
          queueFamilyIndex:             VkUint32
  ): VkBool32; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};
{$ENDIF}

{ ======================================= VK_EXT_debug_report ======================================== }
  TvkCreateDebugReportCallbackEXT = function (
          instance:                     VkInstance; 
    const pCreateInfo:                  PVkDebugReportCallbackCreateInfoEXT; 
    const pAllocator:                   PVkAllocationCallbacks; 
          pCallback:                    PVkDebugReportCallbackEXT
  ): TVkResult; {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkDestroyDebugReportCallbackEXT = procedure(
          instance:                     VkInstance; 
          callback:                     VkDebugReportCallbackEXT; 
    const pAllocator:                   PVkAllocationCallbacks
  ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

  TvkDebugReportMessageEXT = procedure(
          instance:                     VkInstance; 
          flags:                        VkDebugReportFlagsEXT; 
          objectType:                   TVkDebugReportObjectTypeEXT; 
          uObject:                      VkUint64; 
          location:                     VkSize; 
          messageCode:                  VkInt32; 
    const pLayerPrefix:                 PVkChar; 
    const pMessage:                     PVkChar
  ); {$IFDEF VK_CDECL}cdecl{$ELSE}stdcall{$ENDIF};

var

{ ========================================== VK_VERSION_1_0 ========================================== }
  vkCreateInstance:                                 TvkCreateInstance;
  vkGetInstanceProcAddr:                            TvkGetInstanceProcAddr;
  vkEnumerateInstanceExtensionProperties:           TvkEnumerateInstanceExtensionProperties;
  vkEnumerateInstanceLayerProperties:               TvkEnumerateInstanceLayerProperties;

const { predefined flags / sets }
  VK_SHADER_STAGE_ALL_GRAPHICS: TVkShaderStageFlagBits = [
    VK_SHADER_STAGE_VERTEX_BIT,
    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
    VK_SHADER_STAGE_GEOMETRY_BIT,
    VK_SHADER_STAGE_FRAGMENT_BIT
  ];
  VK_SHADER_STAGE_ALL: TVkShaderStageFlagBits = [
    VK_SHADER_STAGE_VERTEX_BIT,
    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
    VK_SHADER_STAGE_GEOMETRY_BIT,
    VK_SHADER_STAGE_FRAGMENT_BIT,
    VK_SHADER_STAGE_COMPUTE_BIT
  ];
  VK_CULL_MODE_NONE: TVkCullModeFlagBits = [  ];
  VK_CULL_MODE_FRONT_AND_BACK: TVkCullModeFlagBits = [
    VK_CULL_MODE_FRONT_BIT,
    VK_CULL_MODE_BACK_BIT
  ];
  VK_STENCIL_FRONT_AND_BACK: TVkStencilFaceFlagBits = [
    VK_STENCIL_FACE_FRONT_BIT,
    VK_STENCIL_FACE_BACK_BIT
  ];

type
  TVkInstanceCommands = class
    Instance: VkInstance;
    
    { ========================================== VK_VERSION_1_0 ========================================== }
    vkDestroyInstance:                                TvkDestroyInstance;
    vkEnumeratePhysicalDevices:                       TvkEnumeratePhysicalDevices;
    vkGetPhysicalDeviceFeatures:                      TvkGetPhysicalDeviceFeatures;
    vkGetPhysicalDeviceFormatProperties:              TvkGetPhysicalDeviceFormatProperties;
    vkGetPhysicalDeviceImageFormatProperties:         TvkGetPhysicalDeviceImageFormatProperties;
    vkGetPhysicalDeviceProperties:                    TvkGetPhysicalDeviceProperties;
    vkGetPhysicalDeviceQueueFamilyProperties:         TvkGetPhysicalDeviceQueueFamilyProperties;
    vkGetPhysicalDeviceMemoryProperties:              TvkGetPhysicalDeviceMemoryProperties;
    vkGetDeviceProcAddr:                              TvkGetDeviceProcAddr;
    vkCreateDevice:                                   TvkCreateDevice;
    vkEnumerateDeviceExtensionProperties:             TvkEnumerateDeviceExtensionProperties;
    vkEnumerateDeviceLayerProperties:                 TvkEnumerateDeviceLayerProperties;
    vkGetPhysicalDeviceSparseImageFormatProperties:   TvkGetPhysicalDeviceSparseImageFormatProperties;
    
    { ========================================== VK_KHR_surface ========================================== }
    vkDestroySurfaceKHR:                              TvkDestroySurfaceKHR;
    vkGetPhysicalDeviceSurfaceSupportKHR:             TvkGetPhysicalDeviceSurfaceSupportKHR;
    vkGetPhysicalDeviceSurfaceCapabilitiesKHR:        TvkGetPhysicalDeviceSurfaceCapabilitiesKHR;
    vkGetPhysicalDeviceSurfaceFormatsKHR:             TvkGetPhysicalDeviceSurfaceFormatsKHR;
    vkGetPhysicalDeviceSurfacePresentModesKHR:        TvkGetPhysicalDeviceSurfacePresentModesKHR;
    
    { ========================================== VK_KHR_display ========================================== }
    vkGetPhysicalDeviceDisplayPropertiesKHR:          TvkGetPhysicalDeviceDisplayPropertiesKHR;
    vkGetPhysicalDeviceDisplayPlanePropertiesKHR:     TvkGetPhysicalDeviceDisplayPlanePropertiesKHR;
    vkGetDisplayPlaneSupportedDisplaysKHR:            TvkGetDisplayPlaneSupportedDisplaysKHR;
    vkGetDisplayModePropertiesKHR:                    TvkGetDisplayModePropertiesKHR;
    vkCreateDisplayModeKHR:                           TvkCreateDisplayModeKHR;
    vkGetDisplayPlaneCapabilitiesKHR:                 TvkGetDisplayPlaneCapabilitiesKHR;
    vkCreateDisplayPlaneSurfaceKHR:                   TvkCreateDisplayPlaneSurfaceKHR;
    
    { ======================================= VK_KHR_xlib_surface ======================================== }
    {$IFDEF VK_USE_PLATFORM_XLIB_KHR}
    vkCreateXlibSurfaceKHR:                           TvkCreateXlibSurfaceKHR;
    vkGetPhysicalDeviceXlibPresentationSupportKHR:    TvkGetPhysicalDeviceXlibPresentationSupportKHR;
    {$ENDIF}
    
    { ======================================== VK_KHR_xcb_surface ======================================== }
    {$IFDEF VK_USE_PLATFORM_XCB_KHR}
    vkCreateXcbSurfaceKHR:                            TvkCreateXcbSurfaceKHR;
    vkGetPhysicalDeviceXcbPresentationSupportKHR:     TvkGetPhysicalDeviceXcbPresentationSupportKHR;
    {$ENDIF}
    
    { ====================================== VK_KHR_wayland_surface ====================================== }
    {$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}
    vkCreateWaylandSurfaceKHR:                        TvkCreateWaylandSurfaceKHR;
    vkGetPhysicalDeviceWaylandPresentationSupportKHR: TvkGetPhysicalDeviceWaylandPresentationSupportKHR;
    {$ENDIF}
    
    { ======================================== VK_KHR_mir_surface ======================================== }
    {$IFDEF VK_USE_PLATFORM_MIR_KHR}
    vkCreateMirSurfaceKHR:                            TvkCreateMirSurfaceKHR;
    vkGetPhysicalDeviceMirPresentationSupportKHR:     TvkGetPhysicalDeviceMirPresentationSupportKHR;
    {$ENDIF}
    
    { ====================================== VK_KHR_android_surface ====================================== }
    {$IFDEF VK_USE_PLATFORM_ANDROID_KHR}
    vkCreateAndroidSurfaceKHR:                        TvkCreateAndroidSurfaceKHR;
    {$ENDIF}
    
    { ======================================= VK_KHR_win32_surface ======================================= }
    {$IFDEF VK_USE_PLATFORM_WIN32_KHR}
    vkCreateWin32SurfaceKHR:                          TvkCreateWin32SurfaceKHR;
    vkGetPhysicalDeviceWin32PresentationSupportKHR:   TvkGetPhysicalDeviceWin32PresentationSupportKHR;
    {$ENDIF}
    
    { ======================================= VK_EXT_debug_report ======================================== }
    vkCreateDebugReportCallbackEXT:                   TvkCreateDebugReportCallbackEXT;
    vkDestroyDebugReportCallbackEXT:                  TvkDestroyDebugReportCallbackEXT;
    vkDebugReportMessageEXT:                          TvkDebugReportMessageEXT;

  end;

  TVkDeviceCommands = class
    Device: VkDevice;
    
    { ========================================== VK_VERSION_1_0 ========================================== }
    vkDestroyDevice:                                  TvkDestroyDevice;
    vkGetDeviceQueue:                                 TvkGetDeviceQueue;
    vkQueueSubmit:                                    TvkQueueSubmit;
    vkQueueWaitIdle:                                  TvkQueueWaitIdle;
    vkDeviceWaitIdle:                                 TvkDeviceWaitIdle;
    vkAllocateMemory:                                 TvkAllocateMemory;
    vkFreeMemory:                                     TvkFreeMemory;
    vkMapMemory:                                      TvkMapMemory;
    vkUnmapMemory:                                    TvkUnmapMemory;
    vkFlushMappedMemoryRanges:                        TvkFlushMappedMemoryRanges;
    vkInvalidateMappedMemoryRanges:                   TvkInvalidateMappedMemoryRanges;
    vkGetDeviceMemoryCommitment:                      TvkGetDeviceMemoryCommitment;
    vkBindBufferMemory:                               TvkBindBufferMemory;
    vkBindImageMemory:                                TvkBindImageMemory;
    vkGetBufferMemoryRequirements:                    TvkGetBufferMemoryRequirements;
    vkGetImageMemoryRequirements:                     TvkGetImageMemoryRequirements;
    vkGetImageSparseMemoryRequirements:               TvkGetImageSparseMemoryRequirements;
    vkQueueBindSparse:                                TvkQueueBindSparse;
    vkCreateFence:                                    TvkCreateFence;
    vkDestroyFence:                                   TvkDestroyFence;
    vkResetFences:                                    TvkResetFences;
    vkGetFenceStatus:                                 TvkGetFenceStatus;
    vkWaitForFences:                                  TvkWaitForFences;
    vkCreateSemaphore:                                TvkCreateSemaphore;
    vkDestroySemaphore:                               TvkDestroySemaphore;
    vkCreateEvent:                                    TvkCreateEvent;
    vkDestroyEvent:                                   TvkDestroyEvent;
    vkGetEventStatus:                                 TvkGetEventStatus;
    vkSetEvent:                                       TvkSetEvent;
    vkResetEvent:                                     TvkResetEvent;
    vkCreateQueryPool:                                TvkCreateQueryPool;
    vkDestroyQueryPool:                               TvkDestroyQueryPool;
    vkGetQueryPoolResults:                            TvkGetQueryPoolResults;
    vkCreateBuffer:                                   TvkCreateBuffer;
    vkDestroyBuffer:                                  TvkDestroyBuffer;
    vkCreateBufferView:                               TvkCreateBufferView;
    vkDestroyBufferView:                              TvkDestroyBufferView;
    vkCreateImage:                                    TvkCreateImage;
    vkDestroyImage:                                   TvkDestroyImage;
    vkGetImageSubresourceLayout:                      TvkGetImageSubresourceLayout;
    vkCreateImageView:                                TvkCreateImageView;
    vkDestroyImageView:                               TvkDestroyImageView;
    vkCreateShaderModule:                             TvkCreateShaderModule;
    vkDestroyShaderModule:                            TvkDestroyShaderModule;
    vkCreatePipelineCache:                            TvkCreatePipelineCache;
    vkDestroyPipelineCache:                           TvkDestroyPipelineCache;
    vkGetPipelineCacheData:                           TvkGetPipelineCacheData;
    vkMergePipelineCaches:                            TvkMergePipelineCaches;
    vkCreateGraphicsPipelines:                        TvkCreateGraphicsPipelines;
    vkCreateComputePipelines:                         TvkCreateComputePipelines;
    vkDestroyPipeline:                                TvkDestroyPipeline;
    vkCreatePipelineLayout:                           TvkCreatePipelineLayout;
    vkDestroyPipelineLayout:                          TvkDestroyPipelineLayout;
    vkCreateSampler:                                  TvkCreateSampler;
    vkDestroySampler:                                 TvkDestroySampler;
    vkCreateDescriptorSetLayout:                      TvkCreateDescriptorSetLayout;
    vkDestroyDescriptorSetLayout:                     TvkDestroyDescriptorSetLayout;
    vkCreateDescriptorPool:                           TvkCreateDescriptorPool;
    vkDestroyDescriptorPool:                          TvkDestroyDescriptorPool;
    vkResetDescriptorPool:                            TvkResetDescriptorPool;
    vkAllocateDescriptorSets:                         TvkAllocateDescriptorSets;
    vkFreeDescriptorSets:                             TvkFreeDescriptorSets;
    vkUpdateDescriptorSets:                           TvkUpdateDescriptorSets;
    vkCreateFramebuffer:                              TvkCreateFramebuffer;
    vkDestroyFramebuffer:                             TvkDestroyFramebuffer;
    vkCreateRenderPass:                               TvkCreateRenderPass;
    vkDestroyRenderPass:                              TvkDestroyRenderPass;
    vkGetRenderAreaGranularity:                       TvkGetRenderAreaGranularity;
    vkCreateCommandPool:                              TvkCreateCommandPool;
    vkDestroyCommandPool:                             TvkDestroyCommandPool;
    vkResetCommandPool:                               TvkResetCommandPool;
    vkAllocateCommandBuffers:                         TvkAllocateCommandBuffers;
    vkFreeCommandBuffers:                             TvkFreeCommandBuffers;
    vkBeginCommandBuffer:                             TvkBeginCommandBuffer;
    vkEndCommandBuffer:                               TvkEndCommandBuffer;
    vkResetCommandBuffer:                             TvkResetCommandBuffer;
    vkCmdBindPipeline:                                TvkCmdBindPipeline;
    vkCmdSetViewport:                                 TvkCmdSetViewport;
    vkCmdSetScissor:                                  TvkCmdSetScissor;
    vkCmdSetLineWidth:                                TvkCmdSetLineWidth;
    vkCmdSetDepthBias:                                TvkCmdSetDepthBias;
    vkCmdSetBlendConstants:                           TvkCmdSetBlendConstants;
    vkCmdSetDepthBounds:                              TvkCmdSetDepthBounds;
    vkCmdSetStencilCompareMask:                       TvkCmdSetStencilCompareMask;
    vkCmdSetStencilWriteMask:                         TvkCmdSetStencilWriteMask;
    vkCmdSetStencilReference:                         TvkCmdSetStencilReference;
    vkCmdBindDescriptorSets:                          TvkCmdBindDescriptorSets;
    vkCmdBindIndexBuffer:                             TvkCmdBindIndexBuffer;
    vkCmdBindVertexBuffers:                           TvkCmdBindVertexBuffers;
    vkCmdDraw:                                        TvkCmdDraw;
    vkCmdDrawIndexed:                                 TvkCmdDrawIndexed;
    vkCmdDrawIndirect:                                TvkCmdDrawIndirect;
    vkCmdDrawIndexedIndirect:                         TvkCmdDrawIndexedIndirect;
    vkCmdDispatch:                                    TvkCmdDispatch;
    vkCmdDispatchIndirect:                            TvkCmdDispatchIndirect;
    vkCmdCopyBuffer:                                  TvkCmdCopyBuffer;
    vkCmdCopyImage:                                   TvkCmdCopyImage;
    vkCmdBlitImage:                                   TvkCmdBlitImage;
    vkCmdCopyBufferToImage:                           TvkCmdCopyBufferToImage;
    vkCmdCopyImageToBuffer:                           TvkCmdCopyImageToBuffer;
    vkCmdUpdateBuffer:                                TvkCmdUpdateBuffer;
    vkCmdFillBuffer:                                  TvkCmdFillBuffer;
    vkCmdClearColorImage:                             TvkCmdClearColorImage;
    vkCmdClearDepthStencilImage:                      TvkCmdClearDepthStencilImage;
    vkCmdClearAttachments:                            TvkCmdClearAttachments;
    vkCmdResolveImage:                                TvkCmdResolveImage;
    vkCmdSetEvent:                                    TvkCmdSetEvent;
    vkCmdResetEvent:                                  TvkCmdResetEvent;
    vkCmdWaitEvents:                                  TvkCmdWaitEvents;
    vkCmdPipelineBarrier:                             TvkCmdPipelineBarrier;
    vkCmdBeginQuery:                                  TvkCmdBeginQuery;
    vkCmdEndQuery:                                    TvkCmdEndQuery;
    vkCmdResetQueryPool:                              TvkCmdResetQueryPool;
    vkCmdWriteTimestamp:                              TvkCmdWriteTimestamp;
    vkCmdCopyQueryPoolResults:                        TvkCmdCopyQueryPoolResults;
    vkCmdPushConstants:                               TvkCmdPushConstants;
    vkCmdBeginRenderPass:                             TvkCmdBeginRenderPass;
    vkCmdNextSubpass:                                 TvkCmdNextSubpass;
    vkCmdEndRenderPass:                               TvkCmdEndRenderPass;
    vkCmdExecuteCommands:                             TvkCmdExecuteCommands;
    
    { ========================================= VK_KHR_swapchain ========================================= }
    vkCreateSwapchainKHR:                             TvkCreateSwapchainKHR;
    vkDestroySwapchainKHR:                            TvkDestroySwapchainKHR;
    vkGetSwapchainImagesKHR:                          TvkGetSwapchainImagesKHR;
    vkAcquireNextImageKHR:                            TvkAcquireNextImageKHR;
    vkQueuePresentKHR:                                TvkQueuePresentKHR;
    
    { ===================================== VK_KHR_display_swapchain ===================================== }
    vkCreateSharedSwapchainsKHR:                      TvkCreateSharedSwapchainsKHR;

  end;

const
  VULKAN_LIBNAME = 'vulkan-1.dll';

type
  VkVersion = VkInt32;

function vkMakeVersion(const aMajor, aMinor, aPatch: Integer): VkVersion; inline;
function vkGetVersionMajor(const aVersion: VkVersion): Integer; inline;
function vkGetVersionMinor(const aVersion: VkVersion): Integer; inline;
function vkGetVersionPatch(const aVersion: VkVersion): Integer; inline;

function  InitializeVulkan(const aLibName: String = VULKAN_LIBNAME): Boolean;
function  LoadInstanceCommands(const aInstance: VkInstance): TVkInstanceCommands;
function  LoadDeviceCommands(const aInstance: VkInstance; const aDevice: VkDevice): TVkDeviceCommands;
procedure FinalizeVulkan;

implementation

uses
  SysUtils;

type
{$IF DEFINED(VK_WIN)}
  TvkLibHandle = TLibHandle;
{$ELSE}
  TvkLibHandle = Pointer;
{$ENDIF}

const
{$IF DEFINED(VK_WIN)}
  InvalidLibHandle = 0;
{$ELSE}
  InvalidLibHandle = nil;
{$ENDIF}

var
  vkLibHandle: TvkLibHandle = InvalidLibHandle;

{ ===================================== Library Handling ============================================= }
function vkLoadLibrary(const aLibName: String): TvkLibHandle;
begin
  {$IF DEFINED(VK_WIN)}
  result := LoadLibrary(aLibName);
  {$ELSE}
  result := InvalidLibHandle;
  {$ENDIF}
end;

function vkGetProcAddress(const aProcName: String; aLibHandle: TvkLibHandle = InvalidLibHandle): TvkVoidFunction;
begin
  result := nil;
  if (aLibHandle = InvalidLibHandle) then
    aLibHandle := vkLibHandle;
  {$IF DEFINED(VK_WIN)}
  result := TvkVoidFunction(GetProcAddress(aLibHandle, AnsiString(aProcName)));
  {$ELSE}
  result := nil;
  {$ENDIF}
end;

procedure vkFreeLibrary(var aLibHandle: TvkLibHandle);
begin
  if (aLibHandle <> InvalidLibHandle) then begin
    {$IF DEFINED(VK_WIN)}
    FreeLibrary(aLibHandle);
    {$ENDIF}
    aLibHandle := InvalidLibHandle;
  end;
end;

{ ===================================== Vulkan Version Helpers ======================================= }
function vkMakeVersion(const aMajor, aMinor, aPatch: Integer): VkVersion;
begin
  result := (aMajor shl 22) or (aMinor shl 12) or aPatch;
end;

function vkGetVersionMajor(const aVersion: VkVersion): Integer;
begin
  result := (aVersion shr 22);
end;

function vkGetVersionMinor(const aVersion: VkVersion): Integer;
begin
  result := (aVersion shr 12) and $3FF;
end;

function vkGetVersionPatch(const aVersion: VkVersion): Integer;
begin
  result := (aVersion and $FFF);
end;

{ ===================================== Initialize Routines ========================================== }
function InitializeVulkan(const aLibName: String = VULKAN_LIBNAME): Boolean;
var success: Boolean;

  function GetProcAddress(const aName: String): TvkVoidFunction;
  begin
    result := vkGetProcAddress(aName);
    if not Assigned(result) then
      success := false;
  end;

begin
  FinalizeVulkan;
  vkLibHandle := vkLoadLibrary(aLibName);
  success := (vkLibHandle <> InvalidLibHandle);
  if not success then
    exit;
  
  vkCreateInstance                                   := TvkCreateInstance                                  (GetProcAddress('vkCreateInstance'));
  vkGetInstanceProcAddr                              := TvkGetInstanceProcAddr                             (GetProcAddress('vkGetInstanceProcAddr'));
  vkEnumerateInstanceExtensionProperties             := TvkEnumerateInstanceExtensionProperties            (GetProcAddress('vkEnumerateInstanceExtensionProperties'));
  vkEnumerateInstanceLayerProperties                 := TvkEnumerateInstanceLayerProperties                (GetProcAddress('vkEnumerateInstanceLayerProperties'));

  result := success;
end;

function LoadInstanceCommands(const aInstance: VkInstance): TVkInstanceCommands;

  function GetProcAddress(const aName: String): TvkVoidFunction;
  begin
    result := vkGetInstanceProcAddr(aInstance, PVkChar(aName));
  end;

begin
  result  := TVkInstanceCommands.Create;
  try
    result.Instance := aInstance;
    with result do begin
      
      { ========================================== VK_VERSION_1_0 ========================================== }
      vkDestroyInstance                                  := TvkDestroyInstance                                 (GetProcAddress('vkDestroyInstance'));
      vkEnumeratePhysicalDevices                         := TvkEnumeratePhysicalDevices                        (GetProcAddress('vkEnumeratePhysicalDevices'));
      vkGetPhysicalDeviceFeatures                        := TvkGetPhysicalDeviceFeatures                       (GetProcAddress('vkGetPhysicalDeviceFeatures'));
      vkGetPhysicalDeviceFormatProperties                := TvkGetPhysicalDeviceFormatProperties               (GetProcAddress('vkGetPhysicalDeviceFormatProperties'));
      vkGetPhysicalDeviceImageFormatProperties           := TvkGetPhysicalDeviceImageFormatProperties          (GetProcAddress('vkGetPhysicalDeviceImageFormatProperties'));
      vkGetPhysicalDeviceProperties                      := TvkGetPhysicalDeviceProperties                     (GetProcAddress('vkGetPhysicalDeviceProperties'));
      vkGetPhysicalDeviceQueueFamilyProperties           := TvkGetPhysicalDeviceQueueFamilyProperties          (GetProcAddress('vkGetPhysicalDeviceQueueFamilyProperties'));
      vkGetPhysicalDeviceMemoryProperties                := TvkGetPhysicalDeviceMemoryProperties               (GetProcAddress('vkGetPhysicalDeviceMemoryProperties'));
      vkGetDeviceProcAddr                                := TvkGetDeviceProcAddr                               (GetProcAddress('vkGetDeviceProcAddr'));
      vkCreateDevice                                     := TvkCreateDevice                                    (GetProcAddress('vkCreateDevice'));
      vkEnumerateDeviceExtensionProperties               := TvkEnumerateDeviceExtensionProperties              (GetProcAddress('vkEnumerateDeviceExtensionProperties'));
      vkEnumerateDeviceLayerProperties                   := TvkEnumerateDeviceLayerProperties                  (GetProcAddress('vkEnumerateDeviceLayerProperties'));
      vkGetPhysicalDeviceSparseImageFormatProperties     := TvkGetPhysicalDeviceSparseImageFormatProperties    (GetProcAddress('vkGetPhysicalDeviceSparseImageFormatProperties'));
      
      { ========================================== VK_KHR_surface ========================================== }
      vkDestroySurfaceKHR                                := TvkDestroySurfaceKHR                               (GetProcAddress('vkDestroySurfaceKHR'));
      vkGetPhysicalDeviceSurfaceSupportKHR               := TvkGetPhysicalDeviceSurfaceSupportKHR              (GetProcAddress('vkGetPhysicalDeviceSurfaceSupportKHR'));
      vkGetPhysicalDeviceSurfaceCapabilitiesKHR          := TvkGetPhysicalDeviceSurfaceCapabilitiesKHR         (GetProcAddress('vkGetPhysicalDeviceSurfaceCapabilitiesKHR'));
      vkGetPhysicalDeviceSurfaceFormatsKHR               := TvkGetPhysicalDeviceSurfaceFormatsKHR              (GetProcAddress('vkGetPhysicalDeviceSurfaceFormatsKHR'));
      vkGetPhysicalDeviceSurfacePresentModesKHR          := TvkGetPhysicalDeviceSurfacePresentModesKHR         (GetProcAddress('vkGetPhysicalDeviceSurfacePresentModesKHR'));
      
      { ========================================== VK_KHR_display ========================================== }
      vkGetPhysicalDeviceDisplayPropertiesKHR            := TvkGetPhysicalDeviceDisplayPropertiesKHR           (GetProcAddress('vkGetPhysicalDeviceDisplayPropertiesKHR'));
      vkGetPhysicalDeviceDisplayPlanePropertiesKHR       := TvkGetPhysicalDeviceDisplayPlanePropertiesKHR      (GetProcAddress('vkGetPhysicalDeviceDisplayPlanePropertiesKHR'));
      vkGetDisplayPlaneSupportedDisplaysKHR              := TvkGetDisplayPlaneSupportedDisplaysKHR             (GetProcAddress('vkGetDisplayPlaneSupportedDisplaysKHR'));
      vkGetDisplayModePropertiesKHR                      := TvkGetDisplayModePropertiesKHR                     (GetProcAddress('vkGetDisplayModePropertiesKHR'));
      vkCreateDisplayModeKHR                             := TvkCreateDisplayModeKHR                            (GetProcAddress('vkCreateDisplayModeKHR'));
      vkGetDisplayPlaneCapabilitiesKHR                   := TvkGetDisplayPlaneCapabilitiesKHR                  (GetProcAddress('vkGetDisplayPlaneCapabilitiesKHR'));
      vkCreateDisplayPlaneSurfaceKHR                     := TvkCreateDisplayPlaneSurfaceKHR                    (GetProcAddress('vkCreateDisplayPlaneSurfaceKHR'));
      
      { ======================================= VK_KHR_xlib_surface ======================================== }
      {$IFDEF VK_USE_PLATFORM_XLIB_KHR}
      vkCreateXlibSurfaceKHR                             := TvkCreateXlibSurfaceKHR                            (GetProcAddress('vkCreateXlibSurfaceKHR'));
      vkGetPhysicalDeviceXlibPresentationSupportKHR      := TvkGetPhysicalDeviceXlibPresentationSupportKHR     (GetProcAddress('vkGetPhysicalDeviceXlibPresentationSupportKHR'));
      {$ENDIF}
      
      { ======================================== VK_KHR_xcb_surface ======================================== }
      {$IFDEF VK_USE_PLATFORM_XCB_KHR}
      vkCreateXcbSurfaceKHR                              := TvkCreateXcbSurfaceKHR                             (GetProcAddress('vkCreateXcbSurfaceKHR'));
      vkGetPhysicalDeviceXcbPresentationSupportKHR       := TvkGetPhysicalDeviceXcbPresentationSupportKHR      (GetProcAddress('vkGetPhysicalDeviceXcbPresentationSupportKHR'));
      {$ENDIF}
      
      { ====================================== VK_KHR_wayland_surface ====================================== }
      {$IFDEF VK_USE_PLATFORM_WAYLAND_KHR}
      vkCreateWaylandSurfaceKHR                          := TvkCreateWaylandSurfaceKHR                         (GetProcAddress('vkCreateWaylandSurfaceKHR'));
      vkGetPhysicalDeviceWaylandPresentationSupportKHR   := TvkGetPhysicalDeviceWaylandPresentationSupportKHR  (GetProcAddress('vkGetPhysicalDeviceWaylandPresentationSupportKHR'));
      {$ENDIF}
      
      { ======================================== VK_KHR_mir_surface ======================================== }
      {$IFDEF VK_USE_PLATFORM_MIR_KHR}
      vkCreateMirSurfaceKHR                              := TvkCreateMirSurfaceKHR                             (GetProcAddress('vkCreateMirSurfaceKHR'));
      vkGetPhysicalDeviceMirPresentationSupportKHR       := TvkGetPhysicalDeviceMirPresentationSupportKHR      (GetProcAddress('vkGetPhysicalDeviceMirPresentationSupportKHR'));
      {$ENDIF}
      
      { ====================================== VK_KHR_android_surface ====================================== }
      {$IFDEF VK_USE_PLATFORM_ANDROID_KHR}
      vkCreateAndroidSurfaceKHR                          := TvkCreateAndroidSurfaceKHR                         (GetProcAddress('vkCreateAndroidSurfaceKHR'));
      {$ENDIF}
      
      { ======================================= VK_KHR_win32_surface ======================================= }
      {$IFDEF VK_USE_PLATFORM_WIN32_KHR}
      vkCreateWin32SurfaceKHR                            := TvkCreateWin32SurfaceKHR                           (GetProcAddress('vkCreateWin32SurfaceKHR'));
      vkGetPhysicalDeviceWin32PresentationSupportKHR     := TvkGetPhysicalDeviceWin32PresentationSupportKHR    (GetProcAddress('vkGetPhysicalDeviceWin32PresentationSupportKHR'));
      {$ENDIF}
      
      { ======================================= VK_EXT_debug_report ======================================== }
      vkCreateDebugReportCallbackEXT                     := TvkCreateDebugReportCallbackEXT                    (GetProcAddress('vkCreateDebugReportCallbackEXT'));
      vkDestroyDebugReportCallbackEXT                    := TvkDestroyDebugReportCallbackEXT                   (GetProcAddress('vkDestroyDebugReportCallbackEXT'));
      vkDebugReportMessageEXT                            := TvkDebugReportMessageEXT                           (GetProcAddress('vkDebugReportMessageEXT'));

    end;
  except
    FreeAndNil(result);
    raise;
  end;
end;

function LoadDeviceCommands(const aInstance: VkInstance; const aDevice: VkDevice): TVkDeviceCommands;
var
  vkGetDeviceProcAddr: TvkGetDeviceProcAddr;

  function GetProcAddress(const aName: String): TvkVoidFunction;
  begin
    result := vkGetDeviceProcAddr(aDevice, PVkChar(aName));
  end;

begin
  vkGetDeviceProcAddr := TvkGetDeviceProcAddr(vkGetInstanceProcAddr(aInstance, 'vkGetDeviceProcAddr'));
  result := TVkDeviceCommands.Create;
  try
    result.Device := aDevice;
    with result do begin
      
      { ========================================== VK_VERSION_1_0 ========================================== }
      vkDestroyDevice                                    := TvkDestroyDevice                                   (GetProcAddress('vkDestroyDevice'));
      vkGetDeviceQueue                                   := TvkGetDeviceQueue                                  (GetProcAddress('vkGetDeviceQueue'));
      vkQueueSubmit                                      := TvkQueueSubmit                                     (GetProcAddress('vkQueueSubmit'));
      vkQueueWaitIdle                                    := TvkQueueWaitIdle                                   (GetProcAddress('vkQueueWaitIdle'));
      vkDeviceWaitIdle                                   := TvkDeviceWaitIdle                                  (GetProcAddress('vkDeviceWaitIdle'));
      vkAllocateMemory                                   := TvkAllocateMemory                                  (GetProcAddress('vkAllocateMemory'));
      vkFreeMemory                                       := TvkFreeMemory                                      (GetProcAddress('vkFreeMemory'));
      vkMapMemory                                        := TvkMapMemory                                       (GetProcAddress('vkMapMemory'));
      vkUnmapMemory                                      := TvkUnmapMemory                                     (GetProcAddress('vkUnmapMemory'));
      vkFlushMappedMemoryRanges                          := TvkFlushMappedMemoryRanges                         (GetProcAddress('vkFlushMappedMemoryRanges'));
      vkInvalidateMappedMemoryRanges                     := TvkInvalidateMappedMemoryRanges                    (GetProcAddress('vkInvalidateMappedMemoryRanges'));
      vkGetDeviceMemoryCommitment                        := TvkGetDeviceMemoryCommitment                       (GetProcAddress('vkGetDeviceMemoryCommitment'));
      vkBindBufferMemory                                 := TvkBindBufferMemory                                (GetProcAddress('vkBindBufferMemory'));
      vkBindImageMemory                                  := TvkBindImageMemory                                 (GetProcAddress('vkBindImageMemory'));
      vkGetBufferMemoryRequirements                      := TvkGetBufferMemoryRequirements                     (GetProcAddress('vkGetBufferMemoryRequirements'));
      vkGetImageMemoryRequirements                       := TvkGetImageMemoryRequirements                      (GetProcAddress('vkGetImageMemoryRequirements'));
      vkGetImageSparseMemoryRequirements                 := TvkGetImageSparseMemoryRequirements                (GetProcAddress('vkGetImageSparseMemoryRequirements'));
      vkQueueBindSparse                                  := TvkQueueBindSparse                                 (GetProcAddress('vkQueueBindSparse'));
      vkCreateFence                                      := TvkCreateFence                                     (GetProcAddress('vkCreateFence'));
      vkDestroyFence                                     := TvkDestroyFence                                    (GetProcAddress('vkDestroyFence'));
      vkResetFences                                      := TvkResetFences                                     (GetProcAddress('vkResetFences'));
      vkGetFenceStatus                                   := TvkGetFenceStatus                                  (GetProcAddress('vkGetFenceStatus'));
      vkWaitForFences                                    := TvkWaitForFences                                   (GetProcAddress('vkWaitForFences'));
      vkCreateSemaphore                                  := TvkCreateSemaphore                                 (GetProcAddress('vkCreateSemaphore'));
      vkDestroySemaphore                                 := TvkDestroySemaphore                                (GetProcAddress('vkDestroySemaphore'));
      vkCreateEvent                                      := TvkCreateEvent                                     (GetProcAddress('vkCreateEvent'));
      vkDestroyEvent                                     := TvkDestroyEvent                                    (GetProcAddress('vkDestroyEvent'));
      vkGetEventStatus                                   := TvkGetEventStatus                                  (GetProcAddress('vkGetEventStatus'));
      vkSetEvent                                         := TvkSetEvent                                        (GetProcAddress('vkSetEvent'));
      vkResetEvent                                       := TvkResetEvent                                      (GetProcAddress('vkResetEvent'));
      vkCreateQueryPool                                  := TvkCreateQueryPool                                 (GetProcAddress('vkCreateQueryPool'));
      vkDestroyQueryPool                                 := TvkDestroyQueryPool                                (GetProcAddress('vkDestroyQueryPool'));
      vkGetQueryPoolResults                              := TvkGetQueryPoolResults                             (GetProcAddress('vkGetQueryPoolResults'));
      vkCreateBuffer                                     := TvkCreateBuffer                                    (GetProcAddress('vkCreateBuffer'));
      vkDestroyBuffer                                    := TvkDestroyBuffer                                   (GetProcAddress('vkDestroyBuffer'));
      vkCreateBufferView                                 := TvkCreateBufferView                                (GetProcAddress('vkCreateBufferView'));
      vkDestroyBufferView                                := TvkDestroyBufferView                               (GetProcAddress('vkDestroyBufferView'));
      vkCreateImage                                      := TvkCreateImage                                     (GetProcAddress('vkCreateImage'));
      vkDestroyImage                                     := TvkDestroyImage                                    (GetProcAddress('vkDestroyImage'));
      vkGetImageSubresourceLayout                        := TvkGetImageSubresourceLayout                       (GetProcAddress('vkGetImageSubresourceLayout'));
      vkCreateImageView                                  := TvkCreateImageView                                 (GetProcAddress('vkCreateImageView'));
      vkDestroyImageView                                 := TvkDestroyImageView                                (GetProcAddress('vkDestroyImageView'));
      vkCreateShaderModule                               := TvkCreateShaderModule                              (GetProcAddress('vkCreateShaderModule'));
      vkDestroyShaderModule                              := TvkDestroyShaderModule                             (GetProcAddress('vkDestroyShaderModule'));
      vkCreatePipelineCache                              := TvkCreatePipelineCache                             (GetProcAddress('vkCreatePipelineCache'));
      vkDestroyPipelineCache                             := TvkDestroyPipelineCache                            (GetProcAddress('vkDestroyPipelineCache'));
      vkGetPipelineCacheData                             := TvkGetPipelineCacheData                            (GetProcAddress('vkGetPipelineCacheData'));
      vkMergePipelineCaches                              := TvkMergePipelineCaches                             (GetProcAddress('vkMergePipelineCaches'));
      vkCreateGraphicsPipelines                          := TvkCreateGraphicsPipelines                         (GetProcAddress('vkCreateGraphicsPipelines'));
      vkCreateComputePipelines                           := TvkCreateComputePipelines                          (GetProcAddress('vkCreateComputePipelines'));
      vkDestroyPipeline                                  := TvkDestroyPipeline                                 (GetProcAddress('vkDestroyPipeline'));
      vkCreatePipelineLayout                             := TvkCreatePipelineLayout                            (GetProcAddress('vkCreatePipelineLayout'));
      vkDestroyPipelineLayout                            := TvkDestroyPipelineLayout                           (GetProcAddress('vkDestroyPipelineLayout'));
      vkCreateSampler                                    := TvkCreateSampler                                   (GetProcAddress('vkCreateSampler'));
      vkDestroySampler                                   := TvkDestroySampler                                  (GetProcAddress('vkDestroySampler'));
      vkCreateDescriptorSetLayout                        := TvkCreateDescriptorSetLayout                       (GetProcAddress('vkCreateDescriptorSetLayout'));
      vkDestroyDescriptorSetLayout                       := TvkDestroyDescriptorSetLayout                      (GetProcAddress('vkDestroyDescriptorSetLayout'));
      vkCreateDescriptorPool                             := TvkCreateDescriptorPool                            (GetProcAddress('vkCreateDescriptorPool'));
      vkDestroyDescriptorPool                            := TvkDestroyDescriptorPool                           (GetProcAddress('vkDestroyDescriptorPool'));
      vkResetDescriptorPool                              := TvkResetDescriptorPool                             (GetProcAddress('vkResetDescriptorPool'));
      vkAllocateDescriptorSets                           := TvkAllocateDescriptorSets                          (GetProcAddress('vkAllocateDescriptorSets'));
      vkFreeDescriptorSets                               := TvkFreeDescriptorSets                              (GetProcAddress('vkFreeDescriptorSets'));
      vkUpdateDescriptorSets                             := TvkUpdateDescriptorSets                            (GetProcAddress('vkUpdateDescriptorSets'));
      vkCreateFramebuffer                                := TvkCreateFramebuffer                               (GetProcAddress('vkCreateFramebuffer'));
      vkDestroyFramebuffer                               := TvkDestroyFramebuffer                              (GetProcAddress('vkDestroyFramebuffer'));
      vkCreateRenderPass                                 := TvkCreateRenderPass                                (GetProcAddress('vkCreateRenderPass'));
      vkDestroyRenderPass                                := TvkDestroyRenderPass                               (GetProcAddress('vkDestroyRenderPass'));
      vkGetRenderAreaGranularity                         := TvkGetRenderAreaGranularity                        (GetProcAddress('vkGetRenderAreaGranularity'));
      vkCreateCommandPool                                := TvkCreateCommandPool                               (GetProcAddress('vkCreateCommandPool'));
      vkDestroyCommandPool                               := TvkDestroyCommandPool                              (GetProcAddress('vkDestroyCommandPool'));
      vkResetCommandPool                                 := TvkResetCommandPool                                (GetProcAddress('vkResetCommandPool'));
      vkAllocateCommandBuffers                           := TvkAllocateCommandBuffers                          (GetProcAddress('vkAllocateCommandBuffers'));
      vkFreeCommandBuffers                               := TvkFreeCommandBuffers                              (GetProcAddress('vkFreeCommandBuffers'));
      vkBeginCommandBuffer                               := TvkBeginCommandBuffer                              (GetProcAddress('vkBeginCommandBuffer'));
      vkEndCommandBuffer                                 := TvkEndCommandBuffer                                (GetProcAddress('vkEndCommandBuffer'));
      vkResetCommandBuffer                               := TvkResetCommandBuffer                              (GetProcAddress('vkResetCommandBuffer'));
      vkCmdBindPipeline                                  := TvkCmdBindPipeline                                 (GetProcAddress('vkCmdBindPipeline'));
      vkCmdSetViewport                                   := TvkCmdSetViewport                                  (GetProcAddress('vkCmdSetViewport'));
      vkCmdSetScissor                                    := TvkCmdSetScissor                                   (GetProcAddress('vkCmdSetScissor'));
      vkCmdSetLineWidth                                  := TvkCmdSetLineWidth                                 (GetProcAddress('vkCmdSetLineWidth'));
      vkCmdSetDepthBias                                  := TvkCmdSetDepthBias                                 (GetProcAddress('vkCmdSetDepthBias'));
      vkCmdSetBlendConstants                             := TvkCmdSetBlendConstants                            (GetProcAddress('vkCmdSetBlendConstants'));
      vkCmdSetDepthBounds                                := TvkCmdSetDepthBounds                               (GetProcAddress('vkCmdSetDepthBounds'));
      vkCmdSetStencilCompareMask                         := TvkCmdSetStencilCompareMask                        (GetProcAddress('vkCmdSetStencilCompareMask'));
      vkCmdSetStencilWriteMask                           := TvkCmdSetStencilWriteMask                          (GetProcAddress('vkCmdSetStencilWriteMask'));
      vkCmdSetStencilReference                           := TvkCmdSetStencilReference                          (GetProcAddress('vkCmdSetStencilReference'));
      vkCmdBindDescriptorSets                            := TvkCmdBindDescriptorSets                           (GetProcAddress('vkCmdBindDescriptorSets'));
      vkCmdBindIndexBuffer                               := TvkCmdBindIndexBuffer                              (GetProcAddress('vkCmdBindIndexBuffer'));
      vkCmdBindVertexBuffers                             := TvkCmdBindVertexBuffers                            (GetProcAddress('vkCmdBindVertexBuffers'));
      vkCmdDraw                                          := TvkCmdDraw                                         (GetProcAddress('vkCmdDraw'));
      vkCmdDrawIndexed                                   := TvkCmdDrawIndexed                                  (GetProcAddress('vkCmdDrawIndexed'));
      vkCmdDrawIndirect                                  := TvkCmdDrawIndirect                                 (GetProcAddress('vkCmdDrawIndirect'));
      vkCmdDrawIndexedIndirect                           := TvkCmdDrawIndexedIndirect                          (GetProcAddress('vkCmdDrawIndexedIndirect'));
      vkCmdDispatch                                      := TvkCmdDispatch                                     (GetProcAddress('vkCmdDispatch'));
      vkCmdDispatchIndirect                              := TvkCmdDispatchIndirect                             (GetProcAddress('vkCmdDispatchIndirect'));
      vkCmdCopyBuffer                                    := TvkCmdCopyBuffer                                   (GetProcAddress('vkCmdCopyBuffer'));
      vkCmdCopyImage                                     := TvkCmdCopyImage                                    (GetProcAddress('vkCmdCopyImage'));
      vkCmdBlitImage                                     := TvkCmdBlitImage                                    (GetProcAddress('vkCmdBlitImage'));
      vkCmdCopyBufferToImage                             := TvkCmdCopyBufferToImage                            (GetProcAddress('vkCmdCopyBufferToImage'));
      vkCmdCopyImageToBuffer                             := TvkCmdCopyImageToBuffer                            (GetProcAddress('vkCmdCopyImageToBuffer'));
      vkCmdUpdateBuffer                                  := TvkCmdUpdateBuffer                                 (GetProcAddress('vkCmdUpdateBuffer'));
      vkCmdFillBuffer                                    := TvkCmdFillBuffer                                   (GetProcAddress('vkCmdFillBuffer'));
      vkCmdClearColorImage                               := TvkCmdClearColorImage                              (GetProcAddress('vkCmdClearColorImage'));
      vkCmdClearDepthStencilImage                        := TvkCmdClearDepthStencilImage                       (GetProcAddress('vkCmdClearDepthStencilImage'));
      vkCmdClearAttachments                              := TvkCmdClearAttachments                             (GetProcAddress('vkCmdClearAttachments'));
      vkCmdResolveImage                                  := TvkCmdResolveImage                                 (GetProcAddress('vkCmdResolveImage'));
      vkCmdSetEvent                                      := TvkCmdSetEvent                                     (GetProcAddress('vkCmdSetEvent'));
      vkCmdResetEvent                                    := TvkCmdResetEvent                                   (GetProcAddress('vkCmdResetEvent'));
      vkCmdWaitEvents                                    := TvkCmdWaitEvents                                   (GetProcAddress('vkCmdWaitEvents'));
      vkCmdPipelineBarrier                               := TvkCmdPipelineBarrier                              (GetProcAddress('vkCmdPipelineBarrier'));
      vkCmdBeginQuery                                    := TvkCmdBeginQuery                                   (GetProcAddress('vkCmdBeginQuery'));
      vkCmdEndQuery                                      := TvkCmdEndQuery                                     (GetProcAddress('vkCmdEndQuery'));
      vkCmdResetQueryPool                                := TvkCmdResetQueryPool                               (GetProcAddress('vkCmdResetQueryPool'));
      vkCmdWriteTimestamp                                := TvkCmdWriteTimestamp                               (GetProcAddress('vkCmdWriteTimestamp'));
      vkCmdCopyQueryPoolResults                          := TvkCmdCopyQueryPoolResults                         (GetProcAddress('vkCmdCopyQueryPoolResults'));
      vkCmdPushConstants                                 := TvkCmdPushConstants                                (GetProcAddress('vkCmdPushConstants'));
      vkCmdBeginRenderPass                               := TvkCmdBeginRenderPass                              (GetProcAddress('vkCmdBeginRenderPass'));
      vkCmdNextSubpass                                   := TvkCmdNextSubpass                                  (GetProcAddress('vkCmdNextSubpass'));
      vkCmdEndRenderPass                                 := TvkCmdEndRenderPass                                (GetProcAddress('vkCmdEndRenderPass'));
      vkCmdExecuteCommands                               := TvkCmdExecuteCommands                              (GetProcAddress('vkCmdExecuteCommands'));
      
      { ========================================= VK_KHR_swapchain ========================================= }
      vkCreateSwapchainKHR                               := TvkCreateSwapchainKHR                              (GetProcAddress('vkCreateSwapchainKHR'));
      vkDestroySwapchainKHR                              := TvkDestroySwapchainKHR                             (GetProcAddress('vkDestroySwapchainKHR'));
      vkGetSwapchainImagesKHR                            := TvkGetSwapchainImagesKHR                           (GetProcAddress('vkGetSwapchainImagesKHR'));
      vkAcquireNextImageKHR                              := TvkAcquireNextImageKHR                             (GetProcAddress('vkAcquireNextImageKHR'));
      vkQueuePresentKHR                                  := TvkQueuePresentKHR                                 (GetProcAddress('vkQueuePresentKHR'));
      
      { ===================================== VK_KHR_display_swapchain ===================================== }
      vkCreateSharedSwapchainsKHR                        := TvkCreateSharedSwapchainsKHR                       (GetProcAddress('vkCreateSharedSwapchainsKHR'));

    end;
  except
    FreeAndNil(result);
    raise;
  end;
end;

procedure FinalizeVulkan;
begin
  vkFreeLibrary(vkLibHandle);
end;

initialization

finalization
  FinalizeVulkan;

end.