MAJOR: malloc(): unsorted double linked list corrupted
MINOR: 
font_sdf_rgba.ktx is opened in 3 different places
write more tests
BUG:
BAD:
CORRECT:
- ktx 1 parser can only handle the font_sdf_rgba.ktx,
 as it doesn't check anything or do dynamic padding for the data
Features
dynamic verts and indice buffers to a_shape as arguments
--experimental:strictEffects
  # Turn on the new refined effect tracking. It enables the new .effectsOf
  # annotation for effect polymorphic code ("this code raises if the callback does so").
--experimental:unicodeOperators
  # Allow the usage of Unicode operators.  I hope that some of
  # the scientific computing libraries use this soon.
--experimental:overloadableEnums
  # Allow enum field names to be overloaded. I hope some libraries make good use of this feature.
--define:nimPreviewDotLikeOps
  # Dot-like operators (operators starting with `.`,
 but not with `..`)
  # now have the same precedence as `.`,
 so that `a.?b.c` is now parsed as `(a.?b).c`
  # instead of `a.?(b.c)`.
--define:nimPreviewFloatRoundtrip
  # Enable much faster "floating point to string" operations that also produce
  # easier to read floating point numbers.
--gc:orc
  # The one and only way to do memory management in modern Nim.
--define:nimStrictDelete
  # make system.delete strict for index out of bounds accesses.
# THINGS
#[Tempest (video game)
#I,
 Robot (video game) 
commando
zaxon
radar scope
alone in the dark
ultima underworld
int(round((atan2((y - y_center),
(x - x_center))/PI * 4 + 4))) % 8
`KOFF` as a command to turn off voice speech - reference to C64 speech sythisizer
# getOccupiedSharedMem when using --gc:arc --threads:on" or "--gc:orc --threads:on
ful·mi·nate
/ˈfo͝olməˌnāt/
Learn to pronounce
verb
1. express vehement protest.
 "he fulminated against the evils of his time"
2. LITERARY: explode violently or flash like lightning.
"thunder fulminated around the house"
]#
# var
#   computer: Computer
# with computer:
# 	manufacturer = "bananas"
# 	cpu = "x7"
# 	powerConsumption = 17
# 	ram = 32
# 	ssd = 1024
# 	quantity = 3
# 	price = 499.99
#[
  Here are four books that Jon recommends: A Digital Signal Processing Primer: With Applications to Digital Audio and Computer Music -- Ken Stieglitz (ISBN:0805316841); Hypercomplex Numbers: An Elementary Introduction to Algebras -- I.L. Kantor (ISBN:0387969802); Linear Algebra Done Right -- Sheldon Axler (ISBN:3319110799); Hacker's Delight -- Henry Warren (ISBN:0321842685)
]#
The Cthaeh
asymptotic
You're expected to have experience in linear algebra, multi-variable calculus, group theory, and complex function theory to really understand it. 
By default, the Nim compiler passes "-g3" to the C compiler, with "--debugger:native", which almost doubles the resulting binary's size (only on disk, not in memory). If we don't need to use GDB on that binary, we can get away with significantly fewer debugging symbols by switching to "-g1":
# for the C backend
nim c --debugger:native --gcc.options.debug:'-g1' -d:release somefile.nim
(P)ower (H)ungry (M)aniacs
 - the critique of ego of Ye
The first 3 phases to the final boss (Yu?) is normal video game stuff
the last 3-4 phases are introducing the very universe lore, and his spawning and coming to the pocket, and how the tear happenend. 
/agdg/ -> Agatha Dagathe
 The good news is that any queue family with VK_QUEUE_GRAPHICS_BIT or VK_QUEUE_COMPUTE_BIT capabilities already implicitly support VK_QUEUE_TRANSFER_BIT operations. The implementation is not required to explicitly list it in queueFlags in those cases.
UI elements for most game genres should never appear outside the center 16:9 when running on ultra wide resolutions.
better FOV calculation
TASHI-497 -> The little cute bomb thing that exploded in space to create a new galaxy in Symbiotic Titan
THE SUNFLOWER CLUB -> The mysterious club/cult(?) dedicated to SUN(yellow)flowers 
On Windows, you'll need to open the binary SPIR-V file in binary mode by specifying the fopen mode flags as "rb". SPIR-V code is a sequence of 32-bit unsigned integers and on Windows you need to suppress any line-ending translations with the "binary" mode flag. The "b" flag is ignored on POSIX conforming systems like Linux and so you can leave it in your code if it is to be compiled on multiple platforms.

import vk/vulkan
vkLoad1_0()
var 
 instance: VkInstance
 val = allocCStringArray(["VK_LAYER_KHRONOS_validation", "VK_LAYER_LUNARG_api_dump"])
 appInfo = newVkApplicationInfo( pApplicationName = "instance test"
                               , applicationVersion = vkMakeVersion(1, 0, 0)
                               , pEngineName = "zzz"
                               , engineVersion = vkMakeVersion(1, 0, 0)
                               , apiVersion = vkApiVersion1_1
                               )
    
 exts = allocCStringArray([])
 instanceCreateInfo = newVkInstanceCreateInfo( pApplicationInfo = appInfo.addr
                                             , enabledExtensionCount = 0
                                             , ppEnabledExtensionNames = exts
                                             , enabledLayerCount = 0
                                             , ppEnabledLayerNames = val
                                             )
 
if vkCreateInstance(instanceCreateInfo.addr, nil, addr instance) != VKSuccess: quit("failed to create instance")
else: echo "vkInstance: PASS" 

--path:"../src/"

{.experimental: "codeReordering".}
{.deadCodeElim: on.}
#[
  THINGS TO FIX 
  : why uboVS as a ref object fucks up vertice uploading
  : #TODO: decouple rec.vk_device from rec and "properly" implement it
]#
import vulkan as nvk
, ../utils/lets
, bitops
, vkTypes
, ../memory/[utils]
#from depth_stencil import Depth_Stencil
proc `<`*(x,y: VkDeviceSize): bool = return x.int < y.int
proc `>`*(x,y: VkDeviceSize): bool = return x.int > y.int
proc `==`*(x,y: VkDeviceSize): bool = return x.int == y.int
proc getQueueFamilyIndex*( qfp: seq[VkQueueFamilyProperties], qFlags: VkQueueFlagBits): uint32 = 
 if bitand(qFlags.int, VK_QUEUE_GRAPHICS_BIT.int) == 1:
  for i, x in qfp: 
   if bitand(qfp[i].queueFlags.int, qFlags.int) == 1: return i.uint32
  
 elif bitand(qFlags.int, VK_QUEUE_TRANSFER_BIT.int) == 1:
  for i, x in qfp: 
   if bitand(qfp[i].queueFlags.int, qFlags.int) == 1: return i.uint32
  
 elif bitand(qFlags.int, VK_QUEUE_COMPUTE_BIT.int) == 1:
  for i, x in qfp: 
   if bitand(qfp[i].queueFlags.int, qFlags.int) == 1: return i.uint32
  
 else:
  for i, x in qfp: 
   if bitand(qfp[i].queueFlags.int, qFlags.int) == 1: return i.uint32
proc chooseSwapSurfaceFormat*(availableFormats: seq[VkSurfaceFormatKHR]): VkSurfaceFormatKHR =
  for availableFormat in availableFormats:
    if availableFormat.format == VK_FORMAT_B8G8R8A8_UNORM and
      availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
      return availableFormat
  availableFormats[0]
proc chooseSwapPresentMode*(availablePresentModes: seq[VkPresentModeKHR]): VkPresentModeKHR =
  for availablePresentMode in availablePresentModes:
    if availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR:
      return availablePresentMode
  VK_PRESENT_MODE_FIFO_KHR
proc chooseSwapExtent*(capabilities: VkSurfaceCapabilitiesKHR): VkExtent2D =
  if capabilities.currentExtent.width != uint32.high:
    return capabilities.currentExtent
  else:
   # result = VkExtent2D(width: WIDTH, height: HEIGHT)
    result.width = max( capabilities.minImageExtent.width, min(capabilities.maxImageExtent.width, result.width))
    result.height = max(capabilities.minImageExtent.height, min(capabilities.maxImageExtent.height, result.height) )
proc createShaderModule*(device: VkDevice, code: string): VkShaderModule =
  var createInfo = VkShaderModuleCreateInfo(
    sType: VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
    codeSize: code.len.uint32,
    pCode: cast[ptr uint32](code[0].addr)
  )
  if vkCreateShaderModule(device, createInfo.addr, nil, result.addr) != VK_SUCCESS:
    quit("failed to create shader module")
proc createCommandPool*( vk_device: VkDevice
                       , graphics_queue_index: uint32
                       ): VkCommandPool =
 var
  poolInfo = VkCommandPoolCreateInfo( sType: VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
                                    , queueFamilyIndex: graphics_queue_index # rec.qfi.graphics
                                    , flags: VkCommandPoolCreateFlags VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT# optional
                                    )
 
 if vkCreateCommandPool( vk_device
                       , poolInfo.addr
                       , nil
                       , addr result 
                       ) != VK_SUCCESS:
  quit("failed to create command pool")
proc getCommandBuffers*( device: VkDevice
                       , command_pool: VkCommandPool
                       , start: bool 
                       ): VkCommandBuffer =
 var
  allocInfo = VkCommandBufferAllocateInfo( sType: VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
                                         , commandPool: command_pool
                                         , level: VK_COMMAND_BUFFER_LEVEL_PRIMARY
                                         , commandBufferCount: 1
                                         )
 discard vkAllocateCommandBuffers(device, allocInfo.addr, result.addr)
 if start: 
  var cmdBufInfo: VkCommandBufferBeginInfo
  cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
  discard vkBeginCommandBuffer(result, addr cmdBufInfo)
 
 result
proc createPipeLineCache*( vk_device: VKDevice                         
                         ): VkPipelineCache =
 
 var pipelineCacheCreateInfo: VkPipelineCacheCreateInfo
 pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
 discard vkCreatePipelineCache( vk_device
                              , addr pipelineCacheCreateInfo
                              , nil
                              , addr result 
                              )
 
proc flushCommandBuffer*( device: VkDevice
                        , q: VkQueue
                        , command_pool: VkCommandPool
                        , commandBuffer: var VkCommandBuffer
                        ) = 
  discard vkEndCommandBuffer commandBuffer
  var
   submitInfo: VkSubmitInfo
   fenceCreateInfo: VkFenceCreateInfo
   fence: VkFence
  submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO
  submitInfo.commandBufferCount = 1
  submitInfo.pCommandBuffers = addr commandBuffer #????????
  # Create fence to ensure that the command buffer has finished executing
  fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
  fenceCreateInfo.flags = VkFenceCreateFlags 0
  discard vkCreateFence(device, addr fenceCreateInfo, nil, addr fence)
  # Submit to the queue
  discard vkQueueSubmit(q, 1, addr submitInfo, fence)
  # # Wait for the fence to signal that command buffer has finished executing 
  discard vkWaitForFences(device, 1.uint32, addr fence, VkBool32 VK_TRUE, high uint64) # in nanoseconds
  vkDestroyFence(device, fence, nil)
  vkFreeCommandBuffers(device, command_pool, 1, addr commandBuffer)
proc createOneCommandBuffer*( device: VkDevice
                          , pool: VkCommandPool 
                          , level: VkCommandBufferLevel = VK_COMMAND_BUFFER_LEVEL_PRIMARY
                          , begin: bool = false
                          ): VkCommandBuffer =
 
 var allocInfo = VkCommandBufferAllocateInfo( sType: VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
                                            , commandPool: pool
                                            , level: level
                                            , commandBufferCount: 1
                                            )
 discard vkAllocateCommandBuffers(device, addr allocInfo, addr result)
 
 if begin: 
  var cmdBufferBeginInfo: VkCommandBufferBeginInfo
  cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
  discard vkBeginCommandBuffer(result, addr cmdBufferBeginInfo)
 result
proc setImageLayout*( cmdbuffer: VkCommandBuffer
                   , image: VkImage
                   , oldImageLayout: VkImageLayout
                   , newImageLayout: VkImageLayout
                   , subresourceRange: VkImageSubresourceRange
                   , srcStageMask: VkPipelineStageFlags
                   , dstStageMask: VkPipelineStageFlags
                   ) = 
 
 var
  # Initialize an image memory barrier with no image transfer ownership
  imageMemoryBarrier = VkImageMemoryBarrier( sType: VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
                                           , srcQueueFamilyIndex: VK_QUEUE_FAMILY_IGNORED
                                           , dstQueueFamilyIndex: VK_QUEUE_FAMILY_IGNORED
                                           , oldLayout: oldImageLayout
                                           , newLayout: newImageLayout
                                           , image: image
                                           , subresourceRange: subresourceRange
                                           )
 # Source layouts (old)
 # Source access mask controls actions that have to be finished on the old layout
 # before it will be transitioned to the new layout
 case oldImageLayout:
 
  of VK_IMAGE_LAYOUT_UNDEFINED:
   # Image layout is undefined (or does not matter)
   # Only valid as initial layout
   # No flags required, listed only for completeness
   imageMemoryBarrier.srcAccessMask = VkAccessFlags 0
 
  of VK_IMAGE_LAYOUT_PREINITIALIZED:
   # Image is preinitialized
   # Only valid as initial layout for linear images, preserves memory contents
   # Make sure host writes have been finished
   imageMemoryBarrier.srcAccessMask = VkAccessFlags VK_ACCESS_HOST_WRITE_BIT
 
  of VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
   # Image is a color attachment
   # Make sure any writes to the color buffer have been finished
   imageMemoryBarrier.srcAccessMask = VkAccessFlags VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
  
  of VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
   # Image is a depth/stencil attachment  
   # Make sure any writes to the depth/stencil buffer have been finished
   imageMemoryBarrier.srcAccessMask = VkAccessFlags VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
  
  of VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
   # Image is a transfer source
   # Make sure any reads from the image have been finished
   imageMemoryBarrier.srcAccessMask = VkAccessFlags VK_ACCESS_TRANSFER_READ_BIT
   
  of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
   # Image is a transfer destination
   # Make sure any writes to the image have been finished
   imageMemoryBarrier.srcAccessMask = VkAccessFlags VK_ACCESS_TRANSFER_WRITE_BIT
  
  of VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
   # Image is read by a shader
   # Make sure any shader reads from the image have been finished
   imageMemoryBarrier.srcAccessMask = VkAccessFlags VK_ACCESS_SHADER_READ_BIT
  else: discard # Other source layouts aren't handled (yet)
 # Target layouts (new)
 # Destination access mask controls the dependency for the new image layout
 case newImageLayout:
  of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
   # Image will be used as a transfer destination
   # Make sure any writes to the image have been finished
   imageMemoryBarrier.dstAccessMask = VkAccessFlags VK_ACCESS_TRANSFER_WRITE_BIT
  of VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
   # Image will be used as a transfer source
   # Make sure any reads from the image have been finished
   imageMemoryBarrier.dstAccessMask = VkAccessFlags VK_ACCESS_TRANSFER_READ_BIT
  of VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
   # Image will be used as a color attachment
   # Make sure any writes to the color buffer have been finished
   imageMemoryBarrier.dstAccessMask = VkAccessFlags VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
  of VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
   # Image layout will be used as a depth/stencil attachment
   # Make sure any writes to depth/stencil buffer have been finished
   imageMemoryBarrier.dstAccessMask = VkAccessFlags bitor(imageMemoryBarrier.dstAccessMask.ord, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT.ord)
  of VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
   # Image will be read in a shader (sampler, input attachment)
   # Make sure any writes to the image have been finished
   if (imageMemoryBarrier.srcAccessMask.int == 0).bool:
    imageMemoryBarrier.srcAccessMask = VkAccessFlags bitor(VK_ACCESS_HOST_WRITE_BIT.ord, VK_ACCESS_TRANSFER_WRITE_BIT.ord)
   imageMemoryBarrier.dstAccessMask = VkAccessFlags VK_ACCESS_SHADER_READ_BIT
  
  else: discard #Other source layouts aren't handled (yet)
 # Put barrier inside setup command buffer
 vkCmdPipelineBarrier( cmdbuffer
                    , srcStageMask
                    , dstStageMask
                    , VkDependencyFlags 0
                    , 0
                    , nil
                    , 0
                    , nil
                    , 1
                    , addr imageMemoryBarrier)
proc beginSingleTimeCommands*( vk_device: VkDevice 
                             , command_pool: VkCommandPool
                             ): VkCommandBuffer = 
 var 
  commandBuffer: VkCommandBuffer
  beginInfo = VkCommandBufferBeginInfo( sType:VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
                                      , flags: VkCommandBufferUsageFlags VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
                                      )
  allocInfo = VkCommandBufferAllocateInfo( sType: VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
                                         , level: VK_COMMAND_BUFFER_LEVEL_PRIMARY
                                         , commandPool: command_pool
                                         , commandBufferCount: 1
                                         )
 discard vkAllocateCommandBuffers( vk_device
                                 , addr allocInfo
                                 , addr commandBuffer
                                 )
 
 discard vkBeginCommandBuffer(commandBuffer, addr beginInfo)
proc endSingleTimeCommands*( vk_device: VkDevice 
                           , cmdBuffer: VkCommandBuffer
                           , graphics_queue: VkQueue
                           , command_pool: VkCommandPool
                           , fence: VkFence = VkFence 0
                           , cmdBufferCount: uint32 = 1
                           ) = 
 var submitInfo = VkSubmitInfo( sType: VK_STRUCTURE_TYPE_SUBMIT_INFO
                              , commandBufferCount: cmdBufferCount
                              , pCommandBuffers: addr cmdBuffer
                              )
 discard vkEndCommandBuffer(cmdBuffer
                           )
 
 discard vkQueueSubmit( graphics_queue
                      , uint32 1
                      , addr submitInfo
                      , fence
                      )
 
 discard vkQueueWaitIdle graphics_queue
 
 vkFreeCommandBuffers( vk_device
                     , command_pool 
                     , 1
                     , addr cmdBuffer
                     )
 
proc createImageView*( device: VkDevice
                     , image: VkImage
                     , format: VkFormat
                     ): VkImageVIew = 
 var viewInfo = VkImageViewCreateInfo( sType: VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
                           , image: image
                           , viewType: VK_IMAGE_VIEW_TYPE_2D
                           , format: format
                           , subresourceRange: VkImageSubresourceRange( aspectMask: VkImageAspectFlags VK_IMAGE_ASPECT_COLOR_BIT
                                                                       , baseMipLevel: 0
                                                                       , levelCount: 1
                                                                       , baseArrayLayer: 0
                                                                       , layerCount: 1
                                                                       )
                           )
 discard vkCreateImageView(device, addr viewInfo, nil, addr result)
 result
# TODO: Samplers can be shared. Decide on parameters and reuse samplers
# when the same parameters are passed.
proc createSampler*(device: VkDevice): VkSampler = 
 var samplerInfo = VkSamplerCreateInfo( sType: VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
                                    , magFilter: VK_FILTER_LINEAR
                                    , minFilter: VK_FILTER_LINEAR
                                    , addressModeU: VK_SAMPLER_ADDRESS_MODE_REPEAT
                                    , addressModeV: VK_SAMPLER_ADDRESS_MODE_REPEAT
                                    , addressModeW: VK_SAMPLER_ADDRESS_MODE_REPEAT
                                    , anisotropyEnable: vktrue
                                    , maxAnisotropy: 16
                                    , borderColor: VK_BORDER_COLOR_INT_OPAQUE_BLACK
                                    , unnormalizedCoordinates: vkfalse
                                    , compareEnable:  vkfalse
                                    , compareOp: VK_COMPARE_OP_ALWAYS
                                    , mipmapMode: VK_SAMPLER_MIPMAP_MODE_LINEAR
                                    )
 discard vkCreateSampler(device, addr samplerInfo,  nil, addr result)
 result
proc newVkFenceCreateInfo*(sType: VkStructureType = VkStructureTypeFenceCreateInfo, pNext: pointer = nil, flags: VkFenceCreateFlags = 0.VkFenceCreateFlags): VkFenceCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  
proc createSyncPrims*( vk_device: VkDevice 
                     , fences: var seq[VkFence]
                     , draw_command_buffers: var seq[VkCommandBuffer]
                    
                     ) =
 var createInfo = newVkFenceCreateInfo() 
 
 #echo rec.draw_command_buffers.len
 fences.setLen draw_command_buffers.len
 for i,fence in fences: 
  discard vkCreateFence( vk_device
                       , addr createInfo
                       , nil
                       , addr fences[i] 
                       )
proc aVkDescriptorImageInfo*( sampler: VkSampler
                           , imageView: VkImageView
                           , imageLayout: VkImageLayout
                           ): VkDescriptorImageInfo = 
 result = VkDescriptorImageInfo()
 result.sampler = sampler
 result.imageView = imageView
 result.imageLayout = imageLayout
proc aVkWriteDescriptorSet*( descSet: VkDescriptorSet
                          ,  descType: VkDescriptorType
                          ,  binding: uint32
                          ,  bufferInfo: VkDescriptorBufferInfo
                          ,  descriptorCount: uint32 = 1  
                          ): VkWriteDescriptorSet = 
 
 result = VkWriteDescriptorSet()
 result.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
 result.dstSet = descSet
 result.descriptorType = descType
 result.dstBinding = binding
 result.pBufferInfo = cast[ptr ptr VkDescriptorBufferInfo] (addr bufferInfo) # LMAO?????
 result.descriptorCount = descriptorCount
                      
proc aVkDescriptorSetLayoutBinding*( descType: VkDescriptorType
                                  , stageFlags: VkShaderStageFlags
                                  , binding: uint32
                                  , descCount: uint32 = 1): VkDescriptorSetLayoutBinding = 
 result = VkDescriptorSetLayoutBinding()
 result.descriptorType = descType
 result.stageFlags = stageFlags
 result.binding = binding
 result.descriptorCount = descCount
proc aVkBufferCreateInfo*( usage: VkBufferUsageFlags
                         , size: VkDeviceSize = vk0
                         ): VkBufferCreateInfo = 
 
 result = VkBufferCreateInfo(sType: VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
                            , usage: usage
                            , size: size
                            )
proc Vkds*[T](t: T): VKDeviceSize {.inline.}= VKDeviceSize t
proc find_memory_with_property*( memory_properties: VkPhysicalDeviceMemoryProperties
                               , the_type_bits: var uint32
                               , required_memory_properties: VkMemoryPropertyFlags 
                               ): uint32 =
 for memory_index in 0 ..< memoryProperties.memoryTypeCount:
  let 
   memory_type_bits = 1 shl memory_index
   is_required_memory_type = (the_type_bits and memory_type_bits.uint32)
   property_flags: VkMemoryPropertyFlags = memory_properties.memoryTypes[memory_index].propertyFlags
   memory_has_required_properties = ( property_flags.int and 
                                      required_memory_properties.int
                                    )
  # is == 1 correct?
  if is_required_memory_type == 1 and 
   memory_has_required_properties == 1:
    return memory_index
 
 quit("no matching memory type could be found:")
proc create_image*( vk_device: VkDevice 
                  , gpu_memory_properties: VkPhysicalDeviceMemoryProperties
                  , width: uint32
                  , height: uint32
                  , depth: uint32
                  , format: VkFormat
                  , tiling: VkImageTiling
                  , usage: VkImageUsageFlags
                  , properties: VkMemoryPropertyFlags
                  ): BoundImage = 
 var  
  allocInfo = VkMemoryAllocateInfo(sType: VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO)
  image: VKImage
  memReqs: VkMemoryRequirements 
  imageMem: VkDeviceMemory
  imageci =  VkimageCreateInfo( sType: VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
                               , imageType: VK_IMAGE_TYPE_2D
                               , extent: VkExtent3D( width: width
                                                   , height: height
                                                   , depth: 1
                                                   )
                               , mipLevels: 1
                               , arrayLayers: 1
                               , format: format
                               , tiling: tiling
                               , initialLayout: VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
                               , usage: usage
                               , samples: VK_SAMPLE_COUNT_1_BIT
                               , sharingMode: VK_SHARING_MODE_EXCLUSIVE
                               #[ , imageCreateMaxMipLevels: 1
                               , imageCreateMaxArrayLayers: 1 
                               , imageCreateMaxExtent: VkExtent3D( width: width
                                                                 , height: height
                                                                , depth: depth
                                                                 )
                               , imageCreateSampleCounts: VK_SAMPLE_COUNT_1_BIT ]#
                               )
 discard vkCreateImage( vk_device
                      , addr imageci
                      , nil
                      , addr image
                      )
 
 vkGetImageMemoryRequirements( vk_device
                             , image
                             , addr memReqs
                             )
 
 allocInfo.allocationSize = memReqs.size
 allocInfo.memoryTypeIndex = find_memory_with_property( gpu_memory_properties
                                                      , memReqs.memoryTypeBits
                                                      , properties
                                                      )
             
 discard vkBindImageMemory( vk_device
                          , image
                          , imageMem
                          , vk0
                          )
#TODO: This should be per pipeline correct?
proc create_descriptor_pool*( vk_device: VkDevice 
                           ): VkDescriptorPool = 
 
 var
  sizes = [ VkDescriptorPoolSize( typee: VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
                                , descriptorCount: 1
                                )
          
          , VkDescriptorPoolSize( typee: VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
                                , descriptorCount: 1
                                )
          ]
  # Create the global descriptor pool
  # All descriptors used in this example are allocated from this pool
  descriptorPoolInfo = VkDescriptorPoolCreateInfo( sType :  VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
                                                 , pNext : nil
                                                 , poolSizeCount : 2
                                                 , pPoolSizes : addr sizes[0]
                                                 , maxSets: 4 # Set the max. number of descriptor sets that can be requested from this pool
                                                )
 
 discard vkCreateDescriptorPool( vk_device
                               , addr descriptorPoolInfo
                               , nil
                               , addr result
                               )
 
 result 

import vulkan 
, gpu 
, swapchain
, vkTypes 
, buffer 
, depth_stencil
, render_pass
, uniform_buffer
, graphics_pipeline
type 
 Vulkan_Record_Object = object of RootObj
  command_pool*: VkCommandPool
  vk_device*: VkDevice
  gpu*: GPU
  graphics_queue*: VkQueue
  instance*: VkInstance
  logicalDevice*: VkDevice
  presentQueue*: VkQueue
  queue*: VkQueue
  swapchain*: Swapchain
  semaphores*: Semaphores 
  pipeline_cache*: VkPipelineCache
  frame_buffers*: seq[VkFramebuffer]
  currentFrameBuffer*: uint32 
  instanceExtensions*: cstringarray
  ieLen*: int
  deviceExtensions*: cstringarray
  deLen*: int
  framePrepared*: bool
  qfi*: QueueFamily
  qfps*: seq[VkQueueFamilyProperties]
  qni*: uint32
  submitInfo*: VkSubmitInfo
  draw_command_buffers*: seq[VkCommandBuffer]
  fences*: seq[VkFence]
  presentCompleteSemaphore*: VkSemaphore
  renderCompleteSemaphore*: VkSemaphore
  current_viewport*: VkViewport
  readyFrame*: bool
  master_vertex_buffer*: Buffer 
  master_index_buffer*: Buffer 
  master_uniform_buffer*: Buffer 
  
 Vulkan_Record* = ref object of Vulkan_Record_Object

var vkGetProc*: proc(procName: cstring): pointer {.cdecl.}
when not defined(vkCustomLoader):
 import dynlib
 when defined(linux): 
  const vkDLL = "libvulkan.so.1"
 when defined(windows): 
  const vkDLL = "vulkan-1.dll"
 let vkHandleDLL = loadLib(vkDLL)
 if isNil(vkHandleDLL):
  quit("could not load: " & vkDLL)
 let vkGetProcAddress* = cast[proc(s: cstring): pointer {.stdcall.}](symAddr(vkHandleDLL, "vkGetInstanceProcAddr"))
 if vkGetProcAddress == nil:
  quit("failed to load `vkGetInstanceProcAddr` from " & vkDLL)
 vkGetProc = proc(procName: cstring): pointer {.cdecl.} =
   when defined(windows):
     result = vkGetProcAddress(procName)
     if result != nil:
       echo "vkGetProc SUCCESS: " & $procName
       return
     else: quit("vkGetProcAddress(" & $procName & ") is nil")
   result = symAddr(vkHandleDLL, procName)
   if result == nil:
    raiseInvalidLibrary(procName)
proc setVKGetProc*(getProc: proc(procName: cstring): pointer {.cdecl.}) =
  vkGetProc = getProc
type
  VkHandle* = int64
  VkNonDispatchableHandle* = int64
  ANativeWindow = ptr object
  CAMetalLayer = ptr object
  AHardwareBuffer = ptr object
# Enums
const
  VK_MAX_PHYSICAL_DEVICE_NAME_SIZE* = 256
  VK_UUID_SIZE* = 16
  VK_LUID_SIZE* = 8
  VK_LUID_SIZE_KHR* = VK_LUID_SIZE
  VK_MAX_EXTENSION_NAME_SIZE* = 256
  VK_MAX_DESCRIPTION_SIZE* = 256
  VK_MAX_MEMORY_TYPES* = 32
  VK_MAX_MEMORY_HEAPS* = 16
  VK_LOD_CLAMP_NONE* = 1000.0f
  VK_REMAINING_MIP_LEVELS* = (not 0'u32)
  VK_REMAINING_ARRAY_LAYERS* = (not 0'u32)
  VK_WHOLE_SIZE* = (not 0'u64)
  VK_ATTACHMENT_UNUSED* = (not 0'u32)
  VK_TRUE* = 1
  VK_FALSE* = 0
  VK_QUEUE_FAMILY_IGNORED* = (not 0'u32)
  VK_QUEUE_FAMILY_EXTERNAL* = (not 0'u32) - 1
  VK_QUEUE_FAMILY_EXTERNAL_KHR* = VK_QUEUE_FAMILY_EXTERNAL
  VK_QUEUE_FAMILY_FOREIGN_EXT* = (not 0'u32) - 2
  VK_SUBPASS_EXTERNAL* = (not 0'u32)
  VK_MAX_DEVICE_GROUP_SIZE* = 32
  VK_MAX_DEVICE_GROUP_SIZE_KHR* = VK_MAX_DEVICE_GROUP_SIZE
  VK_MAX_DRIVER_NAME_SIZE* = 256
  VK_MAX_DRIVER_NAME_SIZE_KHR* = VK_MAX_DRIVER_NAME_SIZE
  VK_MAX_DRIVER_INFO_SIZE* = 256
  VK_MAX_DRIVER_INFO_SIZE_KHR* = VK_MAX_DRIVER_INFO_SIZE
  VK_SHADER_UNUSED_KHR* = (not 0'u32)
  VK_SHADER_UNUSED_NV* = VK_SHADER_UNUSED_KHR
type
  VkImageLayout* {.size: int32.sizeof.} = enum
    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_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000
    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001
    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000
    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001
    VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002
    VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003
    VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000
    VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001
  VkAttachmentLoadOp* {.size: int32.sizeof.} = enum
    VK_ATTACHMENT_LOAD_OP_LOAD = 0
    VK_ATTACHMENT_LOAD_OP_CLEAR = 1
    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2
  VkAttachmentStoreOp* {.size: int32.sizeof.} = enum
    VK_ATTACHMENT_STORE_OP_STORE = 0
    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1
  VkImageType* {.size: int32.sizeof.} = enum
    VK_IMAGE_TYPE_1D = 0
    VK_IMAGE_TYPE_2D = 1
    VK_IMAGE_TYPE_3D = 2
  VkImageTiling* {.size: int32.sizeof.} = enum
    VK_IMAGE_TILING_OPTIMAL = 0
    VK_IMAGE_TILING_LINEAR = 1
  VkImageViewType* {.size: int32.sizeof.} = enum
    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
  VkCommandBufferLevel* {.size: int32.sizeof.} = enum
    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0
    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1
  VkComponentSwizzle* {.size: int32.sizeof.} = enum
    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
  VkDescriptorType* {.size: int32.sizeof.} = enum
    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
  VkQueryType* {.size: int32.sizeof.} = enum
    VK_QUERY_TYPE_OCCLUSION = 0
    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1
    VK_QUERY_TYPE_TIMESTAMP = 2
  VkBorderColor* {.size: int32.sizeof.} = enum
    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
  VkPipelineBindPoint* {.size: int32.sizeof.} = enum
    VK_PIPELINE_BIND_POINT_GRAPHICS = 0
    VK_PIPELINE_BIND_POINT_COMPUTE = 1
  VkPipelineCacheHeaderVersion* {.size: int32.sizeof.} = enum
    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1
  VkPrimitiveTopology* {.size: int32.sizeof.} = enum
    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
  VkSharingMode* {.size: int32.sizeof.} = enum
    VK_SHARING_MODE_EXCLUSIVE = 0
    VK_SHARING_MODE_CONCURRENT = 1
  VkIndexType* {.size: int32.sizeof.} = enum
    VK_INDEX_TYPE_UINT16 = 0
    VK_INDEX_TYPE_UINT32 = 1
  VkFilter* {.size: int32.sizeof.} = enum
    VK_FILTER_NEAREST = 0
    VK_FILTER_LINEAR = 1
  VkSamplerMipmapMode* {.size: int32.sizeof.} = enum
    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0
    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1
  VkSamplerAddressMode* {.size: int32.sizeof.} = enum
    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
  VkCompareOp* {.size: int32.sizeof.} = enum
    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
  VkPolygonMode* {.size: int32.sizeof.} = enum
    VK_POLYGON_MODE_FILL = 0
    VK_POLYGON_MODE_LINE = 1
    VK_POLYGON_MODE_POINT = 2
  VkCullModeFlagBits* {.size: int32.sizeof.} = enum
    VK_CULL_MODE_NONE = 0
    VK_CULL_MODE_FRONT_BIT = 1
    VK_CULL_MODE_BACK_BIT = 2
    VK_CULL_MODE_FRONT_AND_BACK = 3
  VkFrontFace* {.size: int32.sizeof.} = enum
    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0
    VK_FRONT_FACE_CLOCKWISE = 1
  VkBlendFactor* {.size: int32.sizeof.} = enum
    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
  VkBlendOp* {.size: int32.sizeof.} = enum
    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
  VkStencilOp* {.size: int32.sizeof.} = enum
    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
  VkLogicOp* {.size: int32.sizeof.} = enum
    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
  VkInternalAllocationType* {.size: int32.sizeof.} = enum
    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0
  VkSystemAllocationScope* {.size: int32.sizeof.} = enum
    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
  VkPhysicalDeviceType* {.size: int32.sizeof.} = enum
    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
  VkVertexInputRate* {.size: int32.sizeof.} = enum
    VK_VERTEX_INPUT_RATE_VERTEX = 0
    VK_VERTEX_INPUT_RATE_INSTANCE = 1
  VkFormat* {.size: int32.sizeof.} = enum
    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_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000
    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001
    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002
    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003
    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004
    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005
    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006
    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007
    VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000
    VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001
    VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002
    VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003
    VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004
    VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005
    VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006
    VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007
    VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008
    VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009
    VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010
    VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011
    VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012
    VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013
    VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000
    VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001
    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002
    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003
    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004
    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005
    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006
    VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007
    VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008
    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009
    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010
    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015
    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016
    VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017
    VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018
    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019
    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020
    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025
    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026
    VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027
    VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028
    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029
    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030
    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031
    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032
    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033
    VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = 1000330000
    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = 1000330001
    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = 1000330002
    VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = 1000330003
    VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = 1000340000
    VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = 1000340001
    VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
  VkStructureType* {.size: int32.sizeof.} = enum
    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 #added by me
    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000
    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000
    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = 1000060000
    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004
    VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000
  VkSubpassContents* {.size: int32.sizeof.} = enum
    VK_SUBPASS_CONTENTS_INLINE = 0
    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1
  VkResult* {.size: int32.sizeof.} = enum
    VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000,
    VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000
    VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
    VK_ERROR_FRAGMENTATION = -1000161000,
    VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
    VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
    VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000,
    VK_ERROR_INVALID_SHADER_NV = -1000012000,
    VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
    VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
    VK_ERROR_SURFACE_LOST_KHR = -1000000000,
    VK_ERROR_UNKNOWN = -13,
    VK_ERROR_FRAGMENTED_POOL = -12,
    VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
    VK_ERROR_TOO_MANY_OBJECTS = -10,
    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
    VK_ERROR_FEATURE_NOT_PRESENT = -8,
    VK_ERROR_EXTENSION_NOT_PRESENT = -7,
    VK_ERROR_LAYER_NOT_PRESENT = -6,
    VK_ERROR_MEMORY_MAP_FAILED = -5,
    VK_ERROR_DEVICE_LOST = -4,
    VK_ERROR_INITIALIZATION_FAILED = -3,
    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
    VK_ERROR_OUT_OF_HOST_MEMORY = -1,
    VK_SUCCESS = 0,
    VK_NOT_READY = 1,
    VK_TIMEOUT = 2,
    VK_EVENT_SET = 3,
    VK_EVENT_RESET = 4,
    VK_INCOMPLETE = 5,
    VK_SUBOPTIMAL_KHR = 1000001003,
  VkDynamicState* {.size: int32.sizeof.} = enum
    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
  VkDescriptorUpdateTemplateType* {.size: int32.sizeof.} = enum
    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0
  VkObjectType* {.size: int32.sizeof.} = enum
    VK_OBJECT_TYPE_UNKNOWN = 0
    VK_OBJECT_TYPE_INSTANCE = 1
    VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2
    VK_OBJECT_TYPE_DEVICE = 3
    VK_OBJECT_TYPE_QUEUE = 4
    VK_OBJECT_TYPE_SEMAPHORE = 5
    VK_OBJECT_TYPE_COMMAND_BUFFER = 6
    VK_OBJECT_TYPE_FENCE = 7
    VK_OBJECT_TYPE_DEVICE_MEMORY = 8
    VK_OBJECT_TYPE_BUFFER = 9
    VK_OBJECT_TYPE_IMAGE = 10
    VK_OBJECT_TYPE_EVENT = 11
    VK_OBJECT_TYPE_QUERY_POOL = 12
    VK_OBJECT_TYPE_BUFFER_VIEW = 13
    VK_OBJECT_TYPE_IMAGE_VIEW = 14
    VK_OBJECT_TYPE_SHADER_MODULE = 15
    VK_OBJECT_TYPE_PIPELINE_CACHE = 16
    VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17
    VK_OBJECT_TYPE_RENDER_PASS = 18
    VK_OBJECT_TYPE_PIPELINE = 19
    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20
    VK_OBJECT_TYPE_SAMPLER = 21
    VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22
    VK_OBJECT_TYPE_DESCRIPTOR_SET = 23
    VK_OBJECT_TYPE_FRAMEBUFFER = 24
    VK_OBJECT_TYPE_COMMAND_POOL = 25
  VkQueueFlagBits* {.size: int32.sizeof.} = enum
    VK_QUEUE_GRAPHICS_BIT = 1
    VK_QUEUE_COMPUTE_BIT = 2
    VK_QUEUE_TRANSFER_BIT = 4
    VK_QUEUE_SPARSE_BINDING_BIT = 8
  VkMemoryPropertyFlagBits* {.size: int32.sizeof.} = enum
    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1
    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 2
    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 4
    VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 8
    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 16
  VkMemoryHeapFlagBits* {.size: int32.sizeof.} = enum
    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1
  VkAccessFlagBits* {.size: int32.sizeof.} = enum
    VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 1
    VK_ACCESS_INDEX_READ_BIT = 2
    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 4
    VK_ACCESS_UNIFORM_READ_BIT = 8
    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 16
    VK_ACCESS_SHADER_READ_BIT = 32
    VK_ACCESS_SHADER_WRITE_BIT = 64
    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 128
    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 256
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 512
    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 1024
    VK_ACCESS_TRANSFER_READ_BIT = 2048
    VK_ACCESS_TRANSFER_WRITE_BIT = 4096
    VK_ACCESS_HOST_READ_BIT = 8192
    VK_ACCESS_HOST_WRITE_BIT = 16384
    VK_ACCESS_MEMORY_READ_BIT = 32768
    VK_ACCESS_MEMORY_WRITE_BIT = 65536
  VkBufferUsageFlagBits* {.size: int32.sizeof.} = enum
    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001
    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002
    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004
    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008
    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010
    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020
    VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040
    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080
    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100
    VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000
  VkBufferCreateFlagBits* {.size: int32.sizeof.} = enum
    VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1
    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2
    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 4
  VkShaderStageFlagBits* {.size: int32.sizeof.} = enum
    VK_SHADER_STAGE_VERTEX_BIT = 1
    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 2
    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 4
    VK_SHADER_STAGE_GEOMETRY_BIT = 8
    VK_SHADER_STAGE_FRAGMENT_BIT = 16
    VK_SHADER_STAGE_ALL_GRAPHICS = 31
    VK_SHADER_STAGE_COMPUTE_BIT = 32
    VK_SHADER_STAGE_ALL = 2147483647
  VkImageUsageFlagBits* {.size: int32.sizeof.} = enum
    VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 1
    VK_IMAGE_USAGE_TRANSFER_DST_BIT = 2
    VK_IMAGE_USAGE_SAMPLED_BIT = 4
    VK_IMAGE_USAGE_STORAGE_BIT = 8
    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 16
    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 32
    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 64
    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 128
  VkImageCreateFlagBits* {.size: int32.sizeof.} = enum
    VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 1
    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 2
    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 4
    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 8
    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 16
  VkPipelineCreateFlagBits* {.size: int32.sizeof.} = enum
    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1
    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2
    VK_PIPELINE_CREATE_DERIVATIVE_BIT = 4
  VkColorComponentFlagBits* {.size: int32.sizeof.} = enum
    VK_COLOR_COMPONENT_R_BIT = 1
    VK_COLOR_COMPONENT_G_BIT = 2
    VK_COLOR_COMPONENT_B_BIT = 4
    VK_COLOR_COMPONENT_A_BIT = 8
  VkFenceCreateFlagBits* {.size: int32.sizeof.} = enum
    VK_FENCE_CREATE_SIGNALED_BIT = 1
  VkFormatFeatureFlagBits* {.size: int32.sizeof.} = enum
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1
    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 2
    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 4
    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 8
    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 16
    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 32
    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 64
    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 128
    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 256
    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 512
    VK_FORMAT_FEATURE_BLIT_SRC_BIT = 1024
    VK_FORMAT_FEATURE_BLIT_DST_BIT = 2048
    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4096
  VkQueryControlFlagBits* {.size: int32.sizeof.} = enum
    VK_QUERY_CONTROL_PRECISE_BIT = 1
  VkQueryResultFlagBits* {.size: int32.sizeof.} = enum
    VK_QUERY_RESULT_64_BIT = 1
    VK_QUERY_RESULT_WAIT_BIT = 2
    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 4
    VK_QUERY_RESULT_PARTIAL_BIT = 8
  VkCommandBufferUsageFlagBits* {.size: int32.sizeof.} = enum
    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1
    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 2
    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 4
  VkQueryPipelineStatisticFlagBits* {.size: int32.sizeof.} = enum
    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1
    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 2
    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 4
    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 8
    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 16
    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 32
    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 64
    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 128
    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 256
    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 512
    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1024
  VkImageAspectFlagBits* {.size: int32.sizeof.} = enum
    VK_IMAGE_ASPECT_COLOR_BIT = 1
    VK_IMAGE_ASPECT_DEPTH_BIT = 2
    VK_IMAGE_ASPECT_STENCIL_BIT = 4
    VK_IMAGE_ASPECT_METADATA_BIT = 8
  VkSparseImageFormatFlagBits* {.size: int32.sizeof.} = enum
    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1
    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 2
    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 4
  VkSparseMemoryBindFlagBits* {.size: int32.sizeof.} = enum
    VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1
  
  VkPipelineStageFlagBits* {.size: int32.sizeof.} = enum
    VK_PIPELINE_STAGE_NONE = 0 # Provided by VK_KHR_synchronization2
    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001
    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002
    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004
    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008
    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010
    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020
    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040
    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080
    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100
    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200
    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400
    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800
    VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000
    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000
    VK_PIPELINE_STAGE_HOST_BIT = 0x00004000
    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000
    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000
    VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000 # Provided by VK_NV_device_generated_commands
    VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000 # Provided by VK_EXT_conditional_rendering
    VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000 # Provided by VK_NV_mesh_shader
    VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000 # Provided by VK_NV_mesh_shader
    VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT = 0x00200000 # Provided by VK_KHR_ray_tracing_pipeline
    VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT = 0x00400000 # Provided by VK_KHR_fragment_shading_rate
    VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000 # Provided by VK_EXT_fragment_density_map
    VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000 # Provided by VK_EXT_transform_feedback
    VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT = 0x02000000 # Provided by VK_KHR_acceleration_structure
    # VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT # Provided by VK_NV_ray_tracing
    # VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT # Provided by VK_NV_shading_rate_image
    # VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT # Provided by VK_NV_ray_tracing
    
  VkCommandPoolCreateFlagBits* {.size: int32.sizeof.} = enum
    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1
    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2
  VkCommandPoolResetFlagBits* {.size: int32.sizeof.} = enum
    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1
  VkCommandBufferResetFlagBits* {.size: int32.sizeof.} = enum
    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1
  VkSampleCountFlagBits* {.size: int32.sizeof.} = enum
    VK_SAMPLE_COUNT_1_BIT = 1
    VK_SAMPLE_COUNT_2_BIT = 2
    VK_SAMPLE_COUNT_4_BIT = 4
    VK_SAMPLE_COUNT_8_BIT = 8
    VK_SAMPLE_COUNT_16_BIT = 16
    VK_SAMPLE_COUNT_32_BIT = 32
    VK_SAMPLE_COUNT_64_BIT = 64
  VkAttachmentDescriptionFlagBits* {.size: int32.sizeof.} = enum
    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1
  VkStencilFaceFlagBits* {.size: int32.sizeof.} = enum
    VK_STENCIL_FACE_FRONT_BIT = 1
    VK_STENCIL_FACE_BACK_BIT = 2
    VK_STENCIL_FACE_FRONT_AND_BACK = 3
  VkDescriptorPoolCreateFlagBits* {.size: int32.sizeof.} = enum
    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1
  VkDependencyFlagBits* {.size: int32.sizeof.} = enum
    VK_DEPENDENCY_BY_REGION_BIT = 1
  VkSemaphoreType* {.size: int32.sizeof.} = enum
    VK_SEMAPHORE_TYPE_BINARY = 0
    VK_SEMAPHORE_TYPE_TIMELINE = 1
  VkSemaphoreWaitFlagBits* {.size: int32.sizeof.} = enum
    VK_SEMAPHORE_WAIT_ANY_BIT = 1
  VkPresentModeKHR* {.size: int32.sizeof.} = enum
    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
  VkColorSpaceKHR* {.size: int32.sizeof.} = enum
    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0
  VkDisplayPlaneAlphaFlagBitsKHR* {.size: int32.sizeof.} = enum
    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 1
    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 2
    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 4
    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 8
  VkCompositeAlphaFlagBitsKHR* {.size: int32.sizeof.} = enum
    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 1
    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 2
    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 4
    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 8
  VkSurfaceTransformFlagBitsKHR* {.size: int32.sizeof.} = enum
    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 1
    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 2
    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 4
    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 8
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 16
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 32
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 64
    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 128
    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 256
  VkSwapchainImageUsageFlagBitsANDROID* {.size: int32.sizeof.} = enum
    VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 1
  VkTimeDomainEXT* {.size: int32.sizeof.} = enum
    VK_TIME_DOMAIN_DEVICE_EXT = 0
    VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1
    VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2
    VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3
  VkDebugReportFlagBitsEXT* {.size: int32.sizeof.} = enum
    VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 1
    VK_DEBUG_REPORT_WARNING_BIT_EXT = 2
    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 4
    VK_DEBUG_REPORT_ERROR_BIT_EXT = 8
    VK_DEBUG_REPORT_DEBUG_BIT_EXT = 16
  VkDebugReportObjectTypeEXT* {.size: int32.sizeof.} = enum
    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_CALLBACK_EXT_EXT = 28
    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29
    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30
    VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33
  VkRasterizationOrderAMD* {.size: int32.sizeof.} = enum
    VK_RASTERIZATION_ORDER_STRICT_AMD = 0
    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1
  VkExternalMemoryHandleTypeFlagBitsNV* {.size: int32.sizeof.} = enum
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 1
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 2
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 4
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 8
  VkExternalMemoryFeatureFlagBitsNV* {.size: int32.sizeof.} = enum
    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 1
    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 2
    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 4
  VkValidationCheckEXT* {.size: int32.sizeof.} = enum
    VK_VALIDATION_CHECK_ALL_EXT = 0
    VK_VALIDATION_CHECK_SHADERS_EXT = 1
  VkValidationFeatureEnableEXT* {.size: int32.sizeof.} = enum
    VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0
    VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1
    VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2
    VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3
    VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4
  VkValidationFeatureDisableEXT* {.size: int32.sizeof.} = enum
    VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0
    VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1
    VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2
    VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3
    VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4
    VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5
    VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6
  VkSubgroupFeatureFlagBits* {.size: int32.sizeof.} = enum
    VK_SUBGROUP_FEATURE_BASIC_BIT = 1
    VK_SUBGROUP_FEATURE_VOTE_BIT = 2
    VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 4
    VK_SUBGROUP_FEATURE_BALLOT_BIT = 8
    VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 16
    VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 32
    VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 64
    VK_SUBGROUP_FEATURE_QUAD_BIT = 128
  VkIndirectCommandsLayoutUsageFlagBitsNV* {.size: int32.sizeof.} = enum
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 1
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 2
    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 4
  VkIndirectStateFlagBitsNV* {.size: int32.sizeof.} = enum
    VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 1
  VkIndirectCommandsTokenTypeNV* {.size: int32.sizeof.} = enum
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6
    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7
  VkExternalMemoryHandleTypeFlagBits* {.size: int32.sizeof.} = enum
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 1
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 8
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 16
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 32
    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 64
  VkExternalMemoryFeatureFlagBits* {.size: int32.sizeof.} = enum
    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1
    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2
    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4
  VkExternalSemaphoreHandleTypeFlagBits* {.size: int32.sizeof.} = enum
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 1
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 8
    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 16
  VkExternalSemaphoreFeatureFlagBits* {.size: int32.sizeof.} = enum
    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1
    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2
  VkSemaphoreImportFlagBits* {.size: int32.sizeof.} = enum
    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1
  VkExternalFenceHandleTypeFlagBits* {.size: int32.sizeof.} = enum
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 1
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2
    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4
    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 8
  VkExternalFenceFeatureFlagBits* {.size: int32.sizeof.} = enum
    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1
    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2
  VkFenceImportFlagBits* {.size: int32.sizeof.} = enum
    VK_FENCE_IMPORT_TEMPORARY_BIT = 1
  VkSurfaceCounterFlagBitsEXT* {.size: int32.sizeof.} = enum
    VK_SURFACE_COUNTER_VBLANK_EXT = 1
  VkDisplayPowerStateEXT* {.size: int32.sizeof.} = enum
    VK_DISPLAY_POWER_STATE_OFF_EXT = 0
    VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1
    VK_DISPLAY_POWER_STATE_ON_EXT = 2
  VkDeviceEventTypeEXT* {.size: int32.sizeof.} = enum
    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0
  VkDisplayEventTypeEXT* {.size: int32.sizeof.} = enum
    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0
  VkPeerMemoryFeatureFlagBits* {.size: int32.sizeof.} = enum
    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 1
    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 2
    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 4
    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 8
  VkMemoryAllocateFlagBits* {.size: int32.sizeof.} = enum
    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001
    VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002
    VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004
    VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
  VkDeviceGroupPresentModeFlagBitsKHR* {.size: int32.sizeof.} = enum
    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 1
    VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 2
    VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 4
    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 8
  VkViewportCoordinateSwizzleNV* {.size: int32.sizeof.} = enum
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5
    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6
    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7
  VkDiscardRectangleModeEXT* {.size: int32.sizeof.} = enum
    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0
    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1
  VkPointClippingBehavior* {.size: int32.sizeof.} = enum
    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0
    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1
  VkSamplerReductionMode* {.size: int32.sizeof.} = enum
    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0
    VK_SAMPLER_REDUCTION_MODE_MIN = 1
    VK_SAMPLER_REDUCTION_MODE_MAX = 2
  VkTessellationDomainOrigin* {.size: int32.sizeof.} = enum
    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0
    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1
  VkSamplerYcbcrModelConversion* {.size: int32.sizeof.} = enum
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3
    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4
  VkSamplerYcbcrRange* {.size: int32.sizeof.} = enum
    VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0
    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1
  VkChromaLocation* {.size: int32.sizeof.} = enum
    VK_CHROMA_LOCATION_COSITED_EVEN = 0
    VK_CHROMA_LOCATION_MIDPOINT = 1
  VkBlendOverlapEXT* {.size: int32.sizeof.} = enum
    VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0
    VK_BLEND_OVERLAP_DISJOINT_EXT = 1
    VK_BLEND_OVERLAP_CONJOINT_EXT = 2
  VkCoverageModulationModeNV* {.size: int32.sizeof.} = enum
    VK_COVERAGE_MODULATION_MODE_NONE_NV = 0
    VK_COVERAGE_MODULATION_MODE_RGB_NV = 1
    VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2
    VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3
  VkCoverageReductionModeNV* {.size: int32.sizeof.} = enum
    VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0
    VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1
  VkValidationCacheHeaderVersionEXT* {.size: int32.sizeof.} = enum
    VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1
  VkShaderInfoTypeAMD* {.size: int32.sizeof.} = enum
    VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0
    VK_SHADER_INFO_TYPE_BINARY_AMD = 1
    VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2
  VkQueueGlobalPriorityEXT* {.size: int32.sizeof.} = enum
    VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128
    VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256
    VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512
    VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024
  VkDebugUtilsMessageSeverityFlagBitsEXT* {.size: int32.sizeof.} = enum
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 1
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 16
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 256
    VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 4096
  VkDebugUtilsMessageTypeFlagBitsEXT* {.size: int32.sizeof.} = enum
    VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 1
    VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 2
    VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 4
  VkConservativeRasterizationModeEXT* {.size: int32.sizeof.} = enum
    VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0
    VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1
    VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2
  VkDescriptorBindingFlagBits* {.size: int32.sizeof.} = enum
    VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 1
    VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 2
    VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 4
    VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 8
  VkVendorId* {.size: int32.sizeof.} = enum
    VK_VENDOR_ID_VIV = 65537
    VK_VENDOR_ID_VSI = 65538
    VK_VENDOR_ID_KAZAN = 65539
    VK_VENDOR_ID_CODEPLAY = 65540
    VK_VENDOR_ID_MESA = 65541
  VkDriverId* {.size: int32.sizeof.} = enum
    VK_DRIVER_ID_AMD_PROPRIETARY = 1
    VK_DRIVER_ID_AMD_OPEN_SOURCE = 2
    VK_DRIVER_ID_MESA_RADV = 3
    VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4
    VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5
    VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6
    VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7
    VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8
    VK_DRIVER_ID_ARM_PROPRIETARY = 9
    VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10
    VK_DRIVER_ID_GGP_PROPRIETARY = 11
    VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12
    VK_DRIVER_ID_MESA_LLVMPIPE = 13
    VK_DRIVER_ID_MOLTENVK = 14
  VkConditionalRenderingFlagBitsEXT* {.size: int32.sizeof.} = enum
    VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 1
  VkResolveModeFlagBits* {.size: int32.sizeof.} = enum
    VK_RESOLVE_MODE_NONE = 0
    VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 1
    VK_RESOLVE_MODE_AVERAGE_BIT = 2
    VK_RESOLVE_MODE_MIN_BIT = 4
    VK_RESOLVE_MODE_MAX_BIT = 8
  VkShadingRatePaletteEntryNV* {.size: int32.sizeof.} = enum
    VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0
    VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1
    VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2
    VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3
    VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10
    VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11
  VkCoarseSampleOrderTypeNV* {.size: int32.sizeof.} = enum
    VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0
    VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1
    VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2
    VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3
  VkGeometryInstanceFlagBitsKHR* {.size: int32.sizeof.} = enum
    VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 1
    VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = 2
    VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 4
    VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 8
  VkGeometryFlagBitsKHR* {.size: int32.sizeof.} = enum
    VK_GEOMETRY_OPAQUE_BIT_KHR = 1
    VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 2
  VkBuildAccelerationStructureFlagBitsKHR* {.size: int32.sizeof.} = enum
    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 1
    VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 2
    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 4
    VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 8
    VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 16
  VkCopyAccelerationStructureModeKHR* {.size: int32.sizeof.} = enum
    VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0
    VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1
    VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2
    VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3
  VkAccelerationStructureTypeKHR* {.size: int32.sizeof.} = enum
    VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0
    VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1
  VkGeometryTypeKHR* {.size: int32.sizeof.} = enum
    VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0
    VK_GEOMETRY_TYPE_AABBS_KHR = 1
  VkAccelerationStructureMemoryRequirementsTypeKHR* {.size: int32.sizeof.} = enum
    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_KHR = 0
    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_KHR = 1
    VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_KHR = 2
  VkAccelerationStructureBuildTypeKHR* {.size: int32.sizeof.} = enum
    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0
    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1
    VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2
  VkRayTracingShaderGroupTypeKHR* {.size: int32.sizeof.} = enum
    VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0
    VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1
    VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2
  VkMemoryOverallocationBehaviorAMD* {.size: int32.sizeof.} = enum
    VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0
    VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1
    VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2
  VkScopeNV* {.size: int32.sizeof.} = enum
    VK_SCOPE_DEVICE_NV = 1
    VK_SCOPE_WORKGROUP_NV = 2
    VK_SCOPE_SUBGROUP_NV = 3
    VK_SCOPE_QUEUE_FAMILY_NV = 5
  VkComponentTypeNV* {.size: int32.sizeof.} = enum
    VK_COMPONENT_TYPE_FLOAT16_NV = 0
    VK_COMPONENT_TYPE_FLOAT32_NV = 1
    VK_COMPONENT_TYPE_FLOAT64_NV = 2
    VK_COMPONENT_TYPE_SINT8_NV = 3
    VK_COMPONENT_TYPE_SINT16_NV = 4
    VK_COMPONENT_TYPE_SINT32_NV = 5
    VK_COMPONENT_TYPE_SINT64_NV = 6
    VK_COMPONENT_TYPE_UINT8_NV = 7
    VK_COMPONENT_TYPE_UINT16_NV = 8
    VK_COMPONENT_TYPE_UINT32_NV = 9
    VK_COMPONENT_TYPE_UINT64_NV = 10
  VkDeviceDiagnosticsConfigFlagBitsNV* {.size: int32.sizeof.} = enum
    VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 1
    VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 2
    VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 4
  VkPipelineCreationFeedbackFlagBitsEXT* {.size: int32.sizeof.} = enum
    VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 1
    VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 2
    VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 4
  VkFullScreenExclusiveEXT* {.size: int32.sizeof.} = enum
    VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0
    VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1
    VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2
    VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3
  VkPerformanceCounterScopeKHR* {.size: int32.sizeof.} = enum
    VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0
    VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1
    VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2
  VkPerformanceCounterUnitKHR* {.size: int32.sizeof.} = enum
    VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0
    VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1
    VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2
    VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3
    VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4
    VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5
    VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6
    VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7
    VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8
    VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9
    VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10
  VkPerformanceCounterStorageKHR* {.size: int32.sizeof.} = enum
    VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0
    VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1
    VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2
    VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3
    VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4
    VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5
  VkPerformanceCounterDescriptionFlagBitsKHR* {.size: int32.sizeof.} = enum
    VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 1
    VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 2
  VkPerformanceConfigurationTypeINTEL* {.size: int32.sizeof.} = enum
    VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0
  VkQueryPoolSamplingModeINTEL* {.size: int32.sizeof.} = enum
    VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0
  VkPerformanceOverrideTypeINTEL* {.size: int32.sizeof.} = enum
    VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0
    VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1
  VkPerformanceParameterTypeINTEL* {.size: int32.sizeof.} = enum
    VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0
    VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1
  VkPerformanceValueTypeINTEL* {.size: int32.sizeof.} = enum
    VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0
    VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1
    VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2
    VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3
    VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4
  VkShaderFloatControlsIndependence* {.size: int32.sizeof.} = enum
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1
    VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2
  VkPipelineExecutableStatisticFormatKHR* {.size: int32.sizeof.} = enum
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2
    VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3
  VkLineRasterizationModeEXT* {.size: int32.sizeof.} = enum
    VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0
    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1
    VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2
    VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3
  VkToolPurposeFlagBitsEXT* {.size: int32.sizeof.} = enum
    VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = 1
    VK_TOOL_PURPOSE_PROFILING_BIT_EXT = 2
    VK_TOOL_PURPOSE_TRACING_BIT_EXT = 4
    VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = 8
    VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = 16
# Types
type
  Display* = ptr object
  VisualID* = ptr object
  Window* = ptr object
  RROutput* = ptr object
  wl_display* = ptr object
  wl_surface* = ptr object
  HINSTANCE* = ptr object
  HWND* = ptr object
  HMONITOR* = ptr object
  HANDLE* = ptr object
  SECURITY_ATTRIBUTES* = ptr object
  DWORD* = ptr object
  LPCWSTR* = ptr object
  xcb_connection_t* = ptr object
  xcb_visualid_t* = ptr object
  xcb_window_t* = ptr object
  IDirectFB* = ptr object
  IDirectFBSurface* = ptr object
  zx_handle_t* = ptr object
  GgpStreamDescriptor* = ptr object
  GgpFrameToken* = ptr object
template vkMakeVersion*(major, minor, patch: untyped): untyped =
  (((major) shl 22) or ((minor) shl 12) or (patch))
template vkVersionMajor*(version: untyped): untyped =
  ((uint32)(version) shr 22)
template vkVersionMinor*(version: untyped): untyped =
  (((uint32)(version) shr 12) and 0x000003FF)
template vkVersionPatch*(version: untyped): untyped =
  ((uint32)(version) and 0x00000FFF)
const vkApiVersion1_0* = vkMakeVersion(1, 0, 0)
const vkApiVersion1_1* = vkMakeVersion(1, 1, 0)
const vkApiVersion1_2* = vkMakeVersion(1, 2, 0)
const vkApiVersion1_3* = vkMakeVersion(1, 3, 0)
type
  VkSampleMask* = distinct uint32
  VkBool32* = distinct uint32
  VkFlags* = distinct uint32
  VkDeviceSize* = distinct uint64
  VkDeviceAddress* = distinct uint64
  VkFramebufferCreateFlags* = distinct VkFlags
  VkQueryPoolCreateFlags* = distinct VkFlags
  VkRenderPassCreateFlags* = distinct VkFlags
  VkSamplerCreateFlags* = distinct VkFlags
  VkPipelineLayoutCreateFlags* = distinct VkFlags
  VkPipelineCacheCreateFlags* = distinct VkFlags
  VkPipelineDepthStencilStateCreateFlags* = distinct VkFlags
  VkPipelineDynamicStateCreateFlags* = distinct VkFlags
  VkPipelineColorBlendStateCreateFlags* = distinct VkFlags
  VkPipelineMultisampleStateCreateFlags* = distinct VkFlags
  VkPipelineRasterizationStateCreateFlags* = distinct VkFlags
  VkPipelineViewportStateCreateFlags* = distinct VkFlags
  VkPipelineTessellationStateCreateFlags* = distinct VkFlags
  VkPipelineInputAssemblyStateCreateFlags* = distinct VkFlags
  VkPipelineVertexInputStateCreateFlags* = distinct VkFlags
  VkPipelineShaderStageCreateFlags* = distinct VkFlags
  VkDescriptorSetLayoutCreateFlags* = distinct VkFlags
  VkBufferViewCreateFlags* = distinct VkFlags
  VkInstanceCreateFlags* = distinct VkFlags
  VkDeviceCreateFlags* = distinct VkFlags
  VkDeviceQueueCreateFlags* = distinct VkFlags
  VkQueueFlags* = distinct VkFlags
  VkMemoryPropertyFlags* = distinct VkFlags
  VkMemoryHeapFlags* = distinct VkFlags
  VkAccessFlags* = distinct VkFlags
  VkBufferUsageFlags* = distinct VkFlags
  VkBufferCreateFlags* = distinct VkFlags
  VkShaderStageFlags* = distinct VkFlags
  VkImageUsageFlags* = distinct VkFlags
  VkImageCreateFlags* = distinct VkFlags
  VkImageViewCreateFlags* = distinct VkFlags
  VkPipelineCreateFlags* = distinct VkFlags
  VkColorComponentFlags* = distinct VkFlags
  VkFenceCreateFlags* = distinct VkFlags
  VkSemaphoreCreateFlags* = distinct VkFlags
  VkFormatFeatureFlags* = distinct VkFlags
  VkQueryControlFlags* = distinct VkFlags
  VkQueryResultFlags* = distinct VkFlags
  VkShaderModuleCreateFlags* = distinct VkFlags
  VkEventCreateFlags* = distinct VkFlags
  VkCommandPoolCreateFlags* = distinct VkFlags
  VkCommandPoolResetFlags* = distinct VkFlags
  VkCommandBufferResetFlags* = distinct VkFlags
  VkCommandBufferUsageFlags* = distinct VkFlags
  VkQueryPipelineStatisticFlags* = distinct VkFlags
  VkMemoryMapFlags* = distinct VkFlags
  VkImageAspectFlags* = distinct VkFlags
  VkSparseMemoryBindFlags* = distinct VkFlags
  VkSparseImageFormatFlags* = distinct VkFlags
  VkSubpassDescriptionFlags* = distinct VkFlags
  VkPipelineStageFlags* = distinct VkFlags
  VkSampleCountFlags* = distinct VkFlags
  VkAttachmentDescriptionFlags* = distinct VkFlags
  VkStencilFaceFlags* = distinct VkFlags
  VkCullModeFlags* = distinct VkFlags
  VkDescriptorPoolCreateFlags* = distinct VkFlags
  VkDescriptorPoolResetFlags* = distinct VkFlags
  VkDependencyFlags* = distinct VkFlags
  VkSubgroupFeatureFlags* = distinct VkFlags
  VkIndirectCommandsLayoutUsageFlagsNV* = distinct VkFlags
  VkIndirectStateFlagsNV* = distinct VkFlags
  VkGeometryFlagsKHR* = distinct VkFlags
  VkGeometryFlagsNV* = VkGeometryFlagsKHR
  VkGeometryInstanceFlagsKHR* = distinct VkFlags
  VkGeometryInstanceFlagsNV* = VkGeometryInstanceFlagsKHR
  VkBuildAccelerationStructureFlagsKHR* = distinct VkFlags
  VkBuildAccelerationStructureFlagsNV* = VkBuildAccelerationStructureFlagsKHR
  VkPrivateDataSlotCreateFlagsEXT* = distinct VkFlags
  VkDescriptorUpdateTemplateCreateFlags* = distinct VkFlags
  VkDescriptorUpdateTemplateCreateFlagsKHR* = VkDescriptorUpdateTemplateCreateFlags
  VkPipelineCreationFeedbackFlagsEXT* = distinct VkFlags
  VkPerformanceCounterDescriptionFlagsKHR* = distinct VkFlags
  VkAcquireProfilingLockFlagsKHR* = distinct VkFlags
  VkSemaphoreWaitFlags* = distinct VkFlags
  VkSemaphoreWaitFlagsKHR* = VkSemaphoreWaitFlags
  VkPipelineCompilerControlFlagsAMD* = distinct VkFlags
  VkShaderCorePropertiesFlagsAMD* = distinct VkFlags
  VkDeviceDiagnosticsConfigFlagsNV* = distinct VkFlags
  VkCompositeAlphaFlagsKHR* = distinct VkFlags
  VkDisplayPlaneAlphaFlagsKHR* = distinct VkFlags
  VkSurfaceTransformFlagsKHR* = distinct VkFlags
  VkSwapchainCreateFlagsKHR* = distinct VkFlags
  VkDisplayModeCreateFlagsKHR* = distinct VkFlags
  VkDisplaySurfaceCreateFlagsKHR* = distinct VkFlags
  VkAndroidSurfaceCreateFlagsKHR* = distinct VkFlags
  VkViSurfaceCreateFlagsNN* = distinct VkFlags
  VkWaylandSurfaceCreateFlagsKHR* = distinct VkFlags
  VkWin32SurfaceCreateFlagsKHR* = distinct VkFlags
  VkXlibSurfaceCreateFlagsKHR* = distinct VkFlags
  VkXcbSurfaceCreateFlagsKHR* = distinct VkFlags
  VkDirectFBSurfaceCreateFlagsEXT* = distinct VkFlags
  VkIOSSurfaceCreateFlagsMVK* = distinct VkFlags
  VkMacOSSurfaceCreateFlagsMVK* = distinct VkFlags
  VkMetalSurfaceCreateFlagsEXT* = distinct VkFlags
  VkImagePipeSurfaceCreateFlagsFUCHSIA* = distinct VkFlags
  VkStreamDescriptorSurfaceCreateFlagsGGP* = distinct VkFlags
  VkHeadlessSurfaceCreateFlagsEXT* = distinct VkFlags
  VkPeerMemoryFeatureFlags* = distinct VkFlags
  VkPeerMemoryFeatureFlagsKHR* = VkPeerMemoryFeatureFlags
  VkMemoryAllocateFlags* = distinct VkFlags
  VkMemoryAllocateFlagsKHR* = VkMemoryAllocateFlags
  VkDeviceGroupPresentModeFlagsKHR* = distinct VkFlags
  VkDebugReportFlagsEXT* = distinct VkFlags
  VkCommandPoolTrimFlags* = distinct VkFlags
  VkCommandPoolTrimFlagsKHR* = VkCommandPoolTrimFlags
  VkExternalMemoryHandleTypeFlagsNV* = distinct VkFlags
  VkExternalMemoryFeatureFlagsNV* = distinct VkFlags
  VkExternalMemoryHandleTypeFlags* = distinct VkFlags
  VkExternalMemoryHandleTypeFlagsKHR* = VkExternalMemoryHandleTypeFlags
  VkExternalMemoryFeatureFlags* = distinct VkFlags
  VkExternalMemoryFeatureFlagsKHR* = VkExternalMemoryFeatureFlags
  VkExternalSemaphoreHandleTypeFlags* = distinct VkFlags
  VkExternalSemaphoreHandleTypeFlagsKHR* = VkExternalSemaphoreHandleTypeFlags
  VkExternalSemaphoreFeatureFlags* = distinct VkFlags
  VkExternalSemaphoreFeatureFlagsKHR* = VkExternalSemaphoreFeatureFlags
  VkSemaphoreImportFlags* = distinct VkFlags
  VkSemaphoreImportFlagsKHR* = VkSemaphoreImportFlags
  VkExternalFenceHandleTypeFlags* = distinct VkFlags
  VkExternalFenceHandleTypeFlagsKHR* = VkExternalFenceHandleTypeFlags
  VkExternalFenceFeatureFlags* = distinct VkFlags
  VkExternalFenceFeatureFlagsKHR* = VkExternalFenceFeatureFlags
  VkFenceImportFlags* = distinct VkFlags
  VkFenceImportFlagsKHR* = VkFenceImportFlags
  VkSurfaceCounterFlagsEXT* = distinct VkFlags
  VkPipelineViewportSwizzleStateCreateFlagsNV* = distinct VkFlags
  VkPipelineDiscardRectangleStateCreateFlagsEXT* = distinct VkFlags
  VkPipelineCoverageToColorStateCreateFlagsNV* = distinct VkFlags
  VkPipelineCoverageModulationStateCreateFlagsNV* = distinct VkFlags
  VkPipelineCoverageReductionStateCreateFlagsNV* = distinct VkFlags
  VkValidationCacheCreateFlagsEXT* = distinct VkFlags
  VkDebugUtilsMessageSeverityFlagsEXT* = distinct VkFlags
  VkDebugUtilsMessageTypeFlagsEXT* = distinct VkFlags
  VkDebugUtilsMessengerCreateFlagsEXT* = distinct VkFlags
  VkDebugUtilsMessengerCallbackDataFlagsEXT* = distinct VkFlags
  VkPipelineRasterizationConservativeStateCreateFlagsEXT* = distinct VkFlags
  VkDescriptorBindingFlags* = distinct VkFlags
  VkDescriptorBindingFlagsEXT* = VkDescriptorBindingFlags
  VkConditionalRenderingFlagsEXT* = distinct VkFlags
  VkResolveModeFlags* = distinct VkFlags
  VkResolveModeFlagsKHR* = VkResolveModeFlags
  VkPipelineRasterizationStateStreamCreateFlagsEXT* = distinct VkFlags
  VkPipelineRasterizationDepthClipStateCreateFlagsEXT* = distinct VkFlags
  VkSwapchainImageUsageFlagsANDROID* = distinct VkFlags
  VkToolPurposeFlagsEXT* = distinct VkFlags
  VkInstance* = distinct VkHandle
  VkPhysicalDevice* = distinct VkHandle
  VkDevice* = distinct VkHandle
  VkQueue* = distinct VkHandle
  VkCommandBuffer* = distinct VkHandle
  VkDeviceMemory* = distinct VkNonDispatchableHandle
  VkCommandPool* = distinct VkNonDispatchableHandle
  VkBuffer* = distinct VkNonDispatchableHandle
  VkBufferView* = distinct VkNonDispatchableHandle
  VkImage* = distinct VkNonDispatchableHandle
  VkImageView* = distinct VkNonDispatchableHandle
  VkShaderModule* = distinct VkNonDispatchableHandle
  VkPipeline* = distinct VkNonDispatchableHandle
  VkPipelineLayout* = distinct VkNonDispatchableHandle
  VkSampler* = distinct VkNonDispatchableHandle
  VkDescriptorSet* = distinct VkNonDispatchableHandle
  VkDescriptorSetLayout* = distinct VkNonDispatchableHandle
  VkDescriptorPool* = distinct VkNonDispatchableHandle
  VkFence* = distinct VkNonDispatchableHandle
  VkSemaphore* = distinct VkNonDispatchableHandle
  VkEvent* = distinct VkNonDispatchableHandle
  VkQueryPool* = distinct VkNonDispatchableHandle
  VkFramebuffer* = distinct VkNonDispatchableHandle
  VkRenderPass* = distinct VkNonDispatchableHandle
  VkPipelineCache* = distinct VkNonDispatchableHandle
  VkIndirectCommandsLayoutNV* = distinct VkNonDispatchableHandle
  VkDescriptorUpdateTemplate* = distinct VkNonDispatchableHandle
  VkDescriptorUpdateTemplateKHR* = VkDescriptorUpdateTemplate
  VkSamplerYcbcrConversion* = distinct VkNonDispatchableHandle
  VkSamplerYcbcrConversionKHR* = VkSamplerYcbcrConversion
  VkValidationCacheEXT* = distinct VkNonDispatchableHandle
  VkAccelerationStructureKHR* = distinct VkNonDispatchableHandle
  VkAccelerationStructureNV* = VkAccelerationStructureKHR
  VkPerformanceConfigurationINTEL* = distinct VkNonDispatchableHandle
  VkDeferredOperationKHR* = distinct VkNonDispatchableHandle
  VkPrivateDataSlotEXT* = distinct VkNonDispatchableHandle
  VkDisplayKHR* = distinct VkNonDispatchableHandle
  VkDisplayModeKHR* = distinct VkNonDispatchableHandle
  VkSurfaceKHR* = distinct VkNonDispatchableHandle
  VkSwapchainKHR* = distinct VkNonDispatchableHandle
  VkDebugReportCallbackEXT* = distinct VkNonDispatchableHandle
  VkDebugUtilsMessengerEXT* = distinct VkNonDispatchableHandle
  VkDescriptorUpdateTemplateTypeKHR* = VkDescriptorUpdateTemplateType
  VkPointClippingBehaviorKHR* = VkPointClippingBehavior
  VkResolveModeFlagBitsKHR* = VkResolveModeFlagBits
  VkDescriptorBindingFlagBitsEXT* = VkDescriptorBindingFlagBits
  VkSemaphoreTypeKHR* = VkSemaphoreType
  VkGeometryFlagBitsNV* = VkGeometryFlagBitsKHR
  VkGeometryInstanceFlagBitsNV* = VkGeometryInstanceFlagBitsKHR
  VkBuildAccelerationStructureFlagBitsNV* = VkBuildAccelerationStructureFlagBitsKHR
  VkCopyAccelerationStructureModeNV* = VkCopyAccelerationStructureModeKHR
  VkAccelerationStructureTypeNV* = VkAccelerationStructureTypeKHR
  VkGeometryTypeNV* = VkGeometryTypeKHR
  VkRayTracingShaderGroupTypeNV* = VkRayTracingShaderGroupTypeKHR
  VkAccelerationStructureMemoryRequirementsTypeNV* = VkAccelerationStructureMemoryRequirementsTypeKHR
  VkSemaphoreWaitFlagBitsKHR* = VkSemaphoreWaitFlagBits
  VkExternalMemoryHandleTypeFlagBitsKHR* = VkExternalMemoryHandleTypeFlagBits
  VkExternalMemoryFeatureFlagBitsKHR* = VkExternalMemoryFeatureFlagBits
  VkExternalSemaphoreHandleTypeFlagBitsKHR* = VkExternalSemaphoreHandleTypeFlagBits
  VkExternalSemaphoreFeatureFlagBitsKHR* = VkExternalSemaphoreFeatureFlagBits
  VkSemaphoreImportFlagBitsKHR* = VkSemaphoreImportFlagBits
  VkExternalFenceHandleTypeFlagBitsKHR* = VkExternalFenceHandleTypeFlagBits
  VkExternalFenceFeatureFlagBitsKHR* = VkExternalFenceFeatureFlagBits
  VkFenceImportFlagBitsKHR* = VkFenceImportFlagBits
  VkPeerMemoryFeatureFlagBitsKHR* = VkPeerMemoryFeatureFlagBits
  VkMemoryAllocateFlagBitsKHR* = VkMemoryAllocateFlagBits
  VkTessellationDomainOriginKHR* = VkTessellationDomainOrigin
  VkSamplerYcbcrModelConversionKHR* = VkSamplerYcbcrModelConversion
  VkSamplerYcbcrRangeKHR* = VkSamplerYcbcrRange
  VkChromaLocationKHR* = VkChromaLocation
  VkSamplerReductionModeEXT* = VkSamplerReductionMode
  VkShaderFloatControlsIndependenceKHR* = VkShaderFloatControlsIndependence
  VkDriverIdKHR* = VkDriverId
  PFN_vkInternalAllocationNotification* = proc(pUserData: pointer; size: csize_t; allocationType: VkInternalAllocationType; allocationScope: VkSystemAllocationScope) {.cdecl.}
  PFN_vkInternalFreeNotification* = proc(pUserData: pointer; size: csize_t; allocationType: VkInternalAllocationType; allocationScope: VkSystemAllocationScope) {.cdecl.}
  PFN_vkReallocationFunction* = proc(pUserData: pointer; pOriginal: pointer; size: csize_t; alignment: csize_t; allocationScope: VkSystemAllocationScope): pointer {.cdecl.}
  PFN_vkAllocationFunction* = proc(pUserData: pointer; size: csize_t; alignment: csize_t; allocationScope: VkSystemAllocationScope): pointer {.cdecl.}
  PFN_vkFreeFunction* = proc(pUserData: pointer; pMemory: pointer) {.cdecl.}
  PFN_vkVoidFunction* = proc() {.cdecl.}
  PFN_vkDebugReportCallbackEXT* = proc(flags: VkDebugReportFlagsEXT; objectType: VkDebugReportObjectTypeEXT; cbObject: uint64; location: csize_t; messageCode:  int32; pLayerPrefix: cstring; pMessage: cstring; pUserData: pointer): VkBool32 {.cdecl.}
  PFN_vkDebugUtilsMessengerCallbackEXT* = proc(messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: VkDebugUtilsMessengerCallbackDataEXT, userData: pointer): VkBool32 {.cdecl.}
  VkOffset2D* = object
    x*: int32
    y*: int32
  VkOffset3D* = object
    x*: int32
    y*: int32
    z*: int32
  VkExtent2D* = object
    width*: uint32
    height*: uint32
  VkExtent3D* = object
    width*: uint32
    height*: uint32
    depth*: uint32
  VkViewport* = object
    x*: float32
    y*: float32
    width*: float32
    height*: float32
    minDepth*: float32
    maxDepth*: float32
  VkRect2D* = object
    offset*: VkOffset2D
    extent*: VkExtent2D
  VkClearRect* = object
    rect*: VkRect2D
    baseArrayLayer*: uint32
    layerCount*: uint32
  VkComponentMapping* = object
    r*: VkComponentSwizzle
    g*: VkComponentSwizzle
    b*: VkComponentSwizzle
    a*: VkComponentSwizzle
  VkPhysicalDeviceProperties* = object
    apiVersion*: uint32
    driverVersion*: uint32
    vendorID*: uint32
    deviceID*: uint32
    deviceType*: VkPhysicalDeviceType
    deviceName*: array[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, char]
    pipelineCacheUUID*: array[VK_UUID_SIZE, uint8]
    limits*: VkPhysicalDeviceLimits
    sparseProperties*: VkPhysicalDeviceSparseProperties
  VkExtensionProperties* = object
    extensionName*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
    specVersion*: uint32
  VkLayerProperties* = object
    layerName*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
    specVersion*: uint32
    implementationVersion*: uint32
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]
  VkApplicationInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    pApplicationName*: cstring
    applicationVersion*: uint32
    pEngineName*: cstring
    engineVersion*: uint32
    apiVersion*: uint32
  VkAllocationCallbacks* = object
    pUserData*: pointer
    pfnAllocation*: PFN_vkAllocationFunction
    pfnReallocation*: PFN_vkReallocationFunction
    pfnFree*: PFN_vkFreeFunction
    pfnInternalAllocation*: PFN_vkInternalAllocationNotification
    pfnInternalFree*: PFN_vkInternalFreeNotification
  VkDeviceQueueCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDeviceQueueCreateFlags
    queueFamilyIndex*: uint32
    queueCount*: uint32
    pQueuePriorities*: ptr float32
  VkDeviceCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDeviceCreateFlags
    queueCreateInfoCount*: uint32
    pQueueCreateInfos*: ptr VkDeviceQueueCreateInfo
    enabledLayerCount*: uint32
    ppEnabledLayerNames*: cstringArray
    enabledExtensionCount*: uint32
    ppEnabledExtensionNames*: cstringArray
    pEnabledFeatures*: ptr VkPhysicalDeviceFeatures
  VkInstanceCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkInstanceCreateFlags
    pApplicationInfo*: ptr VkApplicationInfo
    enabledLayerCount*: uint32
    ppEnabledLayerNames*: cstringArray
    enabledExtensionCount*: uint32
    ppEnabledExtensionNames*: cstringArray
  VkQueueFamilyProperties* = object
    queueFlags*: VkQueueFlags
    queueCount*: uint32
    timestampValidBits*: uint32
    minImageTransferGranularity*: VkExtent3D
  VkPhysicalDeviceMemoryProperties* = object
    memoryTypeCount*: uint32
    memoryTypes*: array[VK_MAX_MEMORY_TYPES, VkMemoryType]
    memoryHeapCount*: uint32
    memoryHeaps*: array[VK_MAX_MEMORY_HEAPS, VkMemoryHeap]
  VkMemoryAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    allocationSize*: VkDeviceSize
    memoryTypeIndex*: uint32
  VkMemoryRequirements* = object
    size*: VkDeviceSize
    alignment*: VkDeviceSize
    memoryTypeBits*: uint32
  VkSparseImageFormatProperties* = object
    aspectMask*: VkImageAspectFlags
    imageGranularity*: VkExtent3D
    flags*: VkSparseImageFormatFlags
  VkSparseImageMemoryRequirements* = object
    formatProperties*: VkSparseImageFormatProperties
    imageMipTailFirstLod*: uint32
    imageMipTailSize*: VkDeviceSize
    imageMipTailOffset*: VkDeviceSize
    imageMipTailStride*: VkDeviceSize
  VkMemoryType* = object
    propertyFlags*: VkMemoryPropertyFlags
    heapIndex*: uint32
  VkMemoryHeap* = object
    size*: VkDeviceSize
    flags*: VkMemoryHeapFlags
  VkMappedMemoryRange* = object
    sType*: VkStructureType
    pNext*: pointer
    memory*: VkDeviceMemory
    offset*: VkDeviceSize
    size*: VkDeviceSize
  VkFormatProperties* = object
    linearTilingFeatures*: VkFormatFeatureFlags
    optimalTilingFeatures*: VkFormatFeatureFlags
    bufferFeatures*: VkFormatFeatureFlags
  VkImageFormatProperties* = object
    maxExtent*: VkExtent3D
    maxMipLevels*: uint32
    maxArrayLayers*: uint32
    sampleCounts*: VkSampleCountFlags
    maxResourceSize*: VkDeviceSize
  VkDescriptorBufferInfo* = object
    buffer*: VkBuffer
    offset*: VkDeviceSize
    range*: VkDeviceSize
  VkDescriptorImageInfo* = object
    sampler*: VkSampler
    imageView*: VkImageView
    imageLayout*: VkImageLayout
  VkWriteDescriptorSet* = object
    sType*: VkStructureType
    pNext*: pointer
    dstSet*: VkDescriptorSet
    dstBinding*: uint32
    dstArrayElement*: uint32
    descriptorCount*: uint32
    descriptorType*: VkDescriptorType
    pImageInfo*: ptr VkDescriptorImageInfo
    pBufferInfo*: ptr ptr VkDescriptorBufferInfo
    pTexelBufferView*: ptr VkBufferView
  VkCopyDescriptorSet* = object
    sType*: VkStructureType
    pNext*: pointer
    srcSet*: VkDescriptorSet
    srcBinding*: uint32
    srcArrayElement*: uint32
    dstSet*: VkDescriptorSet
    dstBinding*: uint32
    dstArrayElement*: uint32
    descriptorCount*: uint32
  VkBufferCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkBufferCreateFlags
    size*: VkDeviceSize
    usage*: VkBufferUsageFlags
    sharingMode*: VkSharingMode
    queueFamilyIndexCount*: uint32
    pQueueFamilyIndices*: ptr uint32
  VkBufferViewCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkBufferViewCreateFlags
    buffer*: VkBuffer
    format*: VkFormat
    offset*: VkDeviceSize
    range*: VkDeviceSize
  VkImageSubresource* = object
    aspectMask*: VkImageAspectFlags
    mipLevel*: uint32
    arrayLayer*: uint32
  VkImageSubresourceLayers* = object
    aspectMask*: VkImageAspectFlags
    mipLevel*: uint32
    baseArrayLayer*: uint32
    layerCount*: uint32
  VkImageSubresourceRange* = object
    aspectMask*: VkImageAspectFlags
    baseMipLevel*: uint32
    levelCount*: uint32
    baseArrayLayer*: uint32
    layerCount*: uint32
  VkMemoryBarrier* = object
    sType*: VkStructureType
    pNext*: pointer
    srcAccessMask*: VkAccessFlags
    dstAccessMask*: VkAccessFlags
  VkBufferMemoryBarrier* = object
    sType*: VkStructureType
    pNext*: pointer
    srcAccessMask*: VkAccessFlags
    dstAccessMask*: VkAccessFlags
    srcQueueFamilyIndex*: uint32
    dstQueueFamilyIndex*: uint32
    buffer*: VkBuffer
    offset*: VkDeviceSize
    size*: VkDeviceSize
  VkImageMemoryBarrier* = object
    sType*: VkStructureType
    pNext*: pointer
    srcAccessMask*: VkAccessFlags
    dstAccessMask*: VkAccessFlags
    oldLayout*: VkImageLayout
    newLayout*: VkImageLayout
    srcQueueFamilyIndex*: uint32
    dstQueueFamilyIndex*: uint32
    image*: VkImage
    subresourceRange*: VkImageSubresourceRange
  VkImageCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkImageCreateFlags
    imageType*: VkImageType
    format*: VkFormat
    extent*: VkExtent3D
    mipLevels*: uint32
    arrayLayers*: uint32
    samples*: VkSampleCountFlagBits
    tiling*: VkImageTiling
    usage*: VkImageUsageFlags
    sharingMode*: VkSharingMode
    queueFamilyIndexCount*: uint32
    pQueueFamilyIndices*: ptr uint32
    initialLayout*: VkImageLayout
  VkSubresourceLayout* = object
    offset*: VkDeviceSize
    size*: VkDeviceSize
    rowPitch*: VkDeviceSize
    arrayPitch*: VkDeviceSize
    depthPitch*: VkDeviceSize
  VkImageViewCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkImageViewCreateFlags
    image*: VkImage
    viewType*: VkImageViewType
    format*: VkFormat
    components*: VkComponentMapping
    subresourceRange*: VkImageSubresourceRange
  VkBufferCopy* = object
    srcOffset*: VkDeviceSize
    dstOffset*: VkDeviceSize
    size*: VkDeviceSize
  VkSparseMemoryBind* = object
    resourceOffset*: VkDeviceSize
    size*: VkDeviceSize
    memory*: VkDeviceMemory
    memoryOffset*: VkDeviceSize
    flags*: VkSparseMemoryBindFlags
  VkSparseImageMemoryBind* = object
    subresource*: VkImageSubresource
    offset*: VkOffset3D
    extent*: VkExtent3D
    memory*: VkDeviceMemory
    memoryOffset*: VkDeviceSize
    flags*: VkSparseMemoryBindFlags
  VkSparseBufferMemoryBindInfo* = object
    buffer*: VkBuffer
    bindCount*: uint32
    pBinds*: ptr VkSparseMemoryBind
  VkSparseImageOpaqueMemoryBindInfo* = object
    image*: VkImage
    bindCount*: uint32
    pBinds*: ptr VkSparseMemoryBind
  VkSparseImageMemoryBindInfo* = object
    image*: VkImage
    bindCount*: uint32
    pBinds*: ptr VkSparseImageMemoryBind
  VkBindSparseInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreCount*: uint32
    pWaitSemaphores*: ptr VkSemaphore
    bufferBindCount*: uint32
    pBufferBinds*: ptr VkSparseBufferMemoryBindInfo
    imageOpaqueBindCount*: uint32
    pImageOpaqueBinds*: ptr VkSparseImageOpaqueMemoryBindInfo
    imageBindCount*: uint32
    pImageBinds*: ptr VkSparseImageMemoryBindInfo
    signalSemaphoreCount*: uint32
    pSignalSemaphores*: ptr VkSemaphore
  VkImageCopy* = object
    srcSubresource*: VkImageSubresourceLayers
    srcOffset*: VkOffset3D
    dstSubresource*: VkImageSubresourceLayers
    dstOffset*: VkOffset3D
    extent*: VkExtent3D
  VkImageBlit* = object
    srcSubresource*: VkImageSubresourceLayers
    srcOffsets*: array[2, VkOffset3D]
    dstSubresource*: VkImageSubresourceLayers
    dstOffsets*: array[2, VkOffset3D]
  VkBufferImageCopy* = object
    bufferOffset*: VkDeviceSize
    bufferRowLength*: uint32
    bufferImageHeight*: uint32
    imageSubresource*: VkImageSubresourceLayers
    imageOffset*: VkOffset3D
    imageExtent*: VkExtent3D
  VkImageResolve* = object
    srcSubresource*: VkImageSubresourceLayers
    srcOffset*: VkOffset3D
    dstSubresource*: VkImageSubresourceLayers
    dstOffset*: VkOffset3D
    extent*: VkExtent3D
  VkShaderModuleCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkShaderModuleCreateFlags
    codeSize*: uint
    pCode*: ptr uint32
  VkDescriptorSetLayoutBinding* = object
    binding*: uint32
    descriptorType*: VkDescriptorType
    descriptorCount*: uint32
    stageFlags*: VkShaderStageFlags
    pImmutableSamplers*: ptr VkSampler
  VkDescriptorSetLayoutCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDescriptorSetLayoutCreateFlags
    bindingCount*: uint32
    pBindings*: ptr VkDescriptorSetLayoutBinding
  VkDescriptorPoolSize* = object
    typee*: VkDescriptorType
    descriptorCount*: uint32
  VkDescriptorPoolCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDescriptorPoolCreateFlags
    maxSets*: uint32
    poolSizeCount*: uint32
    pPoolSizes*: ptr VkDescriptorPoolSize
  VkDescriptorSetAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    descriptorPool*: VkDescriptorPool
    descriptorSetCount*: uint32
    pSetLayouts*: ptr VkDescriptorSetLayout
  VkSpecializationMapEntry* = object
    constantID*: uint32
    offset*: uint32
    size*: uint
  VkSpecializationInfo* = object
    mapEntryCount*: uint32
    pMapEntries*: ptr VkSpecializationMapEntry
    dataSize*: uint
    pData*: pointer
  VkPipelineShaderStageCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineShaderStageCreateFlags
    stage*: VkShaderStageFlagBits
    module*: VkShaderModule
    pName*: cstring
    pSpecializationInfo*: ptr VkSpecializationInfo
  VkComputePipelineCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCreateFlags
    stage*: VkPipelineShaderStageCreateInfo
    layout*: VkPipelineLayout
    basePipelineHandle*: VkPipeline
    basePipelineIndex*: int32
  VkVertexInputBindingDescription* = object
    binding*: uint32
    stride*: uint32
    inputRate*: VkVertexInputRate
  VkVertexInputAttributeDescription* = object
    location*: uint32
    binding*: uint32
    format*: VkFormat
    offset*: uint32
  VkPipelineVertexInputStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineVertexInputStateCreateFlags
    vertexBindingDescriptionCount*: uint32
    pVertexBindingDescriptions*: ptr VkVertexInputBindingDescription
    vertexAttributeDescriptionCount*: uint32
    pVertexAttributeDescriptions*: ptr VkVertexInputAttributeDescription
  VkPipelineInputAssemblyStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineInputAssemblyStateCreateFlags
    topology*: VkPrimitiveTopology
    primitiveRestartEnable*: VkBool32
  VkPipelineTessellationStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineTessellationStateCreateFlags
    patchControlPoints*: uint32
  VkPipelineViewportStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineViewportStateCreateFlags
    viewportCount*: uint32
    pViewports*: ptr VkViewport
    scissorCount*: uint32
    pScissors*: ptr VkRect2D
  VkPipelineRasterizationStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineRasterizationStateCreateFlags
    depthClampEnable*: VkBool32
    rasterizerDiscardEnable*: VkBool32
    polygonMode*: VkPolygonMode
    cullMode*: VkCullModeFlags
    frontFace*: VkFrontFace
    depthBiasEnable*: VkBool32
    depthBiasConstantFactor*: float32
    depthBiasClamp*: float32
    depthBiasSlopeFactor*: float32
    lineWidth*: float32
  VkPipelineMultisampleStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineMultisampleStateCreateFlags
    rasterizationSamples*: VkSampleCountFlagBits
    sampleShadingEnable*: VkBool32
    minSampleShading*: float32
    pSampleMask*: ptr VkSampleMask
    alphaToCoverageEnable*: VkBool32
    alphaToOneEnable*: VkBool32
  VkPipelineColorBlendAttachmentState* = object
    blendEnable*: VkBool32
    srcColorBlendFactor*: VkBlendFactor
    dstColorBlendFactor*: VkBlendFactor
    colorBlendOp*: VkBlendOp
    srcAlphaBlendFactor*: VkBlendFactor
    dstAlphaBlendFactor*: VkBlendFactor
    alphaBlendOp*: VkBlendOp
    colorWriteMask*: VkColorComponentFlags
  VkPipelineColorBlendStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineColorBlendStateCreateFlags
    logicOpEnable*: VkBool32
    logicOp*: VkLogicOp
    attachmentCount*: uint32
    pAttachments*: ptr VkPipelineColorBlendAttachmentState
    blendConstants*: array[4, float32]
  VkPipelineDynamicStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineDynamicStateCreateFlags
    dynamicStateCount*: uint32
    pDynamicStates*: ptr VkDynamicState
  VkStencilOpState* = object
    failOp*: VkStencilOp
    passOp*: VkStencilOp
    depthFailOp*: VkStencilOp
    compareOp*: VkCompareOp
    compareMask*: uint32
    writeMask*: uint32
    reference*: uint32
  VkPipelineDepthStencilStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineDepthStencilStateCreateFlags
    depthTestEnable*: VkBool32
    depthWriteEnable*: VkBool32
    depthCompareOp*: VkCompareOp
    depthBoundsTestEnable*: VkBool32
    stencilTestEnable*: VkBool32
    front*: VkStencilOpState
    back*: VkStencilOpState
    minDepthBounds*: float32
    maxDepthBounds*: float32
  VkGraphicsPipelineCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCreateFlags
    stageCount*: uint32
    pStages*: ptr VkPipelineShaderStageCreateInfo
    pVertexInputState*: ptr VkPipelineVertexInputStateCreateInfo
    pInputAssemblyState*: ptr VkPipelineInputAssemblyStateCreateInfo
    pTessellationState*: ptr VkPipelineTessellationStateCreateInfo
    pViewportState*: ptr VkPipelineViewportStateCreateInfo
    pRasterizationState*: ptr VkPipelineRasterizationStateCreateInfo
    pMultisampleState*: ptr VkPipelineMultisampleStateCreateInfo
    pDepthStencilState*: ptr VkPipelineDepthStencilStateCreateInfo
    pColorBlendState*: ptr VkPipelineColorBlendStateCreateInfo
    pDynamicState*: ptr VkPipelineDynamicStateCreateInfo
    layout*: VkPipelineLayout
    render_pass*: VkRenderPass
    subpass*: uint32
    basePipelineHandle*: VkPipeline
    basePipelineIndex*: int32
  VkPipelineCacheCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCacheCreateFlags
    initialDataSize*: uint
    pInitialData*: pointer
  VkPushConstantRange* = object
    stageFlags*: VkShaderStageFlags
    offset*: uint32
    size*: uint32
  VkPipelineLayoutCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineLayoutCreateFlags
    setLayoutCount*: uint32
    pSetLayouts*: ptr VkDescriptorSetLayout
    pushConstantRangeCount*: uint32
    pPushConstantRanges*: ptr VkPushConstantRange
  VkSamplerCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkSamplerCreateFlags
    magFilter*: VkFilter
    minFilter*: VkFilter
    mipmapMode*: VkSamplerMipmapMode
    addressModeU*: VkSamplerAddressMode
    addressModeV*: VkSamplerAddressMode
    addressModeW*: VkSamplerAddressMode
    mipLodBias*: float32
    anisotropyEnable*: VkBool32
    maxAnisotropy*: float32
    compareEnable*: VkBool32
    compareOp*: VkCompareOp
    minLod*: float32
    maxLod*: float32
    borderColor*: VkBorderColor
    unnormalizedCoordinates*: VkBool32
  VkCommandPoolCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkCommandPoolCreateFlags
    queueFamilyIndex*: uint32
  VkCommandBufferAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    commandPool*: VkCommandPool
    level*: VkCommandBufferLevel
    commandBufferCount*: uint32
  VkCommandBufferInheritanceInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    render_pass*: VkRenderPass
    subpass*: uint32
    framebuffer*: VkFramebuffer
    occlusionQueryEnable*: VkBool32
    queryFlags*: VkQueryControlFlags
    pipelineStatistics*: VkQueryPipelineStatisticFlags
  VkCommandBufferBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkCommandBufferUsageFlags
    pInheritanceInfo*: ptr VkCommandBufferInheritanceInfo
  VkRenderPassBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    render_pass*: VkRenderPass
    framebuffer*: VkFramebuffer
    renderArea*: VkRect2D
    clearValueCount*: uint32
    pClearValues*: ptr VkClearValue
  VkClearColorValue* {.union.} = object
    float32*: array[4, float32]
    int32*: array[4, int32]
    uint32*: array[4, uint32]
  VkClearDepthStencilValue* = object
    depth*: float32
    stencil*: uint32
  VkClearValue* {.union.} = object
    color*: VkClearColorValue
    depth_stencil*: VkClearDepthStencilValue
  VkClearAttachment* = object
    aspectMask*: VkImageAspectFlags
    colorAttachment*: uint32
    clearValue*: VkClearValue
  VkAttachmentDescription* = object
    flags*: VkAttachmentDescriptionFlags
    format*: VkFormat
    samples*: VkSampleCountFlagBits
    loadOp*: VkAttachmentLoadOp
    storeOp*: VkAttachmentStoreOp
    stencilLoadOp*: VkAttachmentLoadOp
    stencilStoreOp*: VkAttachmentStoreOp
    initialLayout*: VkImageLayout
    finalLayout*: VkImageLayout
  VkAttachmentReference* = object
    attachment*: uint32
    layout*: VkImageLayout
  VkSubpassDescription* = object
    flags*: VkSubpassDescriptionFlags
    pipelineBindPoint*: VkPipelineBindPoint
    inputAttachmentCount*: uint32
    pInputAttachments*: ptr VkAttachmentReference
    colorAttachmentCount*: uint32
    pColorAttachments*: ptr VkAttachmentReference
    pResolveAttachments*: ptr VkAttachmentReference
    pDepthStencilAttachment*: ptr VkAttachmentReference
    preserveAttachmentCount*: uint32
    pPreserveAttachments*: ptr uint32
  VkSubpassDependency* = object
    srcSubpass*: uint32
    dstSubpass*: uint32
    srcStageMask*: VkPipelineStageFlags
    dstStageMask*: VkPipelineStageFlags
    srcAccessMask*: VkAccessFlags
    dstAccessMask*: VkAccessFlags
    dependencyFlags*: VkDependencyFlags
  VkRenderPassCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkRenderPassCreateFlags
    attachmentCount*: uint32
    pAttachments*: ptr VkAttachmentDescription
    subpassCount*: uint32
    pSubpasses*: ptr VkSubpassDescription
    dependencyCount*: uint32
    pDependencies*: ptr VkSubpassDependency
  VkEventCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkEventCreateFlags
  VkFenceCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkFenceCreateFlags
  VkPhysicalDeviceFeatures* = object
    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
  VkPhysicalDeviceSparseProperties* = object
    residencyStandard2DBlockShape*: VkBool32
    residencyStandard2DMultisampleBlockShape*: VkBool32
    residencyStandard3DBlockShape*: VkBool32
    residencyAlignedMipSize*: VkBool32
    residencyNonResidentStrict*: VkBool32
  VkPhysicalDeviceLimits* = object
    maxImageDimension1D*: uint32
    maxImageDimension2D*: uint32
    maxImageDimension3D*: uint32
    maxImageDimensionCube*: uint32
    maxImageArrayLayers*: uint32
    maxTexelBufferElements*: uint32
    maxUniformBufferRange*: uint32
    maxStorageBufferRange*: uint32
    maxPushConstantsSize*: uint32
    maxMemoryAllocationCount*: uint32
    maxSamplerAllocationCount*: uint32
    bufferImageGranularity*: VkDeviceSize
    sparseAddressSpaceSize*: VkDeviceSize
    maxBoundDescriptorSets*: uint32
    maxPerStageDescriptorSamplers*: uint32
    maxPerStageDescriptorUniformBuffers*: uint32
    maxPerStageDescriptorStorageBuffers*: uint32
    maxPerStageDescriptorSampledImages*: uint32
    maxPerStageDescriptorStorageImages*: uint32
    maxPerStageDescriptorInputAttachments*: uint32
    maxPerStageResources*: uint32
    maxDescriptorSetSamplers*: uint32
    maxDescriptorSetUniformBuffers*: uint32
    maxDescriptorSetUniformBuffersDynamic*: uint32
    maxDescriptorSetStorageBuffers*: uint32
    maxDescriptorSetStorageBuffersDynamic*: uint32
    maxDescriptorSetSampledImages*: uint32
    maxDescriptorSetStorageImages*: uint32
    maxDescriptorSetInputAttachments*: uint32
    maxVertexInputAttributes*: uint32
    maxVertexInputBindings*: uint32
    maxVertexInputAttributeOffset*: uint32
    maxVertexInputBindingStride*: uint32
    maxVertexOutputComponents*: uint32
    maxTessellationGenerationLevel*: uint32
    maxTessellationPatchSize*: uint32
    maxTessellationControlPerVertexInputComponents*: uint32
    maxTessellationControlPerVertexOutputComponents*: uint32
    maxTessellationControlPerPatchOutputComponents*: uint32
    maxTessellationControlTotalOutputComponents*: uint32
    maxTessellationEvaluationInputComponents*: uint32
    maxTessellationEvaluationOutputComponents*: uint32
    maxGeometryShaderInvocations*: uint32
    maxGeometryInputComponents*: uint32
    maxGeometryOutputComponents*: uint32
    maxGeometryOutputVertices*: uint32
    maxGeometryTotalOutputComponents*: uint32
    maxFragmentInputComponents*: uint32
    maxFragmentOutputAttachments*: uint32
    maxFragmentDualSrcAttachments*: uint32
    maxFragmentCombinedOutputResources*: uint32
    maxComputeSharedMemorySize*: uint32
    maxComputeWorkGroupCount*: array[3, uint32]
    maxComputeWorkGroupInvocations*: uint32
    maxComputeWorkGroupSize*: array[3, uint32]
    subPixelPrecisionBits*: uint32
    subTexelPrecisionBits*: uint32
    mipmapPrecisionBits*: uint32
    maxDrawIndexedIndexValue*: uint32
    maxDrawIndirectCount*: uint32
    maxSamplerLodBias*: float32
    maxSamplerAnisotropy*: float32
    maxViewports*: uint32
    maxViewportDimensions*: array[2, uint32]
    viewportBoundsRange*: array[2, float32]
    viewportSubPixelBits*: uint32
    minMemoryMapAlignment*: uint
    minTexelBufferOffsetAlignment*: VkDeviceSize
    minUniformBufferOffsetAlignment*: VkDeviceSize
    minStorageBufferOffsetAlignment*: VkDeviceSize
    minTexelOffset*: int32
    maxTexelOffset*: uint32
    minTexelGatherOffset*: int32
    maxTexelGatherOffset*: uint32
    minInterpolationOffset*: float32
    maxInterpolationOffset*: float32
    subPixelInterpolationOffsetBits*: uint32
    maxFramebufferWidth*: uint32
    maxFramebufferHeight*: uint32
    maxFramebufferLayers*: uint32
    framebufferColorSampleCounts*: VkSampleCountFlags
    framebufferDepthSampleCounts*: VkSampleCountFlags
    framebufferStencilSampleCounts*: VkSampleCountFlags
    framebufferNoAttachmentsSampleCounts*: VkSampleCountFlags
    maxColorAttachments*: uint32
    sampledImageColorSampleCounts*: VkSampleCountFlags
    sampledImageIntegerSampleCounts*: VkSampleCountFlags
    sampledImageDepthSampleCounts*: VkSampleCountFlags
    sampledImageStencilSampleCounts*: VkSampleCountFlags
    storageImageSampleCounts*: VkSampleCountFlags
    maxSampleMaskWords*: uint32
    timestampComputeAndGraphics*: VkBool32
    timestampPeriod*: float32
    maxClipDistances*: uint32
    maxCullDistances*: uint32
    maxCombinedClipAndCullDistances*: uint32
    discreteQueuePriorities*: uint32
    pointSizeRange*: array[2, float32]
    lineWidthRange*: array[2, float32]
    pointSizeGranularity*: float32
    lineWidthGranularity*: float32
    strictLines*: VkBool32
    standardSampleLocations*: VkBool32
    optimalBufferCopyOffsetAlignment*: VkDeviceSize
    optimalBufferCopyRowPitchAlignment*: VkDeviceSize
    nonCoherentAtomSize*: VkDeviceSize
  VkSemaphoreCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkSemaphoreCreateFlags
  VkQueryPoolCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkQueryPoolCreateFlags
    queryType*: VkQueryType
    queryCount*: uint32
    pipelineStatistics*: VkQueryPipelineStatisticFlags
  VkFramebufferCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkFramebufferCreateFlags
    render_pass*: VkRenderPass
    attachmentCount*: uint32
    pAttachments*: ptr VkImageView
    width*: uint32
    height*: uint32
    layers*: uint32
  VkDrawIndirectCommand* = object
    vertexCount*: uint32
    instanceCount*: uint32
    firstVertex*: uint32
    firstInstance*: uint32
  VkDrawIndexedIndirectCommand* = object
    indexCount*: uint32
    instanceCount*: uint32
    firstIndex*: uint32
    vertexOffset*: int32
    firstInstance*: uint32
  VkDispatchIndirectCommand* = object
    x*: uint32
    y*: uint32
    z*: uint32
  VkSubmitInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreCount*: uint32
    pWaitSemaphores*: ptr VkSemaphore
    pWaitDstStageMask*: ptr VkPipelineStageFlags
    commandBufferCount*: uint32
    pCommandBuffers*: ptr VkCommandBuffer
    signalSemaphoreCount*: uint32
    pSignalSemaphores*: ptr VkSemaphore
  VkDisplayPropertiesKHR* = object
    display*: VkDisplayKHR
    displayName*: cstring
    physicalDimensions*: VkExtent2D
    physicalResolution*: VkExtent2D
    supportedTransforms*: VkSurfaceTransformFlagsKHR
    planeReorderPossible*: VkBool32
    persistentContent*: VkBool32
  VkDisplayPlanePropertiesKHR* = object
    currentDisplay*: VkDisplayKHR
    currentStackIndex*: uint32
  VkDisplayModeParametersKHR* = object
    visibleRegion*: VkExtent2D
    refreshRate*: uint32
  VkDisplayModePropertiesKHR* = object
    displayMode*: VkDisplayModeKHR
    parameters*: VkDisplayModeParametersKHR
  VkDisplayModeCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDisplayModeCreateFlagsKHR
    parameters*: VkDisplayModeParametersKHR
  VkDisplayPlaneCapabilitiesKHR* = object
    supportedAlpha*: VkDisplayPlaneAlphaFlagsKHR
    minSrcPosition*: VkOffset2D
    maxSrcPosition*: VkOffset2D
    minSrcExtent*: VkExtent2D
    maxSrcExtent*: VkExtent2D
    minDstPosition*: VkOffset2D
    maxDstPosition*: VkOffset2D
    minDstExtent*: VkExtent2D
    maxDstExtent*: VkExtent2D
  VkDisplaySurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDisplaySurfaceCreateFlagsKHR
    displayMode*: VkDisplayModeKHR
    planeIndex*: uint32
    planeStackIndex*: uint32
    transform*: VkSurfaceTransformFlagBitsKHR
    globalAlpha*: float32
    alphaMode*: VkDisplayPlaneAlphaFlagBitsKHR
    imageExtent*: VkExtent2D
  VkDisplayPresentInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    srcRect*: VkRect2D
    dstRect*: VkRect2D
    persistent*: VkBool32
  VkSurfaceCapabilitiesKHR* = object
    minImageCount*: uint32
    maxImageCount*: uint32
    currentExtent*: VkExtent2D
    minImageExtent*: VkExtent2D
    maxImageExtent*: VkExtent2D
    maxImageArrayLayers*: uint32
    supportedTransforms*: VkSurfaceTransformFlagsKHR
    currentTransform*: VkSurfaceTransformFlagBitsKHR
    supportedCompositeAlpha*: VkCompositeAlphaFlagsKHR
    supportedUsageFlags*: VkImageUsageFlags
  VkAndroidSurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkAndroidSurfaceCreateFlagsKHR
    window*: ptr ANativeWindow
  VkViSurfaceCreateInfoNN* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkViSurfaceCreateFlagsNN
    window*: pointer
  VkWaylandSurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkWaylandSurfaceCreateFlagsKHR
    display*: ptr wl_display
    surface*: ptr wl_surface
  VkWin32SurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkWin32SurfaceCreateFlagsKHR
    hinstance*: HINSTANCE
    hwnd*: HWND
  VkXlibSurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkXlibSurfaceCreateFlagsKHR
    dpy*: ptr Display
    window*: Window
  VkXcbSurfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkXcbSurfaceCreateFlagsKHR
    connection*: ptr xcb_connection_t
    window*: xcb_window_t
  VkDirectFBSurfaceCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDirectFBSurfaceCreateFlagsEXT
    dfb*: ptr IDirectFB
    surface*: ptr IDirectFBSurface
  VkImagePipeSurfaceCreateInfoFUCHSIA* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkImagePipeSurfaceCreateFlagsFUCHSIA
    imagePipeHandle*: zx_handle_t
  VkStreamDescriptorSurfaceCreateInfoGGP* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkStreamDescriptorSurfaceCreateFlagsGGP
    streamDescriptor*: GgpStreamDescriptor
  VkSurfaceFormatKHR* = object
    format*: VkFormat
    colorSpace*: VkColorSpaceKHR
  VkSwapchainCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkSwapchainCreateFlagsKHR
    surface*: VkSurfaceKHR
    minImageCount*: uint32
    imageFormat*: VkFormat
    imageColorSpace*: VkColorSpaceKHR
    imageExtent*: VkExtent2D
    imageArrayLayers*: uint32
    imageUsage*: VkImageUsageFlags
    imageSharingMode*: VkSharingMode
    queueFamilyIndexCount*: uint32
    pQueueFamilyIndices*: ptr uint32
    preTransform*: VkSurfaceTransformFlagBitsKHR
    compositeAlpha*: VkCompositeAlphaFlagBitsKHR
    presentMode*: VkPresentModeKHR
    clipped*: VkBool32
    oldSwapchain*: VkSwapchainKHR
  VkPresentInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreCount*: uint32
    pWaitSemaphores*: ptr VkSemaphore
    swapchainCount*: uint32
    pSwapchains*: ptr VkSwapchainKHR
    pImageIndices*: ptr uint32
    pResults*: ptr VkResult
  VkDebugReportCallbackCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDebugReportFlagsEXT
    pfnCallback*: PFN_vkDebugReportCallbackEXT
    pUserData*: pointer
  VkValidationFlagsEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    disabledValidationCheckCount*: uint32
    pDisabledValidationChecks*: ptr VkValidationCheckEXT
  VkValidationFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    enabledValidationFeatureCount*: uint32
    pEnabledValidationFeatures*: ptr VkValidationFeatureEnableEXT
    disabledValidationFeatureCount*: uint32
    pDisabledValidationFeatures*: ptr VkValidationFeatureDisableEXT
  VkPipelineRasterizationStateRasterizationOrderAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    rasterizationOrder*: VkRasterizationOrderAMD
  VkDebugMarkerObjectNameInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    objectType*: VkDebugReportObjectTypeEXT
    `object`*: uint64
    pObjectName*: cstring
  VkDebugMarkerObjectTagInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    objectType*: VkDebugReportObjectTypeEXT
    `object`*: uint64
    tagName*: uint64
    tagSize*: uint
    pTag*: pointer
  VkDebugMarkerMarkerInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    pMarkerName*: cstring
    color*: array[4, float32]
  VkDedicatedAllocationImageCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    dedicatedAllocation*: VkBool32
  VkDedicatedAllocationBufferCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    dedicatedAllocation*: VkBool32
  VkDedicatedAllocationMemoryAllocateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    image*: VkImage
    buffer*: VkBuffer
  VkExternalImageFormatPropertiesNV* = object
    imageFormatProperties*: VkImageFormatProperties
    externalMemoryFeatures*: VkExternalMemoryFeatureFlagsNV
    exportFromImportedHandleTypes*: VkExternalMemoryHandleTypeFlagsNV
    compatibleHandleTypes*: VkExternalMemoryHandleTypeFlagsNV
  VkExternalMemoryImageCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalMemoryHandleTypeFlagsNV
  VkExportMemoryAllocateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalMemoryHandleTypeFlagsNV
  VkImportMemoryWin32HandleInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalMemoryHandleTypeFlagsNV
    handle*: HANDLE
  VkExportMemoryWin32HandleInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    pAttributes*: ptr SECURITY_ATTRIBUTES
    dwAccess*: DWORD
  VkWin32KeyedMutexAcquireReleaseInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    acquireCount*: uint32
    pAcquireSyncs*: ptr VkDeviceMemory
    pAcquireKeys*: ptr uint64
    pAcquireTimeoutMilliseconds*: ptr uint32
    releaseCount*: uint32
    pReleaseSyncs*: ptr VkDeviceMemory
    pReleaseKeys*: ptr uint64
  VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceGeneratedCommands*: VkBool32
  VkDevicePrivateDataCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    privateDataSlotRequestCount*: uint32
  VkPrivateDataSlotCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPrivateDataSlotCreateFlagsEXT
  VkPhysicalDevicePrivateDataFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    privateData*: VkBool32
  VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    maxGraphicsShaderGroupCount*: uint32
    maxIndirectSequenceCount*: uint32
    maxIndirectCommandsTokenCount*: uint32
    maxIndirectCommandsStreamCount*: uint32
    maxIndirectCommandsTokenOffset*: uint32
    maxIndirectCommandsStreamStride*: uint32
    minSequencesCountBufferOffsetAlignment*: uint32
    minSequencesIndexBufferOffsetAlignment*: uint32
    minIndirectCommandsBufferOffsetAlignment*: uint32
  VkGraphicsShaderGroupCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    stageCount*: uint32
    pStages*: ptr VkPipelineShaderStageCreateInfo
    pVertexInputState*: ptr VkPipelineVertexInputStateCreateInfo
    pTessellationState*: ptr VkPipelineTessellationStateCreateInfo
  VkGraphicsPipelineShaderGroupsCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    groupCount*: uint32
    pGroups*: ptr VkGraphicsShaderGroupCreateInfoNV
    pipelineCount*: uint32
    pPipelines*: ptr VkPipeline
  VkBindShaderGroupIndirectCommandNV* = object
    groupIndex*: uint32
  VkBindIndexBufferIndirectCommandNV* = object
    bufferAddress*: VkDeviceAddress
    size*: uint32
    indexType*: VkIndexType
  VkBindVertexBufferIndirectCommandNV* = object
    bufferAddress*: VkDeviceAddress
    size*: uint32
    stride*: uint32
  VkSetStateFlagsIndirectCommandNV* = object
    data*: uint32
  VkIndirectCommandsStreamNV* = object
    buffer*: VkBuffer
    offset*: VkDeviceSize
  VkIndirectCommandsLayoutTokenNV* = object
    sType*: VkStructureType
    pNext*: pointer
    tokenType*: VkIndirectCommandsTokenTypeNV
    stream*: uint32
    offset*: uint32
    vertexBindingUnit*: uint32
    vertexDynamicStride*: VkBool32
    pushconstantPipelineLayout*: VkPipelineLayout
    pushconstantShaderStageFlags*: VkShaderStageFlags
    pushconstantOffset*: uint32
    pushconstantSize*: uint32
    indirectStateFlags*: VkIndirectStateFlagsNV
    indexTypeCount*: uint32
    pIndexTypes*: ptr VkIndexType
    pIndexTypeValues*: ptr uint32
  VkIndirectCommandsLayoutCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkIndirectCommandsLayoutUsageFlagsNV
    pipelineBindPoint*: VkPipelineBindPoint
    tokenCount*: uint32
    pTokens*: ptr VkIndirectCommandsLayoutTokenNV
    streamCount*: uint32
    pStreamStrides*: ptr uint32
  VkGeneratedCommandsInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    pipelineBindPoint*: VkPipelineBindPoint
    pipeline*: VkPipeline
    indirectCommandsLayout*: VkIndirectCommandsLayoutNV
    streamCount*: uint32
    pStreams*: ptr VkIndirectCommandsStreamNV
    sequencesCount*: uint32
    preprocessBuffer*: VkBuffer
    preprocessOffset*: VkDeviceSize
    preprocessSize*: VkDeviceSize
    sequencesCountBuffer*: VkBuffer
    sequencesCountOffset*: VkDeviceSize
    sequencesIndexBuffer*: VkBuffer
    sequencesIndexOffset*: VkDeviceSize
  VkGeneratedCommandsMemoryRequirementsInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    pipelineBindPoint*: VkPipelineBindPoint
    pipeline*: VkPipeline
    indirectCommandsLayout*: VkIndirectCommandsLayoutNV
    maxSequencesCount*: uint32
  VkPhysicalDeviceFeatures2* = object
    sType*: VkStructureType
    pNext*: pointer
    features*: VkPhysicalDeviceFeatures
  VkPhysicalDeviceFeatures2KHR* = object
  VkPhysicalDeviceProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    properties*: VkPhysicalDeviceProperties
  VkPhysicalDeviceProperties2KHR* = object
  VkFormatProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    formatProperties*: VkFormatProperties
  VkFormatProperties2KHR* = object
  VkImageFormatProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    imageFormatProperties*: VkImageFormatProperties
  VkImageFormatProperties2KHR* = object
  VkPhysicalDeviceImageFormatInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    format*: VkFormat
    typee*: VkImageType
    tiling*: VkImageTiling
    usage*: VkImageUsageFlags
    flags*: VkImageCreateFlags
  VkPhysicalDeviceImageFormatInfo2KHR* = object
  VkQueueFamilyProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    queueFamilyProperties*: VkQueueFamilyProperties
  VkQueueFamilyProperties2KHR* = object
  VkPhysicalDeviceMemoryProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryProperties*: VkPhysicalDeviceMemoryProperties
  VkPhysicalDeviceMemoryProperties2KHR* = object
  VkSparseImageFormatProperties2* = object
    sType*: VkStructureType
    pNext*: pointer
    properties*: VkSparseImageFormatProperties
  VkSparseImageFormatProperties2KHR* = object
  VkPhysicalDeviceSparseImageFormatInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    format*: VkFormat
    typee*: VkImageType
    samples*: VkSampleCountFlagBits
    usage*: VkImageUsageFlags
    tiling*: VkImageTiling
  VkPhysicalDeviceSparseImageFormatInfo2KHR* = object
  VkPhysicalDevicePushDescriptorPropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    maxPushDescriptors*: uint32
  VkConformanceVersion* = object
    major*: uint8
    minor*: uint8
    subminor*: uint8
    patch*: uint8
  VkConformanceVersionKHR* = object
  VkPhysicalDeviceDriverProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    driverID*: VkDriverId
    driverName*: array[VK_MAX_DRIVER_NAME_SIZE, char]
    driverInfo*: array[VK_MAX_DRIVER_INFO_SIZE, char]
    conformanceVersion*: VkConformanceVersion
  VkPhysicalDeviceDriverPropertiesKHR* = object
  VkPresentRegionsKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchainCount*: uint32
    pRegions*: ptr VkPresentRegionKHR
  VkPresentRegionKHR* = object
    rectangleCount*: uint32
    pRectangles*: ptr VkRectLayerKHR
  VkRectLayerKHR* = object
    offset*: VkOffset2D
    extent*: VkExtent2D
    layer*: uint32
  VkPhysicalDeviceVariablePointersFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    variablePointersStorageBuffer*: VkBool32
    variablePointers*: VkBool32
  VkPhysicalDeviceVariablePointersFeaturesKHR* = object
  VkPhysicalDeviceVariablePointerFeaturesKHR* = object
  VkPhysicalDeviceVariablePointerFeatures* = object
  VkExternalMemoryProperties* = object
    externalMemoryFeatures*: VkExternalMemoryFeatureFlags
    exportFromImportedHandleTypes*: VkExternalMemoryHandleTypeFlags
    compatibleHandleTypes*: VkExternalMemoryHandleTypeFlags
  VkExternalMemoryPropertiesKHR* = object
  VkPhysicalDeviceExternalImageFormatInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalMemoryHandleTypeFlagBits
  VkPhysicalDeviceExternalImageFormatInfoKHR* = object
  VkExternalImageFormatProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    externalMemoryProperties*: VkExternalMemoryProperties
  VkExternalImageFormatPropertiesKHR* = object
  VkPhysicalDeviceExternalBufferInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkBufferCreateFlags
    usage*: VkBufferUsageFlags
    handleType*: VkExternalMemoryHandleTypeFlagBits
  VkPhysicalDeviceExternalBufferInfoKHR* = object
  VkExternalBufferProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    externalMemoryProperties*: VkExternalMemoryProperties
  VkExternalBufferPropertiesKHR* = object
  VkPhysicalDeviceIDProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceUUID*: array[VK_UUID_SIZE, uint8]
    driverUUID*: array[VK_UUID_SIZE, uint8]
    deviceLUID*: array[VK_LUID_SIZE, uint8]
    deviceNodeMask*: uint32
    deviceLUIDValid*: VkBool32
  VkPhysicalDeviceIDPropertiesKHR* = object
  VkExternalMemoryImageCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalMemoryHandleTypeFlags
  VkExternalMemoryImageCreateInfoKHR* = object
  VkExternalMemoryBufferCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalMemoryHandleTypeFlags
  VkExternalMemoryBufferCreateInfoKHR* = object
  VkExportMemoryAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalMemoryHandleTypeFlags
  VkExportMemoryAllocateInfoKHR* = object
  VkImportMemoryWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalMemoryHandleTypeFlagBits
    handle*: HANDLE
    name*: LPCWSTR
  VkExportMemoryWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pAttributes*: ptr SECURITY_ATTRIBUTES
    dwAccess*: DWORD
    name*: LPCWSTR
  VkMemoryWin32HandlePropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryTypeBits*: uint32
  VkMemoryGetWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    memory*: VkDeviceMemory
    handleType*: VkExternalMemoryHandleTypeFlagBits
  VkImportMemoryFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalMemoryHandleTypeFlagBits
    fd*: int
  VkMemoryFdPropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryTypeBits*: uint32
  VkMemoryGetFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    memory*: VkDeviceMemory
    handleType*: VkExternalMemoryHandleTypeFlagBits
  VkWin32KeyedMutexAcquireReleaseInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    acquireCount*: uint32
    pAcquireSyncs*: ptr VkDeviceMemory
    pAcquireKeys*: ptr uint64
    pAcquireTimeouts*: ptr uint32
    releaseCount*: uint32
    pReleaseSyncs*: ptr VkDeviceMemory
    pReleaseKeys*: ptr uint64
  VkPhysicalDeviceExternalSemaphoreInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalSemaphoreHandleTypeFlagBits
  VkPhysicalDeviceExternalSemaphoreInfoKHR* = object
  VkExternalSemaphoreProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    exportFromImportedHandleTypes*: VkExternalSemaphoreHandleTypeFlags
    compatibleHandleTypes*: VkExternalSemaphoreHandleTypeFlags
    externalSemaphoreFeatures*: VkExternalSemaphoreFeatureFlags
  VkExternalSemaphorePropertiesKHR* = object
  VkExportSemaphoreCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalSemaphoreHandleTypeFlags
  VkExportSemaphoreCreateInfoKHR* = object
  VkImportSemaphoreWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphore*: VkSemaphore
    flags*: VkSemaphoreImportFlags
    handleType*: VkExternalSemaphoreHandleTypeFlagBits
    handle*: HANDLE
    name*: LPCWSTR
  VkExportSemaphoreWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pAttributes*: ptr SECURITY_ATTRIBUTES
    dwAccess*: DWORD
    name*: LPCWSTR
  VkD3D12FenceSubmitInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreValuesCount*: uint32
    pWaitSemaphoreValues*: ptr uint64
    signalSemaphoreValuesCount*: uint32
    pSignalSemaphoreValues*: ptr uint64
  VkSemaphoreGetWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphore*: VkSemaphore
    handleType*: VkExternalSemaphoreHandleTypeFlagBits
  VkImportSemaphoreFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphore*: VkSemaphore
    flags*: VkSemaphoreImportFlags
    handleType*: VkExternalSemaphoreHandleTypeFlagBits
    fd*: int
  VkSemaphoreGetFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphore*: VkSemaphore
    handleType*: VkExternalSemaphoreHandleTypeFlagBits
  VkPhysicalDeviceExternalFenceInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalFenceHandleTypeFlagBits
  VkPhysicalDeviceExternalFenceInfoKHR* = object
  VkExternalFenceProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    exportFromImportedHandleTypes*: VkExternalFenceHandleTypeFlags
    compatibleHandleTypes*: VkExternalFenceHandleTypeFlags
    externalFenceFeatures*: VkExternalFenceFeatureFlags
  VkExternalFencePropertiesKHR* = object
  VkExportFenceCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    handleTypes*: VkExternalFenceHandleTypeFlags
  VkExportFenceCreateInfoKHR* = object
  VkImportFenceWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    fence*: VkFence
    flags*: VkFenceImportFlags
    handleType*: VkExternalFenceHandleTypeFlagBits
    handle*: HANDLE
    name*: LPCWSTR
  VkExportFenceWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pAttributes*: ptr SECURITY_ATTRIBUTES
    dwAccess*: DWORD
    name*: LPCWSTR
  VkFenceGetWin32HandleInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    fence*: VkFence
    handleType*: VkExternalFenceHandleTypeFlagBits
  VkImportFenceFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    fence*: VkFence
    flags*: VkFenceImportFlags
    handleType*: VkExternalFenceHandleTypeFlagBits
    fd*: int
  VkFenceGetFdInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    fence*: VkFence
    handleType*: VkExternalFenceHandleTypeFlagBits
  VkPhysicalDeviceMultiviewFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    multiview*: VkBool32
    multiviewGeometryShader*: VkBool32
    multiviewTessellationShader*: VkBool32
  VkPhysicalDeviceMultiviewFeaturesKHR* = object
  VkPhysicalDeviceMultiviewProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    maxMultiviewViewCount*: uint32
    maxMultiviewInstanceIndex*: uint32
  VkPhysicalDeviceMultiviewPropertiesKHR* = object
  VkRenderPassMultiviewCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    subpassCount*: uint32
    pViewMasks*: ptr uint32
    dependencyCount*: uint32
    pViewOffsets*: ptr int32
    correlationMaskCount*: uint32
    pCorrelationMasks*: ptr uint32
  VkRenderPassMultiviewCreateInfoKHR* = object
  VkSurfaceCapabilities2EXT* = object
    sType*: VkStructureType
    pNext*: pointer
    minImageCount*: uint32
    maxImageCount*: uint32
    currentExtent*: VkExtent2D
    minImageExtent*: VkExtent2D
    maxImageExtent*: VkExtent2D
    maxImageArrayLayers*: uint32
    supportedTransforms*: VkSurfaceTransformFlagsKHR
    currentTransform*: VkSurfaceTransformFlagBitsKHR
    supportedCompositeAlpha*: VkCompositeAlphaFlagsKHR
    supportedUsageFlags*: VkImageUsageFlags
    supportedSurfaceCounters*: VkSurfaceCounterFlagsEXT
  VkDisplayPowerInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    powerState*: VkDisplayPowerStateEXT
  VkDeviceEventInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceEvent*: VkDeviceEventTypeEXT
  VkDisplayEventInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    displayEvent*: VkDisplayEventTypeEXT
  VkSwapchainCounterCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    surfaceCounters*: VkSurfaceCounterFlagsEXT
  VkPhysicalDeviceGroupProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    physicalDeviceCount*: uint32
    physicalDevices*: array[VK_MAX_DEVICE_GROUP_SIZE, VkPhysicalDevice]
    subsetAllocation*: VkBool32
  VkPhysicalDeviceGroupPropertiesKHR* = object
  VkMemoryAllocateFlagsInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkMemoryAllocateFlags
    deviceMask*: uint32
  VkMemoryAllocateFlagsInfoKHR* = object
  VkBindBufferMemoryInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    buffer*: VkBuffer
    memory*: VkDeviceMemory
    memoryOffset*: VkDeviceSize
  VkBindBufferMemoryInfoKHR* = object
  VkBindBufferMemoryDeviceGroupInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceIndexCount*: uint32
    pDeviceIndices*: ptr uint32
  VkBindBufferMemoryDeviceGroupInfoKHR* = object
  VkBindImageMemoryInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    image*: VkImage
    memory*: VkDeviceMemory
    memoryOffset*: VkDeviceSize
  VkBindImageMemoryInfoKHR* = object
  VkBindImageMemoryDeviceGroupInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceIndexCount*: uint32
    pDeviceIndices*: ptr uint32
    splitInstanceBindRegionCount*: uint32
    pSplitInstanceBindRegions*: ptr VkRect2D
  VkBindImageMemoryDeviceGroupInfoKHR* = object
  VkDeviceGroupRenderPassBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceMask*: uint32
    deviceRenderAreaCount*: uint32
    pDeviceRenderAreas*: ptr VkRect2D
  VkDeviceGroupRenderPassBeginInfoKHR* = object
  VkDeviceGroupCommandBufferBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceMask*: uint32
  VkDeviceGroupCommandBufferBeginInfoKHR* = object
  VkDeviceGroupSubmitInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreCount*: uint32
    pWaitSemaphoreDeviceIndices*: ptr uint32
    commandBufferCount*: uint32
    pCommandBufferDeviceMasks*: ptr uint32
    signalSemaphoreCount*: uint32
    pSignalSemaphoreDeviceIndices*: ptr uint32
  VkDeviceGroupSubmitInfoKHR* = object
  VkDeviceGroupBindSparseInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    resourceDeviceIndex*: uint32
    memoryDeviceIndex*: uint32
  VkDeviceGroupBindSparseInfoKHR* = object
  VkDeviceGroupPresentCapabilitiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    presentMask*: array[VK_MAX_DEVICE_GROUP_SIZE, uint32]
    modes*: VkDeviceGroupPresentModeFlagsKHR
  VkImageSwapchainCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchain*: VkSwapchainKHR
  VkBindImageMemorySwapchainInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchain*: VkSwapchainKHR
    imageIndex*: uint32
  VkAcquireNextImageInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchain*: VkSwapchainKHR
    timeout*: uint64
    semaphore*: VkSemaphore
    fence*: VkFence
    deviceMask*: uint32
  VkDeviceGroupPresentInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchainCount*: uint32
    pDeviceMasks*: ptr uint32
    mode*: VkDeviceGroupPresentModeFlagBitsKHR
  VkDeviceGroupDeviceCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    physicalDeviceCount*: uint32
    pPhysicalDevices*: ptr VkPhysicalDevice
  VkDeviceGroupDeviceCreateInfoKHR* = object
  VkDeviceGroupSwapchainCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    modes*: VkDeviceGroupPresentModeFlagsKHR
  VkDescriptorUpdateTemplateEntry* = object
    dstBinding*: uint32
    dstArrayElement*: uint32
    descriptorCount*: uint32
    descriptorType*: VkDescriptorType
    offset*: uint
    stride*: uint
  VkDescriptorUpdateTemplateEntryKHR* = object
  VkDescriptorUpdateTemplateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDescriptorUpdateTemplateCreateFlags
    descriptorUpdateEntryCount*: uint32
    pDescriptorUpdateEntries*: ptr VkDescriptorUpdateTemplateEntry
    templateType*: VkDescriptorUpdateTemplateType
    descriptorSetLayout*: VkDescriptorSetLayout
    pipelineBindPoint*: VkPipelineBindPoint
    pipelineLayout*: VkPipelineLayout
    set*: uint32
  VkDescriptorUpdateTemplateCreateInfoKHR* = object
  VkXYColorEXT* = object
    x*: float32
    y*: float32
  VkHdrMetadataEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    displayPrimaryRed*: VkXYColorEXT
    displayPrimaryGreen*: VkXYColorEXT
    displayPrimaryBlue*: VkXYColorEXT
    whitePoint*: VkXYColorEXT
    maxLuminance*: float32
    minLuminance*: float32
    maxContentLightLevel*: float32
    maxFrameAverageLightLevel*: float32
  VkDisplayNativeHdrSurfaceCapabilitiesAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    localDimmingSupport*: VkBool32
  VkSwapchainDisplayNativeHdrCreateInfoAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    localDimmingEnable*: VkBool32
  VkRefreshCycleDurationGOOGLE* = object
    refreshDuration*: uint64
  VkPastPresentationTimingGOOGLE* = object
    presentID*: uint32
    desiredPresentTime*: uint64
    actualPresentTime*: uint64
    earliestPresentTime*: uint64
    presentMargin*: uint64
  VkPresentTimesInfoGOOGLE* = object
    sType*: VkStructureType
    pNext*: pointer
    swapchainCount*: uint32
    pTimes*: ptr VkPresentTimeGOOGLE
  VkPresentTimeGOOGLE* = object
    presentID*: uint32
    desiredPresentTime*: uint64
  VkIOSSurfaceCreateInfoMVK* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkIOSSurfaceCreateFlagsMVK
    pView*: pointer
  VkMacOSSurfaceCreateInfoMVK* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkMacOSSurfaceCreateFlagsMVK
    pView*: pointer
  VkMetalSurfaceCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkMetalSurfaceCreateFlagsEXT
    pLayer*: ptr CAMetalLayer
  VkViewportWScalingNV* = object
    xcoeff*: float32
    ycoeff*: float32
  VkPipelineViewportWScalingStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    viewportWScalingEnable*: VkBool32
    viewportCount*: uint32
    pViewportWScalings*: ptr VkViewportWScalingNV
  VkViewportSwizzleNV* = object
    x*: VkViewportCoordinateSwizzleNV
    y*: VkViewportCoordinateSwizzleNV
    z*: VkViewportCoordinateSwizzleNV
    w*: VkViewportCoordinateSwizzleNV
  VkPipelineViewportSwizzleStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineViewportSwizzleStateCreateFlagsNV
    viewportCount*: uint32
    pViewportSwizzles*: ptr VkViewportSwizzleNV
  VkPhysicalDeviceDiscardRectanglePropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxDiscardRectangles*: uint32
  VkPipelineDiscardRectangleStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineDiscardRectangleStateCreateFlagsEXT
    discardRectangleMode*: VkDiscardRectangleModeEXT
    discardRectangleCount*: uint32
    pDiscardRectangles*: ptr VkRect2D
  VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* = object
    sType*: VkStructureType
    pNext*: pointer
    perViewPositionAllComponents*: VkBool32
  VkInputAttachmentAspectReference* = object
    subpass*: uint32
    inputAttachmentIndex*: uint32
    aspectMask*: VkImageAspectFlags
  VkInputAttachmentAspectReferenceKHR* = object
  VkRenderPassInputAttachmentAspectCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    aspectReferenceCount*: uint32
    pAspectReferences*: ptr VkInputAttachmentAspectReference
  VkRenderPassInputAttachmentAspectCreateInfoKHR* = object
  VkPhysicalDeviceSurfaceInfo2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    surface*: VkSurfaceKHR
  VkSurfaceCapabilities2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    surfaceCapabilities*: VkSurfaceCapabilitiesKHR
  VkSurfaceFormat2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    surfaceFormat*: VkSurfaceFormatKHR
  VkDisplayProperties2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    displayProperties*: VkDisplayPropertiesKHR
  VkDisplayPlaneProperties2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    displayPlaneProperties*: VkDisplayPlanePropertiesKHR
  VkDisplayModeProperties2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    displayModeProperties*: VkDisplayModePropertiesKHR
  VkDisplayPlaneInfo2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    mode*: VkDisplayModeKHR
    planeIndex*: uint32
  VkDisplayPlaneCapabilities2KHR* = object
    sType*: VkStructureType
    pNext*: pointer
    capabilities*: VkDisplayPlaneCapabilitiesKHR
  VkSharedPresentSurfaceCapabilitiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    sharedPresentSupportedUsageFlags*: VkImageUsageFlags
  VkPhysicalDevice16BitStorageFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    storageBuffer16BitAccess*: VkBool32
    uniformAndStorageBuffer16BitAccess*: VkBool32
    storagePushConstant16*: VkBool32
    storageInputOutput16*: VkBool32
  VkPhysicalDevice16BitStorageFeaturesKHR* = object
  VkPhysicalDeviceSubgroupProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    subgroupSize*: uint32
    supportedStages*: VkShaderStageFlags
    supportedOperations*: VkSubgroupFeatureFlags
    quadOperationsInAllStages*: VkBool32
  VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderSubgroupExtendedTypes*: VkBool32
  VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR* = object
  VkBufferMemoryRequirementsInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    buffer*: VkBuffer
  VkBufferMemoryRequirementsInfo2KHR* = object
  VkImageMemoryRequirementsInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    image*: VkImage
  VkImageMemoryRequirementsInfo2KHR* = object
  VkImageSparseMemoryRequirementsInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    image*: VkImage
  VkImageSparseMemoryRequirementsInfo2KHR* = object
  VkMemoryRequirements2* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryRequirements*: VkMemoryRequirements
  VkMemoryRequirements2KHR* = object
  VkSparseImageMemoryRequirements2* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryRequirements*: VkSparseImageMemoryRequirements
  VkSparseImageMemoryRequirements2KHR* = object
  VkPhysicalDevicePointClippingProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    pointClippingBehavior*: VkPointClippingBehavior
  VkPhysicalDevicePointClippingPropertiesKHR* = object
  VkMemoryDedicatedRequirements* = object
    sType*: VkStructureType
    pNext*: pointer
    prefersDedicatedAllocation*: VkBool32
    requiresDedicatedAllocation*: VkBool32
  VkMemoryDedicatedRequirementsKHR* = object
  VkMemoryDedicatedAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    image*: VkImage
    buffer*: VkBuffer
  VkMemoryDedicatedAllocateInfoKHR* = object
  VkImageViewUsageCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    usage*: VkImageUsageFlags
  VkImageViewUsageCreateInfoKHR* = object
  VkPipelineTessellationDomainOriginStateCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    domainOrigin*: VkTessellationDomainOrigin
  VkPipelineTessellationDomainOriginStateCreateInfoKHR* = object
  VkSamplerYcbcrConversionInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    conversion*: VkSamplerYcbcrConversion
  VkSamplerYcbcrConversionInfoKHR* = object
  VkSamplerYcbcrConversionCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    format*: VkFormat
    ycbcrModel*: VkSamplerYcbcrModelConversion
    ycbcrRange*: VkSamplerYcbcrRange
    components*: VkComponentMapping
    xChromaOffset*: VkChromaLocation
    yChromaOffset*: VkChromaLocation
    chromaFilter*: VkFilter
    forceExplicitReconstruction*: VkBool32
  VkSamplerYcbcrConversionCreateInfoKHR* = object
  VkBindImagePlaneMemoryInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    planeAspect*: VkImageAspectFlagBits
  VkBindImagePlaneMemoryInfoKHR* = object
  VkImagePlaneMemoryRequirementsInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    planeAspect*: VkImageAspectFlagBits
  VkImagePlaneMemoryRequirementsInfoKHR* = object
  VkPhysicalDeviceSamplerYcbcrConversionFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    samplerYcbcrConversion*: VkBool32
  VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR* = object
  VkSamplerYcbcrConversionImageFormatProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    combinedImageSamplerDescriptorCount*: uint32
  VkSamplerYcbcrConversionImageFormatPropertiesKHR* = object
  VkTextureLODGatherFormatPropertiesAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    supportsTextureGatherLODBiasAMD*: VkBool32
  VkConditionalRenderingBeginInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    buffer*: VkBuffer
    offset*: VkDeviceSize
    flags*: VkConditionalRenderingFlagsEXT
  VkProtectedSubmitInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    protectedSubmit*: VkBool32
  VkPhysicalDeviceProtectedMemoryFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    protectedMemory*: VkBool32
  VkPhysicalDeviceProtectedMemoryProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    protectedNoFault*: VkBool32
  VkDeviceQueueInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDeviceQueueCreateFlags
    queueFamilyIndex*: uint32
    queueIndex*: uint32
  VkPipelineCoverageToColorStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCoverageToColorStateCreateFlagsNV
    coverageToColorEnable*: VkBool32
    coverageToColorLocation*: uint32
  VkPhysicalDeviceSamplerFilterMinmaxProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    filterMinmaxSingleComponentFormats*: VkBool32
    filterMinmaxImageComponentMapping*: VkBool32
  VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* = object
  VkSampleLocationEXT* = object
    x*: float32
    y*: float32
  VkSampleLocationsInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    sampleLocationsPerPixel*: VkSampleCountFlagBits
    sampleLocationGridSize*: VkExtent2D
    sampleLocationsCount*: uint32
    pSampleLocations*: ptr VkSampleLocationEXT
  VkAttachmentSampleLocationsEXT* = object
    attachmentIndex*: uint32
    sampleLocationsInfo*: VkSampleLocationsInfoEXT
  VkSubpassSampleLocationsEXT* = object
    subpassIndex*: uint32
    sampleLocationsInfo*: VkSampleLocationsInfoEXT
  VkRenderPassSampleLocationsBeginInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    attachmentInitialSampleLocationsCount*: uint32
    pAttachmentInitialSampleLocations*: ptr VkAttachmentSampleLocationsEXT
    postSubpassSampleLocationsCount*: uint32
    pPostSubpassSampleLocations*: ptr VkSubpassSampleLocationsEXT
  VkPipelineSampleLocationsStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    sampleLocationsEnable*: VkBool32
    sampleLocationsInfo*: VkSampleLocationsInfoEXT
  VkPhysicalDeviceSampleLocationsPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    sampleLocationSampleCounts*: VkSampleCountFlags
    maxSampleLocationGridSize*: VkExtent2D
    sampleLocationCoordinateRange*: array[2, float32]
    sampleLocationSubPixelBits*: uint32
    variableSampleLocations*: VkBool32
  VkMultisamplePropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxSampleLocationGridSize*: VkExtent2D
  VkSamplerReductionModeCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    reductionMode*: VkSamplerReductionMode
  VkSamplerReductionModeCreateInfoEXT* = object
  VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    advancedBlendCoherentOperations*: VkBool32
  VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    advancedBlendMaxColorAttachments*: uint32
    advancedBlendIndependentBlend*: VkBool32
    advancedBlendNonPremultipliedSrcColor*: VkBool32
    advancedBlendNonPremultipliedDstColor*: VkBool32
    advancedBlendCorrelatedOverlap*: VkBool32
    advancedBlendAllOperations*: VkBool32
  VkPipelineColorBlendAdvancedStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    srcPremultiplied*: VkBool32
    dstPremultiplied*: VkBool32
    blendOverlap*: VkBlendOverlapEXT
  VkPhysicalDeviceInlineUniformBlockFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    inlineUniformBlock*: VkBool32
    descriptorBindingInlineUniformBlockUpdateAfterBind*: VkBool32
  VkPhysicalDeviceInlineUniformBlockPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxInlineUniformBlockSize*: uint32
    maxPerStageDescriptorInlineUniformBlocks*: uint32
    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks*: uint32
    maxDescriptorSetInlineUniformBlocks*: uint32
    maxDescriptorSetUpdateAfterBindInlineUniformBlocks*: uint32
  VkWriteDescriptorSetInlineUniformBlockEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    dataSize*: uint32
    pData*: pointer
  VkDescriptorPoolInlineUniformBlockCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxInlineUniformBlockBindings*: uint32
  VkPipelineCoverageModulationStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCoverageModulationStateCreateFlagsNV
    coverageModulationMode*: VkCoverageModulationModeNV
    coverageModulationTableEnable*: VkBool32
    coverageModulationTableCount*: uint32
    pCoverageModulationTable*: ptr float32
  VkImageFormatListCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    viewFormatCount*: uint32
    pViewFormats*: ptr VkFormat
  VkImageFormatListCreateInfoKHR* = object
  VkValidationCacheCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkValidationCacheCreateFlagsEXT
    initialDataSize*: uint
    pInitialData*: pointer
  VkShaderModuleValidationCacheCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    validationCache*: VkValidationCacheEXT
  VkPhysicalDeviceMaintenance3Properties* = object
    sType*: VkStructureType
    pNext*: pointer
    maxPerSetDescriptors*: uint32
    maxMemoryAllocationSize*: VkDeviceSize
  VkPhysicalDeviceMaintenance3PropertiesKHR* = object
  VkDescriptorSetLayoutSupport* = object
    sType*: VkStructureType
    pNext*: pointer
    supported*: VkBool32
  VkDescriptorSetLayoutSupportKHR* = object
  VkPhysicalDeviceShaderDrawParametersFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderDrawParameters*: VkBool32
  VkPhysicalDeviceShaderDrawParameterFeatures* = object
  VkPhysicalDeviceShaderFloat16Int8Features* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderFloat16*: VkBool32
    shaderInt8*: VkBool32
  VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* = object
  VkPhysicalDeviceFloat16Int8FeaturesKHR* = object
  VkPhysicalDeviceFloatControlsProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    denormBehaviorIndependence*: VkShaderFloatControlsIndependence
    roundingModeIndependence*: VkShaderFloatControlsIndependence
    shaderSignedZeroInfNanPreserveFloat16*: VkBool32
    shaderSignedZeroInfNanPreserveFloat32*: VkBool32
    shaderSignedZeroInfNanPreserveFloat64*: VkBool32
    shaderDenormPreserveFloat16*: VkBool32
    shaderDenormPreserveFloat32*: VkBool32
    shaderDenormPreserveFloat64*: VkBool32
    shaderDenormFlushToZeroFloat16*: VkBool32
    shaderDenormFlushToZeroFloat32*: VkBool32
    shaderDenormFlushToZeroFloat64*: VkBool32
    shaderRoundingModeRTEFloat16*: VkBool32
    shaderRoundingModeRTEFloat32*: VkBool32
    shaderRoundingModeRTEFloat64*: VkBool32
    shaderRoundingModeRTZFloat16*: VkBool32
    shaderRoundingModeRTZFloat32*: VkBool32
    shaderRoundingModeRTZFloat64*: VkBool32
  VkPhysicalDeviceFloatControlsPropertiesKHR* = object
  VkPhysicalDeviceHostQueryResetFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    hostQueryReset*: VkBool32
  VkPhysicalDeviceHostQueryResetFeaturesEXT* = object
  VkNativeBufferUsage2ANDROID* = object
    consumer*: uint64
    producer*: uint64
  VkNativeBufferANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    handle*: pointer
    stride*: int
    format*: int
    usage*: int
    usage2*: VkNativeBufferUsage2ANDROID
  VkSwapchainImageCreateInfoANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    usage*: VkSwapchainImageUsageFlagsANDROID
  VkPhysicalDevicePresentationPropertiesANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    sharedImage*: VkBool32
  VkShaderResourceUsageAMD* = object
    numUsedVgprs*: uint32
    numUsedSgprs*: uint32
    ldsSizePerLocalWorkGroup*: uint32
    ldsUsageSizeInBytes*: uint
    scratchMemUsageInBytes*: uint
  VkShaderStatisticsInfoAMD* = object
    shaderStageMask*: VkShaderStageFlags
    resourceUsage*: VkShaderResourceUsageAMD
    numPhysicalVgprs*: uint32
    numPhysicalSgprs*: uint32
    numAvailableVgprs*: uint32
    numAvailableSgprs*: uint32
    computeWorkGroupSize*: array[3, uint32]
  VkDeviceQueueGlobalPriorityCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    globalPriority*: VkQueueGlobalPriorityEXT
  VkDebugUtilsObjectNameInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    objectType*: VkObjectType
    objectHandle*: uint64
    pObjectName*: cstring
  VkDebugUtilsObjectTagInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    objectType*: VkObjectType
    objectHandle*: uint64
    tagName*: uint64
    tagSize*: uint
    pTag*: pointer
  VkDebugUtilsLabelEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    pLabelName*: cstring
    color*: array[4, float32]
  VkDebugUtilsMessengerCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDebugUtilsMessengerCreateFlagsEXT
    messageSeverity*: VkDebugUtilsMessageSeverityFlagsEXT
    messageType*: VkDebugUtilsMessageTypeFlagsEXT
    pfnUserCallback*: PFN_vkDebugUtilsMessengerCallbackEXT
    pUserData*: pointer
  VkDebugUtilsMessengerCallbackDataEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDebugUtilsMessengerCallbackDataFlagsEXT
    pMessageIdName*: cstring
    messageIdNumber*: int32
    pMessage*: cstring
    queueLabelCount*: uint32
    pQueueLabels*: ptr VkDebugUtilsLabelEXT
    cmdBufLabelCount*: uint32
    pCmdBufLabels*: ptr VkDebugUtilsLabelEXT
    objectCount*: uint32
    pObjects*: ptr VkDebugUtilsObjectNameInfoEXT
  VkImportMemoryHostPointerInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    handleType*: VkExternalMemoryHandleTypeFlagBits
    pHostPointer*: pointer
  VkMemoryHostPointerPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryTypeBits*: uint32
  VkPhysicalDeviceExternalMemoryHostPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    minImportedHostPointerAlignment*: VkDeviceSize
  VkPhysicalDeviceConservativeRasterizationPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    primitiveOverestimationSize*: float32
    maxExtraPrimitiveOverestimationSize*: float32
    extraPrimitiveOverestimationSizeGranularity*: float32
    primitiveUnderestimation*: VkBool32
    conservativePointAndLineRasterization*: VkBool32
    degenerateTrianglesRasterized*: VkBool32
    degenerateLinesRasterized*: VkBool32
    fullyCoveredFragmentShaderInputVariable*: VkBool32
    conservativeRasterizationPostDepthCoverage*: VkBool32
  VkCalibratedTimestampInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    timeDomain*: VkTimeDomainEXT
  VkPhysicalDeviceShaderCorePropertiesAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderEngineCount*: uint32
    shaderArraysPerEngineCount*: uint32
    computeUnitsPerShaderArray*: uint32
    simdPerComputeUnit*: uint32
    wavefrontsPerSimd*: uint32
    wavefrontSize*: uint32
    sgprsPerSimd*: uint32
    minSgprAllocation*: uint32
    maxSgprAllocation*: uint32
    sgprAllocationGranularity*: uint32
    vgprsPerSimd*: uint32
    minVgprAllocation*: uint32
    maxVgprAllocation*: uint32
    vgprAllocationGranularity*: uint32
  VkPhysicalDeviceShaderCoreProperties2AMD* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderCoreFeatures*: VkShaderCorePropertiesFlagsAMD
    activeComputeUnitCount*: uint32
  VkPipelineRasterizationConservativeStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineRasterizationConservativeStateCreateFlagsEXT
    conservativeRasterizationMode*: VkConservativeRasterizationModeEXT
    extraPrimitiveOverestimationSize*: float32
  VkPhysicalDeviceDescriptorIndexingFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderInputAttachmentArrayDynamicIndexing*: VkBool32
    shaderUniformTexelBufferArrayDynamicIndexing*: VkBool32
    shaderStorageTexelBufferArrayDynamicIndexing*: VkBool32
    shaderUniformBufferArrayNonUniformIndexing*: VkBool32
    shaderSampledImageArrayNonUniformIndexing*: VkBool32
    shaderStorageBufferArrayNonUniformIndexing*: VkBool32
    shaderStorageImageArrayNonUniformIndexing*: VkBool32
    shaderInputAttachmentArrayNonUniformIndexing*: VkBool32
    shaderUniformTexelBufferArrayNonUniformIndexing*: VkBool32
    shaderStorageTexelBufferArrayNonUniformIndexing*: VkBool32
    descriptorBindingUniformBufferUpdateAfterBind*: VkBool32
    descriptorBindingSampledImageUpdateAfterBind*: VkBool32
    descriptorBindingStorageImageUpdateAfterBind*: VkBool32
    descriptorBindingStorageBufferUpdateAfterBind*: VkBool32
    descriptorBindingUniformTexelBufferUpdateAfterBind*: VkBool32
    descriptorBindingStorageTexelBufferUpdateAfterBind*: VkBool32
    descriptorBindingUpdateUnusedWhilePending*: VkBool32
    descriptorBindingPartiallyBound*: VkBool32
    descriptorBindingVariableDescriptorCount*: VkBool32
    runtimeDescriptorArray*: VkBool32
  VkPhysicalDeviceDescriptorIndexingFeaturesEXT* = object
  VkPhysicalDeviceDescriptorIndexingProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    maxUpdateAfterBindDescriptorsInAllPools*: uint32
    shaderUniformBufferArrayNonUniformIndexingNative*: VkBool32
    shaderSampledImageArrayNonUniformIndexingNative*: VkBool32
    shaderStorageBufferArrayNonUniformIndexingNative*: VkBool32
    shaderStorageImageArrayNonUniformIndexingNative*: VkBool32
    shaderInputAttachmentArrayNonUniformIndexingNative*: VkBool32
    robustBufferAccessUpdateAfterBind*: VkBool32
    quadDivergentImplicitLod*: VkBool32
    maxPerStageDescriptorUpdateAfterBindSamplers*: uint32
    maxPerStageDescriptorUpdateAfterBindUniformBuffers*: uint32
    maxPerStageDescriptorUpdateAfterBindStorageBuffers*: uint32
    maxPerStageDescriptorUpdateAfterBindSampledImages*: uint32
    maxPerStageDescriptorUpdateAfterBindStorageImages*: uint32
    maxPerStageDescriptorUpdateAfterBindInputAttachments*: uint32
    maxPerStageUpdateAfterBindResources*: uint32
    maxDescriptorSetUpdateAfterBindSamplers*: uint32
    maxDescriptorSetUpdateAfterBindUniformBuffers*: uint32
    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic*: uint32
    maxDescriptorSetUpdateAfterBindStorageBuffers*: uint32
    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic*: uint32
    maxDescriptorSetUpdateAfterBindSampledImages*: uint32
    maxDescriptorSetUpdateAfterBindStorageImages*: uint32
    maxDescriptorSetUpdateAfterBindInputAttachments*: uint32
  VkPhysicalDeviceDescriptorIndexingPropertiesEXT* = object
  VkDescriptorSetLayoutBindingFlagsCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    bindingCount*: uint32
    pBindingFlags*: ptr VkDescriptorBindingFlags
  VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* = object
  VkDescriptorSetVariableDescriptorCountAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    descriptorSetCount*: uint32
    pDescriptorCounts*: ptr uint32
  VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* = object
  VkDescriptorSetVariableDescriptorCountLayoutSupport* = object
    sType*: VkStructureType
    pNext*: pointer
    maxVariableDescriptorCount*: uint32
  VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* = object
  VkAttachmentDescription2* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkAttachmentDescriptionFlags
    format*: VkFormat
    samples*: VkSampleCountFlagBits
    loadOp*: VkAttachmentLoadOp
    storeOp*: VkAttachmentStoreOp
    stencilLoadOp*: VkAttachmentLoadOp
    stencilStoreOp*: VkAttachmentStoreOp
    initialLayout*: VkImageLayout
    finalLayout*: VkImageLayout
  VkAttachmentDescription2KHR* = object
  VkAttachmentReference2* = object
    sType*: VkStructureType
    pNext*: pointer
    attachment*: uint32
    layout*: VkImageLayout
    aspectMask*: VkImageAspectFlags
  VkAttachmentReference2KHR* = object
  VkSubpassDescription2* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkSubpassDescriptionFlags
    pipelineBindPoint*: VkPipelineBindPoint
    viewMask*: uint32
    inputAttachmentCount*: uint32
    pInputAttachments*: ptr VkAttachmentReference2
    colorAttachmentCount*: uint32
    pColorAttachments*: ptr VkAttachmentReference2
    pResolveAttachments*: ptr VkAttachmentReference2
    pDepthStencilAttachment*: ptr VkAttachmentReference2
    preserveAttachmentCount*: uint32
    pPreserveAttachments*: ptr uint32
  VkSubpassDescription2KHR* = object
  VkSubpassDependency2* = object
    sType*: VkStructureType
    pNext*: pointer
    srcSubpass*: uint32
    dstSubpass*: uint32
    srcStageMask*: VkPipelineStageFlags
    dstStageMask*: VkPipelineStageFlags
    srcAccessMask*: VkAccessFlags
    dstAccessMask*: VkAccessFlags
    dependencyFlags*: VkDependencyFlags
    viewOffset*: int32
  VkSubpassDependency2KHR* = object
  VkRenderPassCreateInfo2* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkRenderPassCreateFlags
    attachmentCount*: uint32
    pAttachments*: ptr VkAttachmentDescription2
    subpassCount*: uint32
    pSubpasses*: ptr VkSubpassDescription2
    dependencyCount*: uint32
    pDependencies*: ptr VkSubpassDependency2
    correlatedViewMaskCount*: uint32
    pCorrelatedViewMasks*: ptr uint32
  VkRenderPassCreateInfo2KHR* = object
  VkSubpassBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    contents*: VkSubpassContents
  VkSubpassBeginInfoKHR* = object
  VkSubpassEndInfo* = object
    sType*: VkStructureType
    pNext*: pointer
  VkSubpassEndInfoKHR* = object
  VkPhysicalDeviceTimelineSemaphoreFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    timelineSemaphore*: VkBool32
  VkPhysicalDeviceTimelineSemaphoreFeaturesKHR* = object
  VkPhysicalDeviceTimelineSemaphoreProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    maxTimelineSemaphoreValueDifference*: uint64
  VkPhysicalDeviceTimelineSemaphorePropertiesKHR* = object
  VkSemaphoreTypeCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphoreType*: VkSemaphoreType
    initialValue*: uint64
  VkSemaphoreTypeCreateInfoKHR* = object
  VkTimelineSemaphoreSubmitInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    waitSemaphoreValueCount*: uint32
    pWaitSemaphoreValues*: ptr uint64
    signalSemaphoreValueCount*: uint32
    pSignalSemaphoreValues*: ptr uint64
  VkTimelineSemaphoreSubmitInfoKHR* = object
  VkSemaphoreWaitInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkSemaphoreWaitFlags
    semaphoreCount*: uint32
    pSemaphores*: ptr VkSemaphore
    pValues*: ptr uint64
  VkSemaphoreWaitInfoKHR* = object
  VkSemaphoreSignalInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    semaphore*: VkSemaphore
    value*: uint64
  VkSemaphoreSignalInfoKHR* = object
  VkVertexInputBindingDivisorDescriptionEXT* = object
    binding*: uint32
    divisor*: uint32
  VkPipelineVertexInputDivisorStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    vertexBindingDivisorCount*: uint32
    pVertexBindingDivisors*: ptr VkVertexInputBindingDivisorDescriptionEXT
  VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxVertexAttribDivisor*: uint32
  VkPhysicalDevicePCIBusInfoPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    pciDomain*: uint32
    pciBus*: uint32
    pciDevice*: uint32
    pciFunction*: uint32
  VkImportAndroidHardwareBufferInfoANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    buffer*: ptr AHardwareBuffer
  VkAndroidHardwareBufferUsageANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    androidHardwareBufferUsage*: uint64
  VkAndroidHardwareBufferPropertiesANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    allocationSize*: VkDeviceSize
    memoryTypeBits*: uint32
  VkMemoryGetAndroidHardwareBufferInfoANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    memory*: VkDeviceMemory
  VkAndroidHardwareBufferFormatPropertiesANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    format*: VkFormat
    externalFormat*: uint64
    formatFeatures*: VkFormatFeatureFlags
    samplerYcbcrConversionComponents*: VkComponentMapping
    suggestedYcbcrModel*: VkSamplerYcbcrModelConversion
    suggestedYcbcrRange*: VkSamplerYcbcrRange
    suggestedXChromaOffset*: VkChromaLocation
    suggestedYChromaOffset*: VkChromaLocation
  VkCommandBufferInheritanceConditionalRenderingInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    conditionalRenderingEnable*: VkBool32
  VkExternalFormatANDROID* = object
    sType*: VkStructureType
    pNext*: pointer
    externalFormat*: uint64
  VkPhysicalDevice8BitStorageFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    storageBuffer8BitAccess*: VkBool32
    uniformAndStorageBuffer8BitAccess*: VkBool32
    storagePushConstant8*: VkBool32
  VkPhysicalDevice8BitStorageFeaturesKHR* = object
  VkPhysicalDeviceConditionalRenderingFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    conditionalRendering*: VkBool32
    inheritedConditionalRendering*: VkBool32
  VkPhysicalDeviceVulkanMemoryModelFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    vulkanMemoryModel*: VkBool32
    vulkanMemoryModelDeviceScope*: VkBool32
    vulkanMemoryModelAvailabilityVisibilityChains*: VkBool32
  VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* = object
  VkPhysicalDeviceShaderAtomicInt64Features* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderBufferInt64Atomics*: VkBool32
    shaderSharedInt64Atomics*: VkBool32
  VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* = object
  VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderBufferFloat32Atomics*: VkBool32
    shaderBufferFloat32AtomicAdd*: VkBool32
    shaderBufferFloat64Atomics*: VkBool32
    shaderBufferFloat64AtomicAdd*: VkBool32
    shaderSharedFloat32Atomics*: VkBool32
    shaderSharedFloat32AtomicAdd*: VkBool32
    shaderSharedFloat64Atomics*: VkBool32
    shaderSharedFloat64AtomicAdd*: VkBool32
    shaderImageFloat32Atomics*: VkBool32
    shaderImageFloat32AtomicAdd*: VkBool32
    sparseImageFloat32Atomics*: VkBool32
    sparseImageFloat32AtomicAdd*: VkBool32
  VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    vertexAttributeInstanceRateDivisor*: VkBool32
    vertexAttributeInstanceRateZeroDivisor*: VkBool32
  VkQueueFamilyCheckpointPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    checkpointExecutionStageMask*: VkPipelineStageFlags
  VkCheckpointDataNV* = object
    sType*: VkStructureType
    pNext*: pointer
    stage*: VkPipelineStageFlagBits
    pCheckpointMarker*: pointer
  VkPhysicalDeviceDepthStencilResolveProperties* = object
    sType*: VkStructureType
    pNext*: pointer
    supportedDepthResolveModes*: VkResolveModeFlags
    supportedStencilResolveModes*: VkResolveModeFlags
    independentResolveNone*: VkBool32
    independentResolve*: VkBool32
  VkPhysicalDeviceDepthStencilResolvePropertiesKHR* = object
  VkSubpassDescriptionDepthStencilResolve* = object
    sType*: VkStructureType
    pNext*: pointer
    depthResolveMode*: VkResolveModeFlagBits
    stencilResolveMode*: VkResolveModeFlagBits
    pDepthStencilResolveAttachment*: ptr VkAttachmentReference2
  VkSubpassDescriptionDepthStencilResolveKHR* = object
  VkImageViewASTCDecodeModeEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    decodeMode*: VkFormat
  VkPhysicalDeviceASTCDecodeFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    decodeModeSharedExponent*: VkBool32
  VkPhysicalDeviceTransformFeedbackFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    transformFeedback*: VkBool32
    geometryStreams*: VkBool32
  VkPhysicalDeviceTransformFeedbackPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxTransformFeedbackStreams*: uint32
    maxTransformFeedbackBuffers*: uint32
    maxTransformFeedbackBufferSize*: VkDeviceSize
    maxTransformFeedbackStreamDataSize*: uint32
    maxTransformFeedbackBufferDataSize*: uint32
    maxTransformFeedbackBufferDataStride*: uint32
    transformFeedbackQueries*: VkBool32
    transformFeedbackStreamsLinesTriangles*: VkBool32
    transformFeedbackRasterizationStreamSelect*: VkBool32
    transformFeedbackDraw*: VkBool32
  VkPipelineRasterizationStateStreamCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineRasterizationStateStreamCreateFlagsEXT
    rasterizationStream*: uint32
  VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    representativeFragmentTest*: VkBool32
  VkPipelineRepresentativeFragmentTestStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    representativeFragmentTestEnable*: VkBool32
  VkPhysicalDeviceExclusiveScissorFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    exclusiveScissor*: VkBool32
  VkPipelineViewportExclusiveScissorStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    exclusiveScissorCount*: uint32
    pExclusiveScissors*: ptr VkRect2D
  VkPhysicalDeviceCornerSampledImageFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    cornerSampledImage*: VkBool32
  VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    computeDerivativeGroupQuads*: VkBool32
    computeDerivativeGroupLinear*: VkBool32
  VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    fragmentShaderBarycentric*: VkBool32
  VkPhysicalDeviceShaderImageFootprintFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    imageFootprint*: VkBool32
  VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    dedicatedAllocationImageAliasing*: VkBool32
  VkShadingRatePaletteNV* = object
    shadingRatePaletteEntryCount*: uint32
    pShadingRatePaletteEntries*: ptr VkShadingRatePaletteEntryNV
  VkPipelineViewportShadingRateImageStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shadingRateImageEnable*: VkBool32
    viewportCount*: uint32
    pShadingRatePalettes*: ptr VkShadingRatePaletteNV
  VkPhysicalDeviceShadingRateImageFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shadingRateImage*: VkBool32
    shadingRateCoarseSampleOrder*: VkBool32
  VkPhysicalDeviceShadingRateImagePropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shadingRateTexelSize*: VkExtent2D
    shadingRatePaletteSize*: uint32
    shadingRateMaxCoarseSamples*: uint32
  VkCoarseSampleLocationNV* = object
    pixelX*: uint32
    pixelY*: uint32
    sample*: uint32
  VkCoarseSampleOrderCustomNV* = object
    shadingRate*: VkShadingRatePaletteEntryNV
    sampleCount*: uint32
    sampleLocationCount*: uint32
    pSampleLocations*: ptr VkCoarseSampleLocationNV
  VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    sampleOrderType*: VkCoarseSampleOrderTypeNV
    customSampleOrderCount*: uint32
    pCustomSampleOrders*: ptr VkCoarseSampleOrderCustomNV
  VkPhysicalDeviceMeshShaderFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    taskShader*: VkBool32
    meshShader*: VkBool32
  VkPhysicalDeviceMeshShaderPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    maxDrawMeshTasksCount*: uint32
    maxTaskWorkGroupInvocations*: uint32
    maxTaskWorkGroupSize*: array[3, uint32]
    maxTaskTotalMemorySize*: uint32
    maxTaskOutputCount*: uint32
    maxMeshWorkGroupInvocations*: uint32
    maxMeshWorkGroupSize*: array[3, uint32]
    maxMeshTotalMemorySize*: uint32
    maxMeshOutputVertices*: uint32
    maxMeshOutputPrimitives*: uint32
    maxMeshMultiviewViewCount*: uint32
    meshOutputPerVertexGranularity*: uint32
    meshOutputPerPrimitiveGranularity*: uint32
  VkDrawMeshTasksIndirectCommandNV* = object
    taskCount*: uint32
    firstTask*: uint32
  VkRayTracingShaderGroupCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    typee*: VkRayTracingShaderGroupTypeKHR
    generalShader*: uint32
    closestHitShader*: uint32
    anyHitShader*: uint32
    intersectionShader*: uint32
  VkRayTracingShaderGroupCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    typee*: VkRayTracingShaderGroupTypeKHR
    generalShader*: uint32
    closestHitShader*: uint32
    anyHitShader*: uint32
    intersectionShader*: uint32
    pShaderGroupCaptureReplayHandle*: pointer
  VkRayTracingPipelineCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCreateFlags
    stageCount*: uint32
    pStages*: ptr VkPipelineShaderStageCreateInfo
    groupCount*: uint32
    pGroups*: ptr VkRayTracingShaderGroupCreateInfoNV
    maxRecursionDepth*: uint32
    layout*: VkPipelineLayout
    basePipelineHandle*: VkPipeline
    basePipelineIndex*: int32
  VkRayTracingPipelineCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCreateFlags
    stageCount*: uint32
    pStages*: ptr VkPipelineShaderStageCreateInfo
    groupCount*: uint32
    pGroups*: ptr VkRayTracingShaderGroupCreateInfoKHR
    maxRecursionDepth*: uint32
    libraries*: VkPipelineLibraryCreateInfoKHR
    pLibraryInterface*: ptr VkRayTracingPipelineInterfaceCreateInfoKHR
    layout*: VkPipelineLayout
    basePipelineHandle*: VkPipeline
    basePipelineIndex*: int32
  VkGeometryTrianglesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    vertexData*: VkBuffer
    vertexOffset*: VkDeviceSize
    vertexCount*: uint32
    vertexStride*: VkDeviceSize
    vertexFormat*: VkFormat
    indexData*: VkBuffer
    indexOffset*: VkDeviceSize
    indexCount*: uint32
    indexType*: VkIndexType
    transformData*: VkBuffer
    transformOffset*: VkDeviceSize
  VkGeometryAABBNV* = object
    sType*: VkStructureType
    pNext*: pointer
    aabbData*: VkBuffer
    numAABBs*: uint32
    stride*: uint32
    offset*: VkDeviceSize
  VkGeometryDataNV* = object
    triangles*: VkGeometryTrianglesNV
    aabbs*: VkGeometryAABBNV
  VkGeometryNV* = object
    sType*: VkStructureType
    pNext*: pointer
    geometryType*: VkGeometryTypeKHR
    geometry*: VkGeometryDataNV
    flags*: VkGeometryFlagsKHR
  VkAccelerationStructureInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    typee*: VkAccelerationStructureTypeNV
    flags*: VkBuildAccelerationStructureFlagsNV
    instanceCount*: uint32
    geometryCount*: uint32
    pGeometries*: ptr VkGeometryNV
  VkAccelerationStructureCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    compactedSize*: VkDeviceSize
    info*: VkAccelerationStructureInfoNV
  VkBindAccelerationStructureMemoryInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    accelerationStructure*: VkAccelerationStructureKHR
    memory*: VkDeviceMemory
    memoryOffset*: VkDeviceSize
    deviceIndexCount*: uint32
    pDeviceIndices*: ptr uint32
  VkBindAccelerationStructureMemoryInfoNV* = object
  VkWriteDescriptorSetAccelerationStructureKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    accelerationStructureCount*: uint32
    pAccelerationStructures*: ptr VkAccelerationStructureKHR
  VkWriteDescriptorSetAccelerationStructureNV* = object
  VkAccelerationStructureMemoryRequirementsInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    typee*: VkAccelerationStructureMemoryRequirementsTypeKHR
    buildType*: VkAccelerationStructureBuildTypeKHR
    accelerationStructure*: VkAccelerationStructureKHR
  VkAccelerationStructureMemoryRequirementsInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    typee*: VkAccelerationStructureMemoryRequirementsTypeNV
    accelerationStructure*: VkAccelerationStructureNV
  VkPhysicalDeviceRayTracingFeaturesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    rayTracing*: VkBool32
    rayTracingShaderGroupHandleCaptureReplay*: VkBool32
    rayTracingShaderGroupHandleCaptureReplayMixed*: VkBool32
    rayTracingAccelerationStructureCaptureReplay*: VkBool32
    rayTracingIndirectTraceRays*: VkBool32
    rayTracingIndirectAccelerationStructureBuild*: VkBool32
    rayTracingHostAccelerationStructureCommands*: VkBool32
    rayQuery*: VkBool32
    rayTracingPrimitiveCulling*: VkBool32
  VkPhysicalDeviceRayTracingPropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderGroupHandleSize*: uint32
    maxRecursionDepth*: uint32
    maxShaderGroupStride*: uint32
    shaderGroupBaseAlignment*: uint32
    maxGeometryCount*: uint64
    maxInstanceCount*: uint64
    maxPrimitiveCount*: uint64
    maxDescriptorSetAccelerationStructures*: uint32
    shaderGroupHandleCaptureReplaySize*: uint32
  VkPhysicalDeviceRayTracingPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderGroupHandleSize*: uint32
    maxRecursionDepth*: uint32
    maxShaderGroupStride*: uint32
    shaderGroupBaseAlignment*: uint32
    maxGeometryCount*: uint64
    maxInstanceCount*: uint64
    maxTriangleCount*: uint64
    maxDescriptorSetAccelerationStructures*: uint32
  VkStridedBufferRegionKHR* = object
    buffer*: VkBuffer
    offset*: VkDeviceSize
    stride*: VkDeviceSize
    size*: VkDeviceSize
  VkTraceRaysIndirectCommandKHR* = object
    width*: uint32
    height*: uint32
    depth*: uint32
  VkDrmFormatModifierPropertiesListEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    drmFormatModifierCount*: uint32
    pDrmFormatModifierProperties*: ptr VkDrmFormatModifierPropertiesEXT
  VkDrmFormatModifierPropertiesEXT* = object
    drmFormatModifier*: uint64
    drmFormatModifierPlaneCount*: uint32
    drmFormatModifierTilingFeatures*: VkFormatFeatureFlags
  VkPhysicalDeviceImageDrmFormatModifierInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    drmFormatModifier*: uint64
    sharingMode*: VkSharingMode
    queueFamilyIndexCount*: uint32
    pQueueFamilyIndices*: ptr uint32
  VkImageDrmFormatModifierListCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    drmFormatModifierCount*: uint32
    pDrmFormatModifiers*: ptr uint64
  VkImageDrmFormatModifierExplicitCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    drmFormatModifier*: uint64
    drmFormatModifierPlaneCount*: uint32
    pPlaneLayouts*: ptr VkSubresourceLayout
  VkImageDrmFormatModifierPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    drmFormatModifier*: uint64
  VkImageStencilUsageCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    stencilUsage*: VkImageUsageFlags
  VkImageStencilUsageCreateInfoEXT* = object
  VkDeviceMemoryOverallocationCreateInfoAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    overallocationBehavior*: VkMemoryOverallocationBehaviorAMD
  VkPhysicalDeviceFragmentDensityMapFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fragmentDensityMap*: VkBool32
    fragmentDensityMapDynamic*: VkBool32
    fragmentDensityMapNonSubsampledImages*: VkBool32
  VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fragmentDensityMapDeferred*: VkBool32
  VkPhysicalDeviceFragmentDensityMapPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    minFragmentDensityTexelSize*: VkExtent2D
    maxFragmentDensityTexelSize*: VkExtent2D
    fragmentDensityInvocations*: VkBool32
  VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    subsampledLoads*: VkBool32
    subsampledCoarseReconstructionEarlyAccess*: VkBool32
    maxSubsampledArrayLayers*: uint32
    maxDescriptorSetSubsampledSamplers*: uint32
  VkRenderPassFragmentDensityMapCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fragmentDensityMapAttachment*: VkAttachmentReference
  VkPhysicalDeviceScalarBlockLayoutFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    scalarBlockLayout*: VkBool32
  VkPhysicalDeviceScalarBlockLayoutFeaturesEXT* = object
  VkSurfaceProtectedCapabilitiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    supportsProtected*: VkBool32
  VkPhysicalDeviceUniformBufferStandardLayoutFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    uniformBufferStandardLayout*: VkBool32
  VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* = object
  VkPhysicalDeviceDepthClipEnableFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    depthClipEnable*: VkBool32
  VkPipelineRasterizationDepthClipStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineRasterizationDepthClipStateCreateFlagsEXT
    depthClipEnable*: VkBool32
  VkPhysicalDeviceMemoryBudgetPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    heapBudget*: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize]
    heapUsage*: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize]
  VkPhysicalDeviceMemoryPriorityFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    memoryPriority*: VkBool32
  VkMemoryPriorityAllocateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    priority*: float32
  VkPhysicalDeviceBufferDeviceAddressFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    bufferDeviceAddress*: VkBool32
    bufferDeviceAddressCaptureReplay*: VkBool32
    bufferDeviceAddressMultiDevice*: VkBool32
  VkPhysicalDeviceBufferDeviceAddressFeaturesKHR* = object
  VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    bufferDeviceAddress*: VkBool32
    bufferDeviceAddressCaptureReplay*: VkBool32
    bufferDeviceAddressMultiDevice*: VkBool32
  VkPhysicalDeviceBufferAddressFeaturesEXT* = object
  VkBufferDeviceAddressInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    buffer*: VkBuffer
  VkBufferDeviceAddressInfoKHR* = object
  VkBufferDeviceAddressInfoEXT* = object
  VkBufferOpaqueCaptureAddressCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    opaqueCaptureAddress*: uint64
  VkBufferOpaqueCaptureAddressCreateInfoKHR* = object
  VkBufferDeviceAddressCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceAddress*: VkDeviceAddress
  VkPhysicalDeviceImageViewImageFormatInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    imageViewType*: VkImageViewType
  VkFilterCubicImageViewImageFormatPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    filterCubic*: VkBool32
    filterCubicMinmax*: VkBool32
  VkPhysicalDeviceImagelessFramebufferFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    imagelessFramebuffer*: VkBool32
  VkPhysicalDeviceImagelessFramebufferFeaturesKHR* = object
  VkFramebufferAttachmentsCreateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    attachmentImageInfoCount*: uint32
    pAttachmentImageInfos*: ptr VkFramebufferAttachmentImageInfo
  VkFramebufferAttachmentsCreateInfoKHR* = object
  VkFramebufferAttachmentImageInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkImageCreateFlags
    usage*: VkImageUsageFlags
    width*: uint32
    height*: uint32
    layerCount*: uint32
    viewFormatCount*: uint32
    pViewFormats*: ptr VkFormat
  VkFramebufferAttachmentImageInfoKHR* = object
  VkRenderPassAttachmentBeginInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    attachmentCount*: uint32
    pAttachments*: ptr VkImageView
  VkRenderPassAttachmentBeginInfoKHR* = object
  VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    textureCompressionASTC_HDR*: VkBool32
  VkPhysicalDeviceCooperativeMatrixFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    cooperativeMatrix*: VkBool32
    cooperativeMatrixRobustBufferAccess*: VkBool32
  VkPhysicalDeviceCooperativeMatrixPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    cooperativeMatrixSupportedStages*: VkShaderStageFlags
  VkCooperativeMatrixPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    MSize*: uint32
    NSize*: uint32
    KSize*: uint32
    AType*: VkComponentTypeNV
    BType*: VkComponentTypeNV
    CType*: VkComponentTypeNV
    DType*: VkComponentTypeNV
    scope*: VkScopeNV
  VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    ycbcrImageArrays*: VkBool32
  VkImageViewHandleInfoNVX* = object
    sType*: VkStructureType
    pNext*: pointer
    imageView*: VkImageView
    descriptorType*: VkDescriptorType
    sampler*: VkSampler
  VkImageViewAddressPropertiesNVX* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceAddress*: VkDeviceAddress
    size*: VkDeviceSize
  VkPresentFrameTokenGGP* = object
    sType*: VkStructureType
    pNext*: pointer
    frameToken*: GgpFrameToken
  VkPipelineCreationFeedbackEXT* = object
    flags*: VkPipelineCreationFeedbackFlagsEXT
    duration*: uint64
  VkPipelineCreationFeedbackCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    pPipelineCreationFeedback*: ptr VkPipelineCreationFeedbackEXT
    pipelineStageCreationFeedbackCount*: uint32
    pPipelineStageCreationFeedbacks*: ptr ptr VkPipelineCreationFeedbackEXT
  VkSurfaceFullScreenExclusiveInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fullScreenExclusive*: VkFullScreenExclusiveEXT
  VkSurfaceFullScreenExclusiveWin32InfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    hmonitor*: HMONITOR
  VkSurfaceCapabilitiesFullScreenExclusiveEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fullScreenExclusiveSupported*: VkBool32
  VkPhysicalDevicePerformanceQueryFeaturesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    performanceCounterQueryPools*: VkBool32
    performanceCounterMultipleQueryPools*: VkBool32
  VkPhysicalDevicePerformanceQueryPropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    allowCommandBufferQueryCopies*: VkBool32
  VkPerformanceCounterKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    unit*: VkPerformanceCounterUnitKHR
    scope*: VkPerformanceCounterScopeKHR
    storage*: VkPerformanceCounterStorageKHR
    uuid*: array[VK_UUID_SIZE, uint8]
  VkPerformanceCounterDescriptionKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPerformanceCounterDescriptionFlagsKHR
    name*: array[VK_MAX_DESCRIPTION_SIZE, char]
    category*: array[VK_MAX_DESCRIPTION_SIZE, char]
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]
  VkQueryPoolPerformanceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    queueFamilyIndex*: uint32
    counterIndexCount*: uint32
    pCounterIndices*: ptr uint32
  VkPerformanceCounterResultKHR* {.union.} = object
    int32*: int32
    int64*: int64
    uint32*: uint32
    uint64*: uint64
    float32*: float32
    float64*: float64
  VkAcquireProfilingLockInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkAcquireProfilingLockFlagsKHR
    timeout*: uint64
  VkPerformanceQuerySubmitInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    counterPassIndex*: uint32
  VkHeadlessSurfaceCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkHeadlessSurfaceCreateFlagsEXT
  VkPhysicalDeviceCoverageReductionModeFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    coverageReductionMode*: VkBool32
  VkPipelineCoverageReductionStateCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkPipelineCoverageReductionStateCreateFlagsNV
    coverageReductionMode*: VkCoverageReductionModeNV
  VkFramebufferMixedSamplesCombinationNV* = object
    sType*: VkStructureType
    pNext*: pointer
    coverageReductionMode*: VkCoverageReductionModeNV
    rasterizationSamples*: VkSampleCountFlagBits
    depthStencilSamples*: VkSampleCountFlags
    colorSamples*: VkSampleCountFlags
  VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderIntegerFunctions2*: VkBool32
  VkPerformanceValueDataINTEL* {.union.} = object
    value32*: uint32
    value64*: uint64
    valueFloat*: float32
    valueBool*: VkBool32
    valueString*: cstring
  VkPerformanceValueINTEL* = object
    typee*: VkPerformanceValueTypeINTEL
    data*: VkPerformanceValueDataINTEL
  VkInitializePerformanceApiInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    pUserData*: pointer
  VkQueryPoolPerformanceQueryCreateInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    performanceCountersSampling*: VkQueryPoolSamplingModeINTEL
  VkQueryPoolCreateInfoINTEL* = object
  VkPerformanceMarkerInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    marker*: uint64
  VkPerformanceStreamMarkerInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    marker*: uint32
  VkPerformanceOverrideInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    typee*: VkPerformanceOverrideTypeINTEL
    enable*: VkBool32
    parameter*: uint64
  VkPerformanceConfigurationAcquireInfoINTEL* = object
    sType*: VkStructureType
    pNext*: pointer
    typee*: VkPerformanceConfigurationTypeINTEL
  VkPhysicalDeviceShaderClockFeaturesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderSubgroupClock*: VkBool32
    shaderDeviceClock*: VkBool32
  VkPhysicalDeviceIndexTypeUint8FeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    indexTypeUint8*: VkBool32
  VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderSMCount*: uint32
    shaderWarpsPerSM*: uint32
  VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderSMBuiltins*: VkBool32
  VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    fragmentShaderSampleInterlock*: VkBool32
    fragmentShaderPixelInterlock*: VkBool32
    fragmentShaderShadingRateInterlock*: VkBool32
  VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* = object
    sType*: VkStructureType
    pNext*: pointer
    separateDepthStencilLayouts*: VkBool32
  VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR* = object
  VkAttachmentReferenceStencilLayout* = object
    sType*: VkStructureType
    pNext*: pointer
    stencilLayout*: VkImageLayout
  VkAttachmentReferenceStencilLayoutKHR* = object
  VkAttachmentDescriptionStencilLayout* = object
    sType*: VkStructureType
    pNext*: pointer
    stencilInitialLayout*: VkImageLayout
    stencilFinalLayout*: VkImageLayout
  VkAttachmentDescriptionStencilLayoutKHR* = object
  VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pipelineExecutableInfo*: VkBool32
  VkPipelineInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pipeline*: VkPipeline
  VkPipelineExecutablePropertiesKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    stages*: VkShaderStageFlags
    name*: array[VK_MAX_DESCRIPTION_SIZE, char]
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]
    subgroupSize*: uint32
  VkPipelineExecutableInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    pipeline*: VkPipeline
    executableIndex*: uint32
  VkPipelineExecutableStatisticValueKHR* {.union.} = object
    b32*: VkBool32
    i64*: int64
    u64*: uint64
    f64*: float64
  VkPipelineExecutableStatisticKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    name*: array[VK_MAX_DESCRIPTION_SIZE, char]
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]
    format*: VkPipelineExecutableStatisticFormatKHR
    value*: VkPipelineExecutableStatisticValueKHR
  VkPipelineExecutableInternalRepresentationKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    name*: array[VK_MAX_DESCRIPTION_SIZE, char]
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]
    isText*: VkBool32
    dataSize*: uint
    pData*: pointer
  VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    shaderDemoteToHelperInvocation*: VkBool32
  VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    texelBufferAlignment*: VkBool32
  VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    storageTexelBufferOffsetAlignmentBytes*: VkDeviceSize
    storageTexelBufferOffsetSingleTexelAlignment*: VkBool32
    uniformTexelBufferOffsetAlignmentBytes*: VkDeviceSize
    uniformTexelBufferOffsetSingleTexelAlignment*: VkBool32
  VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    subgroupSizeControl*: VkBool32
    computeFullSubgroups*: VkBool32
  VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    minSubgroupSize*: uint32
    maxSubgroupSize*: uint32
    maxComputeWorkgroupSubgroups*: uint32
    requiredSubgroupSizeStages*: VkShaderStageFlags
  VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    requiredSubgroupSize*: uint32
  VkMemoryOpaqueCaptureAddressAllocateInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    opaqueCaptureAddress*: uint64
  VkMemoryOpaqueCaptureAddressAllocateInfoKHR* = object
  VkDeviceMemoryOpaqueCaptureAddressInfo* = object
    sType*: VkStructureType
    pNext*: pointer
    memory*: VkDeviceMemory
  VkDeviceMemoryOpaqueCaptureAddressInfoKHR* = object
  VkPhysicalDeviceLineRasterizationFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    rectangularLines*: VkBool32
    bresenhamLines*: VkBool32
    smoothLines*: VkBool32
    stippledRectangularLines*: VkBool32
    stippledBresenhamLines*: VkBool32
    stippledSmoothLines*: VkBool32
  VkPhysicalDeviceLineRasterizationPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    lineSubPixelPrecisionBits*: uint32
  VkPipelineRasterizationLineStateCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    lineRasterizationMode*: VkLineRasterizationModeEXT
    stippledLineEnable*: VkBool32
    lineStippleFactor*: uint32
    lineStipplePattern*: uint16
  VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    pipelineCreationCacheControl*: VkBool32
  VkPhysicalDeviceVulkan11Features* = object
    sType*: VkStructureType
    pNext*: pointer
    storageBuffer16BitAccess*: VkBool32
    uniformAndStorageBuffer16BitAccess*: VkBool32
    storagePushConstant16*: VkBool32
    storageInputOutput16*: VkBool32
    multiview*: VkBool32
    multiviewGeometryShader*: VkBool32
    multiviewTessellationShader*: VkBool32
    variablePointersStorageBuffer*: VkBool32
    variablePointers*: VkBool32
    protectedMemory*: VkBool32
    samplerYcbcrConversion*: VkBool32
    shaderDrawParameters*: VkBool32
  VkPhysicalDeviceVulkan11Properties* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceUUID*: array[VK_UUID_SIZE, uint8]
    driverUUID*: array[VK_UUID_SIZE, uint8]
    deviceLUID*: array[VK_LUID_SIZE, uint8]
    deviceNodeMask*: uint32
    deviceLUIDValid*: VkBool32
    subgroupSize*: uint32
    subgroupSupportedStages*: VkShaderStageFlags
    subgroupSupportedOperations*: VkSubgroupFeatureFlags
    subgroupQuadOperationsInAllStages*: VkBool32
    pointClippingBehavior*: VkPointClippingBehavior
    maxMultiviewViewCount*: uint32
    maxMultiviewInstanceIndex*: uint32
    protectedNoFault*: VkBool32
    maxPerSetDescriptors*: uint32
    maxMemoryAllocationSize*: VkDeviceSize
  VkPhysicalDeviceVulkan12Features* = object
    sType*: VkStructureType
    pNext*: pointer
    samplerMirrorClampToEdge*: VkBool32
    drawIndirectCount*: VkBool32
    storageBuffer8BitAccess*: VkBool32
    uniformAndStorageBuffer8BitAccess*: VkBool32
    storagePushConstant8*: VkBool32
    shaderBufferInt64Atomics*: VkBool32
    shaderSharedInt64Atomics*: VkBool32
    shaderFloat16*: VkBool32
    shaderInt8*: VkBool32
    descriptorIndexing*: VkBool32
    shaderInputAttachmentArrayDynamicIndexing*: VkBool32
    shaderUniformTexelBufferArrayDynamicIndexing*: VkBool32
    shaderStorageTexelBufferArrayDynamicIndexing*: VkBool32
    shaderUniformBufferArrayNonUniformIndexing*: VkBool32
    shaderSampledImageArrayNonUniformIndexing*: VkBool32
    shaderStorageBufferArrayNonUniformIndexing*: VkBool32
    shaderStorageImageArrayNonUniformIndexing*: VkBool32
    shaderInputAttachmentArrayNonUniformIndexing*: VkBool32
    shaderUniformTexelBufferArrayNonUniformIndexing*: VkBool32
    shaderStorageTexelBufferArrayNonUniformIndexing*: VkBool32
    descriptorBindingUniformBufferUpdateAfterBind*: VkBool32
    descriptorBindingSampledImageUpdateAfterBind*: VkBool32
    descriptorBindingStorageImageUpdateAfterBind*: VkBool32
    descriptorBindingStorageBufferUpdateAfterBind*: VkBool32
    descriptorBindingUniformTexelBufferUpdateAfterBind*: VkBool32
    descriptorBindingStorageTexelBufferUpdateAfterBind*: VkBool32
    descriptorBindingUpdateUnusedWhilePending*: VkBool32
    descriptorBindingPartiallyBound*: VkBool32
    descriptorBindingVariableDescriptorCount*: VkBool32
    runtimeDescriptorArray*: VkBool32
    samplerFilterMinmax*: VkBool32
    scalarBlockLayout*: VkBool32
    imagelessFramebuffer*: VkBool32
    uniformBufferStandardLayout*: VkBool32
    shaderSubgroupExtendedTypes*: VkBool32
    separateDepthStencilLayouts*: VkBool32
    hostQueryReset*: VkBool32
    timelineSemaphore*: VkBool32
    bufferDeviceAddress*: VkBool32
    bufferDeviceAddressCaptureReplay*: VkBool32
    bufferDeviceAddressMultiDevice*: VkBool32
    vulkanMemoryModel*: VkBool32
    vulkanMemoryModelDeviceScope*: VkBool32
    vulkanMemoryModelAvailabilityVisibilityChains*: VkBool32
    shaderOutputViewportIndex*: VkBool32
    shaderOutputLayer*: VkBool32
    subgroupBroadcastDynamicId*: VkBool32
  VkPhysicalDeviceVulkan12Properties* = object
    sType*: VkStructureType
    pNext*: pointer
    driverID*: VkDriverId
    driverName*: array[VK_MAX_DRIVER_NAME_SIZE, char]
    driverInfo*: array[VK_MAX_DRIVER_INFO_SIZE, char]
    conformanceVersion*: VkConformanceVersion
    denormBehaviorIndependence*: VkShaderFloatControlsIndependence
    roundingModeIndependence*: VkShaderFloatControlsIndependence
    shaderSignedZeroInfNanPreserveFloat16*: VkBool32
    shaderSignedZeroInfNanPreserveFloat32*: VkBool32
    shaderSignedZeroInfNanPreserveFloat64*: VkBool32
    shaderDenormPreserveFloat16*: VkBool32
    shaderDenormPreserveFloat32*: VkBool32
    shaderDenormPreserveFloat64*: VkBool32
    shaderDenormFlushToZeroFloat16*: VkBool32
    shaderDenormFlushToZeroFloat32*: VkBool32
    shaderDenormFlushToZeroFloat64*: VkBool32
    shaderRoundingModeRTEFloat16*: VkBool32
    shaderRoundingModeRTEFloat32*: VkBool32
    shaderRoundingModeRTEFloat64*: VkBool32
    shaderRoundingModeRTZFloat16*: VkBool32
    shaderRoundingModeRTZFloat32*: VkBool32
    shaderRoundingModeRTZFloat64*: VkBool32
    maxUpdateAfterBindDescriptorsInAllPools*: uint32
    shaderUniformBufferArrayNonUniformIndexingNative*: VkBool32
    shaderSampledImageArrayNonUniformIndexingNative*: VkBool32
    shaderStorageBufferArrayNonUniformIndexingNative*: VkBool32
    shaderStorageImageArrayNonUniformIndexingNative*: VkBool32
    shaderInputAttachmentArrayNonUniformIndexingNative*: VkBool32
    robustBufferAccessUpdateAfterBind*: VkBool32
    quadDivergentImplicitLod*: VkBool32
    maxPerStageDescriptorUpdateAfterBindSamplers*: uint32
    maxPerStageDescriptorUpdateAfterBindUniformBuffers*: uint32
    maxPerStageDescriptorUpdateAfterBindStorageBuffers*: uint32
    maxPerStageDescriptorUpdateAfterBindSampledImages*: uint32
    maxPerStageDescriptorUpdateAfterBindStorageImages*: uint32
    maxPerStageDescriptorUpdateAfterBindInputAttachments*: uint32
    maxPerStageUpdateAfterBindResources*: uint32
    maxDescriptorSetUpdateAfterBindSamplers*: uint32
    maxDescriptorSetUpdateAfterBindUniformBuffers*: uint32
    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic*: uint32
    maxDescriptorSetUpdateAfterBindStorageBuffers*: uint32
    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic*: uint32
    maxDescriptorSetUpdateAfterBindSampledImages*: uint32
    maxDescriptorSetUpdateAfterBindStorageImages*: uint32
    maxDescriptorSetUpdateAfterBindInputAttachments*: uint32
    supportedDepthResolveModes*: VkResolveModeFlags
    supportedStencilResolveModes*: VkResolveModeFlags
    independentResolveNone*: VkBool32
    independentResolve*: VkBool32
    filterMinmaxSingleComponentFormats*: VkBool32
    filterMinmaxImageComponentMapping*: VkBool32
    maxTimelineSemaphoreValueDifference*: uint64
    framebufferIntegerColorSampleCounts*: VkSampleCountFlags
  VkPipelineCompilerControlCreateInfoAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    compilerControlFlags*: VkPipelineCompilerControlFlagsAMD
  VkPhysicalDeviceCoherentMemoryFeaturesAMD* = object
    sType*: VkStructureType
    pNext*: pointer
    deviceCoherentMemory*: VkBool32
  VkPhysicalDeviceToolPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    name*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
    version*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
    purposes*: VkToolPurposeFlagsEXT
    description*: array[VK_MAX_DESCRIPTION_SIZE, char]
    layer*: array[VK_MAX_EXTENSION_NAME_SIZE, char]
  VkSamplerCustomBorderColorCreateInfoEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    customBorderColor*: VkClearColorValue
    format*: VkFormat
  VkPhysicalDeviceCustomBorderColorPropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    maxCustomBorderColorSamplers*: uint32
  VkPhysicalDeviceCustomBorderColorFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    customBorderColors*: VkBool32
    customBorderColorWithoutFormat*: VkBool32
  VkDeviceOrHostAddressKHR* {.union.} = object
    deviceAddress*: VkDeviceAddress
    hostAddress*: pointer
  VkDeviceOrHostAddressConstKHR* {.union.} = object
    deviceAddress*: VkDeviceAddress
    hostAddress*: pointer
  VkAccelerationStructureGeometryTrianglesDataKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    vertexFormat*: VkFormat
    vertexData*: VkDeviceOrHostAddressConstKHR
    vertexStride*: VkDeviceSize
    indexType*: VkIndexType
    indexData*: VkDeviceOrHostAddressConstKHR
    transformData*: VkDeviceOrHostAddressConstKHR
  VkAccelerationStructureGeometryAabbsDataKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    data*: VkDeviceOrHostAddressConstKHR
    stride*: VkDeviceSize
  VkAccelerationStructureGeometryInstancesDataKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    arrayOfPointers*: VkBool32
    data*: VkDeviceOrHostAddressConstKHR
  VkAccelerationStructureGeometryDataKHR* {.union.} = object
    triangles*: VkAccelerationStructureGeometryTrianglesDataKHR
    aabbs*: VkAccelerationStructureGeometryAabbsDataKHR
    instances*: VkAccelerationStructureGeometryInstancesDataKHR
  VkAccelerationStructureGeometryKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    geometryType*: VkGeometryTypeKHR
    geometry*: VkAccelerationStructureGeometryDataKHR
    flags*: VkGeometryFlagsKHR
  VkAccelerationStructureBuildGeometryInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    typee*: VkAccelerationStructureTypeKHR
    flags*: VkBuildAccelerationStructureFlagsKHR
    update*: VkBool32
    srcAccelerationStructure*: VkAccelerationStructureKHR
    dstAccelerationStructure*: VkAccelerationStructureKHR
    geometryArrayOfPointers*: VkBool32
    geometryCount*: uint32
    ppGeometries*: ptr ptr VkAccelerationStructureGeometryKHR
    scratchData*: VkDeviceOrHostAddressKHR
  VkAccelerationStructureBuildOffsetInfoKHR* = object
    primitiveCount*: uint32
    primitiveOffset*: uint32
    firstVertex*: uint32
    transformOffset*: uint32
  VkAccelerationStructureCreateGeometryTypeInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    geometryType*: VkGeometryTypeKHR
    maxPrimitiveCount*: uint32
    indexType*: VkIndexType
    maxVertexCount*: uint32
    vertexFormat*: VkFormat
    allowsTransforms*: VkBool32
  VkAccelerationStructureCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    compactedSize*: VkDeviceSize
    typee*: VkAccelerationStructureTypeKHR
    flags*: VkBuildAccelerationStructureFlagsKHR
    maxGeometryCount*: uint32
    pGeometryInfos*: ptr VkAccelerationStructureCreateGeometryTypeInfoKHR
    deviceAddress*: VkDeviceAddress
  VkAabbPositionsKHR* = object
    minX*: float32
    minY*: float32
    minZ*: float32
    maxX*: float32
    maxY*: float32
    maxZ*: float32
  VkAabbPositionsNV* = object
  VkTransformMatrixKHR* = object
    matrix*: array[3, float32]
  VkTransformMatrixNV* = object
  VkAccelerationStructureInstanceKHR* = object
    transform*: VkTransformMatrixKHR
    instanceCustomIndex*: uint32
    mask*: uint32
    instanceShaderBindingTableRecordOffset*: uint32
    flags*: VkGeometryInstanceFlagsKHR
    accelerationStructureReference*: uint64
  VkAccelerationStructureInstanceNV* = object
  VkAccelerationStructureDeviceAddressInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    accelerationStructure*: VkAccelerationStructureKHR
  VkAccelerationStructureVersionKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    versionData*: ptr uint8
  VkCopyAccelerationStructureInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    src*: VkAccelerationStructureKHR
    dst*: VkAccelerationStructureKHR
    mode*: VkCopyAccelerationStructureModeKHR
  VkCopyAccelerationStructureToMemoryInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    src*: VkAccelerationStructureKHR
    dst*: VkDeviceOrHostAddressKHR
    mode*: VkCopyAccelerationStructureModeKHR
  VkCopyMemoryToAccelerationStructureInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    src*: VkDeviceOrHostAddressConstKHR
    dst*: VkAccelerationStructureKHR
    mode*: VkCopyAccelerationStructureModeKHR
  VkRayTracingPipelineInterfaceCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    maxPayloadSize*: uint32
    maxAttributeSize*: uint32
    maxCallableSize*: uint32
  VkDeferredOperationInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    operationHandle*: VkDeferredOperationKHR
  VkPipelineLibraryCreateInfoKHR* = object
    sType*: VkStructureType
    pNext*: pointer
    libraryCount*: uint32
    pLibraries*: ptr VkPipeline
  VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    extendedDynamicState*: VkBool32
  VkRenderPassTransformBeginInfoQCOM* = object
    sType*: VkStructureType
    pNext*: pointer
    transform*: VkSurfaceTransformFlagBitsKHR
  VkCommandBufferInheritanceRenderPassTransformInfoQCOM* = object
    sType*: VkStructureType
    pNext*: pointer
    transform*: VkSurfaceTransformFlagBitsKHR
    renderArea*: VkRect2D
  VkPhysicalDeviceDiagnosticsConfigFeaturesNV* = object
    sType*: VkStructureType
    pNext*: pointer
    diagnosticsConfig*: VkBool32
  VkDeviceDiagnosticsConfigCreateInfoNV* = object
    sType*: VkStructureType
    pNext*: pointer
    flags*: VkDeviceDiagnosticsConfigFlagsNV
  VkPhysicalDeviceRobustness2FeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    robustBufferAccess2*: VkBool32
    robustImageAccess2*: VkBool32
    nullDescriptor*: VkBool32
  VkPhysicalDeviceRobustness2PropertiesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    robustStorageBufferAccessSizeAlignment*: VkDeviceSize
    robustUniformBufferAccessSizeAlignment*: VkDeviceSize
  VkPhysicalDeviceImageRobustnessFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    robustImageAccess*: VkBool32
  VkPhysicalDevice4444FormatsFeaturesEXT* = object
    sType*: VkStructureType
    pNext*: pointer
    formatA4R4G4B4*: VkBool32
    formatA4B4G4R4*: VkBool32
# Constructors
proc newVkOffset2D*(x: int32, y: int32): VkOffset2D =
  result.x = x
  result.y = y
proc newVkOffset3D*(x: int32, y: int32, z: int32): VkOffset3D =
  result.x = x
  result.y = y
  result.z = z
proc newVkExtent2D*(width: uint32, height: uint32): VkExtent2D =
  result.width = width
  result.height = height
proc newVkExtent3D*(width: uint32, height: uint32, depth: uint32): VkExtent3D =
  result.width = width
  result.height = height
  result.depth = depth
proc newVkViewport*(x: float32, y: float32, width: float32, height: float32, minDepth: float32, maxDepth: float32): VkViewport =
  result.x = x
  result.y = y
  result.width = width
  result.height = height
  result.minDepth = minDepth
  result.maxDepth = maxDepth
proc newVkRect2D*(offset: VkOffset2D, extent: VkExtent2D): VkRect2D =
  result.offset = offset
  result.extent = extent
proc newVkClearRect*(rect: VkRect2D, baseArrayLayer: uint32, layerCount: uint32): VkClearRect =
  result.rect = rect
  result.baseArrayLayer = baseArrayLayer
  result.layerCount = layerCount
proc newVkComponentMapping*(r: VkComponentSwizzle, g: VkComponentSwizzle, b: VkComponentSwizzle, a: VkComponentSwizzle): VkComponentMapping =
  result.r = r
  result.g = g
  result.b = b
  result.a = a
proc newVkPhysicalDeviceProperties*(apiVersion: uint32, driverVersion: uint32, vendorID: uint32, deviceID: uint32, deviceType: VkPhysicalDeviceType, deviceName: array[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, char], pipelineCacheUUID: array[VK_UUID_SIZE, uint8], limits: VkPhysicalDeviceLimits, sparseProperties: VkPhysicalDeviceSparseProperties): VkPhysicalDeviceProperties =
  result.apiVersion = apiVersion
  result.driverVersion = driverVersion
  result.vendorID = vendorID
  result.deviceID = deviceID
  result.deviceType = deviceType
  result.deviceName = deviceName
  result.pipelineCacheUUID = pipelineCacheUUID
  result.limits = limits
  result.sparseProperties = sparseProperties
proc newVkExtensionProperties*(extensionName: array[VK_MAX_EXTENSION_NAME_SIZE, char], specVersion: uint32): VkExtensionProperties =
  result.extensionName = extensionName
  result.specVersion = specVersion
proc newVkLayerProperties*(layerName: array[VK_MAX_EXTENSION_NAME_SIZE, char], specVersion: uint32, implementationVersion: uint32, description: array[VK_MAX_DESCRIPTION_SIZE, char]): VkLayerProperties =
  result.layerName = layerName
  result.specVersion = specVersion
  result.implementationVersion = implementationVersion
  result.description = description
proc newVkApplicationInfo*(sType: VkStructureType = VkStructureTypeApplicationInfo, pNext: pointer = nil, pApplicationName: cstring, applicationVersion: uint32, pEngineName: cstring, engineVersion: uint32, apiVersion: uint32): VkApplicationInfo =
  result.sType = sType
  result.pNext = pNext
  result.pApplicationName = pApplicationName
  result.applicationVersion = applicationVersion
  result.pEngineName = pEngineName
  result.engineVersion = engineVersion
  result.apiVersion = apiVersion
proc newVkAllocationCallbacks*(pUserData: pointer = nil, pfnAllocation: PFN_vkAllocationFunction, pfnReallocation: PFN_vkReallocationFunction, pfnFree: PFN_vkFreeFunction, pfnInternalAllocation: PFN_vkInternalAllocationNotification, pfnInternalFree: PFN_vkInternalFreeNotification): VkAllocationCallbacks =
  result.pUserData = pUserData
  result.pfnAllocation = pfnAllocation
  result.pfnReallocation = pfnReallocation
  result.pfnFree = pfnFree
  result.pfnInternalAllocation = pfnInternalAllocation
  result.pfnInternalFree = pfnInternalFree
proc newVkDeviceQueueCreateInfo*(sType: VkStructureType = VkStructureTypeDeviceQueueCreateInfo, pNext: pointer = nil, flags: VkDeviceQueueCreateFlags = 0.VkDeviceQueueCreateFlags, queueFamilyIndex: uint32, queueCount: uint32, pQueuePriorities: ptr float32): VkDeviceQueueCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.queueFamilyIndex = queueFamilyIndex
  result.queueCount = queueCount
  result.pQueuePriorities = pQueuePriorities
proc newVkDeviceCreateInfo*(sType: VkStructureType = VkStructureTypeDeviceCreateInfo, pNext: pointer = nil, flags: VkDeviceCreateFlags = 0.VkDeviceCreateFlags, queueCreateInfoCount: uint32, pQueueCreateInfos: ptr VkDeviceQueueCreateInfo, enabledLayerCount: uint32, ppEnabledLayerNames: cstringArray, enabledExtensionCount: uint32, ppEnabledExtensionNames: cstringArray, pEnabledFeatures: ptr VkPhysicalDeviceFeatures): VkDeviceCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.queueCreateInfoCount = queueCreateInfoCount
  result.pQueueCreateInfos = pQueueCreateInfos
  result.enabledLayerCount = enabledLayerCount
  result.ppEnabledLayerNames = ppEnabledLayerNames
  result.enabledExtensionCount = enabledExtensionCount
  result.ppEnabledExtensionNames = ppEnabledExtensionNames
  result.pEnabledFeatures = pEnabledFeatures
proc newVkInstanceCreateInfo*( sType: VkStructureType = VkStructureTypeInstanceCreateInfo
                             , pNext: pointer = nil
                             , flags: VkInstanceCreateFlags = 0.VkInstanceCreateFlags
                             , pApplicationInfo: ptr VkApplicationInfo
                             , enabledExtensionCount: uint32
                             , ppEnabledExtensionNames: cstringArray = allocCStringArray([])
                             , enabled_layer_count: uint32 = 0
                             , ppEnabledLayerNames: cstringArray = allocCStringArray([])
                             ): VkInstanceCreateInfo = 
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.pApplicationInfo = pApplicationInfo
  result.enabledLayerCount = enabledLayerCount
  result.ppEnabledLayerNames = ppEnabledLayerNames
  result.enabledExtensionCount = enabledExtensionCount
  result.ppEnabledExtensionNames = ppEnabledExtensionNames
proc newVkQueueFamilyProperties*(queueFlags: VkQueueFlags, queueCount: uint32, timestampValidBits: uint32, minImageTransferGranularity: VkExtent3D): VkQueueFamilyProperties =
  result.queueFlags = queueFlags
  result.queueCount = queueCount
  result.timestampValidBits = timestampValidBits
  result.minImageTransferGranularity = minImageTransferGranularity
proc newVkPhysicalDeviceMemoryProperties*(memoryTypeCount: uint32, memoryTypes: array[VK_MAX_MEMORY_TYPES, VkMemoryType], memoryHeapCount: uint32, memoryHeaps: array[VK_MAX_MEMORY_HEAPS, VkMemoryHeap]): VkPhysicalDeviceMemoryProperties =
  result.memoryTypeCount = memoryTypeCount
  result.memoryTypes = memoryTypes
  result.memoryHeapCount = memoryHeapCount
  result.memoryHeaps = memoryHeaps
proc newVkMemoryAllocateInfo*(sType: VkStructureType = VkStructureTypeMemoryAllocateInfo, pNext: pointer = nil, allocationSize: VkDeviceSize, memoryTypeIndex: uint32): VkMemoryAllocateInfo =
  result.sType = sType
  result.pNext = pNext
  result.allocationSize = allocationSize
  result.memoryTypeIndex = memoryTypeIndex
proc newVkMemoryRequirements*(size: VkDeviceSize, alignment: VkDeviceSize, memoryTypeBits: uint32): VkMemoryRequirements =
  result.size = size
  result.alignment = alignment
  result.memoryTypeBits = memoryTypeBits
proc newVkSparseImageFormatProperties*(aspectMask: VkImageAspectFlags, imageGranularity: VkExtent3D, flags: VkSparseImageFormatFlags = 0.VkSparseImageFormatFlags): VkSparseImageFormatProperties =
  result.aspectMask = aspectMask
  result.imageGranularity = imageGranularity
  result.flags = flags
proc newVkSparseImageMemoryRequirements*(formatProperties: VkSparseImageFormatProperties, imageMipTailFirstLod: uint32, imageMipTailSize: VkDeviceSize, imageMipTailOffset: VkDeviceSize, imageMipTailStride: VkDeviceSize): VkSparseImageMemoryRequirements =
  result.formatProperties = formatProperties
  result.imageMipTailFirstLod = imageMipTailFirstLod
  result.imageMipTailSize = imageMipTailSize
  result.imageMipTailOffset = imageMipTailOffset
  result.imageMipTailStride = imageMipTailStride
proc newVkMemoryType*(propertyFlags: VkMemoryPropertyFlags, heapIndex: uint32): VkMemoryType =
  result.propertyFlags = propertyFlags
  result.heapIndex = heapIndex
proc newVkMemoryHeap*(size: VkDeviceSize, flags: VkMemoryHeapFlags = 0.VkMemoryHeapFlags): VkMemoryHeap =
  result.size = size
  result.flags = flags
proc newVkFormatProperties*(linearTilingFeatures: VkFormatFeatureFlags, optimalTilingFeatures: VkFormatFeatureFlags, bufferFeatures: VkFormatFeatureFlags): VkFormatProperties =
  result.linearTilingFeatures = linearTilingFeatures
  result.optimalTilingFeatures = optimalTilingFeatures
  result.bufferFeatures = bufferFeatures
proc newVkImageFormatProperties*(maxExtent: VkExtent3D, maxMipLevels: uint32, maxArrayLayers: uint32, sampleCounts: VkSampleCountFlags, maxResourceSize: VkDeviceSize): VkImageFormatProperties =
  result.maxExtent = maxExtent
  result.maxMipLevels = maxMipLevels
  result.maxArrayLayers = maxArrayLayers
  result.sampleCounts = sampleCounts
  result.maxResourceSize = maxResourceSize
proc newVkDescriptorBufferInfo*(buffer: VkBuffer, offset: VkDeviceSize, range: VkDeviceSize): VkDescriptorBufferInfo =
  result.buffer = buffer
  result.offset = offset
  result.range = range
proc newVkDescriptorImageInfo*(sampler: VkSampler, imageView: VkImageView, imageLayout: VkImageLayout): VkDescriptorImageInfo =
  result.sampler = sampler
  result.imageView = imageView
  result.imageLayout = imageLayout
proc newVkWriteDescriptorSet*(sType: VkStructureType = VkStructureTypeWriteDescriptorSet, pNext: pointer = nil, dstSet: VkDescriptorSet, dstBinding: uint32, dstArrayElement: uint32, descriptorCount: uint32, descriptorType: VkDescriptorType, pImageInfo: ptr VkDescriptorImageInfo, pBufferInfo: ptr ptr VkDescriptorBufferInfo, pTexelBufferView: ptr VkBufferView): VkWriteDescriptorSet =
  result.sType = sType
  result.pNext = pNext
  result.dstSet = dstSet
  result.dstBinding = dstBinding
  result.dstArrayElement = dstArrayElement
  result.descriptorCount = descriptorCount
  result.descriptorType = descriptorType
  result.pImageInfo = pImageInfo
  result.pBufferInfo = pBufferInfo
  result.pTexelBufferView = pTexelBufferView
proc newVkCopyDescriptorSet*(sType: VkStructureType = VkStructureTypeCopyDescriptorSet, pNext: pointer = nil, srcSet: VkDescriptorSet, srcBinding: uint32, srcArrayElement: uint32, dstSet: VkDescriptorSet, dstBinding: uint32, dstArrayElement: uint32, descriptorCount: uint32): VkCopyDescriptorSet =
  result.sType = sType
  result.pNext = pNext
  result.srcSet = srcSet
  result.srcBinding = srcBinding
  result.srcArrayElement = srcArrayElement
  result.dstSet = dstSet
  result.dstBinding = dstBinding
  result.dstArrayElement = dstArrayElement
  result.descriptorCount = descriptorCount
proc newVkBufferCreateInfo*(sType: VkStructureType = VkStructureTypeBufferCreateInfo, pNext: pointer = nil, flags: VkBufferCreateFlags = 0.VkBufferCreateFlags, size: VkDeviceSize, usage: VkBufferUsageFlags, sharingMode: VkSharingMode, queueFamilyIndexCount: uint32, pQueueFamilyIndices: ptr uint32): VkBufferCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.size = size
  result.usage = usage
  result.sharingMode = sharingMode
  result.queueFamilyIndexCount = queueFamilyIndexCount
  result.pQueueFamilyIndices = pQueueFamilyIndices
proc newVkBufferViewCreateInfo*(sType: VkStructureType = VkStructureTypeBufferViewCreateInfo, pNext: pointer = nil, flags: VkBufferViewCreateFlags = 0.VkBufferViewCreateFlags, buffer: VkBuffer, format: VkFormat, offset: VkDeviceSize, range: VkDeviceSize): VkBufferViewCreateInfo =
  result.sType = sType
  result.pNext = pNext
  result.flags = flags
  result.buffer = buffer
  result.format = format
  result.offset = offset
  result.range = range
proc newVkImageSubresource*(aspectMask: VkImageAspectFlags, mipLevel: uint32, arrayLayer: uint32): VkImageSubresource =
  result.aspectMask = aspectMask
  result.mipLevel = mipLevel
  result.arrayLayer = arrayLayer
proc newVkImageSubresourceLayers*(aspectMask: VkImageAspectFlags, mipLevel: uint32, baseArrayLayer: uint32, layerCount: uint32): VkImageSubresourceLayers =
  result.aspectMask = aspectMask
  result.mipLevel = mipLevel
  result.baseArrayLayer = baseArrayLayer
  result.layerCount = layerCount
proc newVkImageSubresourceRange*(aspectMask: VkImageAspectFlags, baseMipLevel: uint32, levelCount: uint32, baseArrayLayer: uint32, layerCount: uint32): VkImageSubresourceRange =
  result.aspectMask = aspectMask
  result.baseMipLevel = baseMipLevel
  result.levelCount = levelCount
  result.baseArrayLayer = baseArrayLayer
  result.layerCount = layerCount
proc newVkMemoryBarrier*(sType: VkStructureType = VkStructureTypeMemoryBarrier, pNext: pointer = nil, srcAccessMask: VkAccessFlags, dstAccessMask: VkAccessFlags): VkMemoryBarrier =
  result.sType = sType
  result.pNext = pNext
  result.srcAccessMask = srcAccessMask
  result.dstAccessMask = dstAccessMask
proc newVkBufferMemoryBarrier*(sType: VkStructureType = VkStructureTypeBufferMemoryBarrier, pNext: pointer = nil, srcAccessMask: VkAccessFlags, dstAccessMask: VkAccessFlags, srcQueueFamilyIndex: uint32, dstQueueFamilyIndex: uint32, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize): VkBufferMemoryBarrier =
  result.sType = sType
  result.pNext = pNext
  result.srcAccessMask = srcAccessMask
  result.dstAccessMask = dstAccessMask
  result.srcQueueFamilyIndex = srcQueueFamilyIndex
  result.dstQueueFamilyIndex = dstQueueFamilyIndex
  result.buffer = buffer
  result.offset = offset
  result.size = size
proc newVkImageMemoryBarrier*(sType: VkStructureType = VkStructureTypeImageMemoryBarrier, pNext: pointer = nil, srcAccessMask: VkAccessFlags, dstAccessMask: VkAccessFlags, oldLayout: VkImageLayout, newLayout: VkImageLayout, srcQueueFamilyIndex: uint32, dstQueueFamilyIndex: uint32, image: VkImage, subresourceRange: VkImageSubresourceRange): VkImageMemoryBarrier =
  result.sType = sType
  result.pNext = pNext
  result.srcAccessMask = srcAccessMask
  result.dstAccessMask = dstAccessMask
  result.oldLayout = oldLayout
  result.newLayout = newLayout
  result.srcQueueFamilyIndex = srcQueueFamilyIndex
  result.dstQueueFamilyIndex = dstQueueFamilyIndex
  result.image = image
  result.subresourceRange = subresourceRange
# Procs
var
  vkCreateInstance*: proc(pCreateInfo: ptr VkInstanceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pInstance: ptr VkInstance ): VkResult {.stdcall.}
  vkDestroyInstance*: proc(instance: VkInstance, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkEnumeratePhysicalDevices*: proc(instance: VkInstance, pPhysicalDeviceCount: ptr uint32 , pPhysicalDevices: ptr VkPhysicalDevice ): VkResult {.stdcall.}
  vkGetDeviceProcAddr*: proc(device: VkDevice, pName: cstring ): PFN_vkVoidFunction {.stdcall.}
  vkGetInstanceProcAddr*: proc(instance: VkInstance, pName: cstring ): PFN_vkVoidFunction {.stdcall.}
  vkGetPhysicalDeviceProperties*: proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties ): void {.stdcall.}
  vkGetPhysicalDeviceQueueFamilyProperties*: proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32 , pQueueFamilyProperties: ptr VkQueueFamilyProperties ): void {.stdcall.}
  vkGetPhysicalDeviceMemoryProperties*: proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties ): void {.stdcall.}
  vkGetPhysicalDeviceFeatures*: proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures ): void {.stdcall.}
  vkGetPhysicalDeviceFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties ): void {.stdcall.}
  vkGetPhysicalDeviceImageFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, typee: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: ptr VkImageFormatProperties ): VkResult {.stdcall.}
  vkCreateDevice*: proc(physicalDevice: VkPhysicalDevice, pCreateInfo: ptr VkDeviceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDevice: ptr VkDevice ): VkResult {.stdcall.}
  vkDestroyDevice*: proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkEnumerateInstanceVersion*: proc(pApiVersion: ptr uint32 ): VkResult {.stdcall.}
  vkEnumerateInstanceLayerProperties*: proc(pPropertyCount: ptr uint32 , pProperties: ptr VkLayerProperties ): VkResult {.stdcall.}
  vkEnumerateInstanceExtensionProperties*: proc(pLayerName: cstring , pPropertyCount: ptr uint32 , pProperties: ptr VkExtensionProperties ): VkResult {.stdcall.}
  vkEnumerateDeviceLayerProperties*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkLayerProperties ): VkResult {.stdcall.}
  vkEnumerateDeviceExtensionProperties*: proc(physicalDevice: VkPhysicalDevice, pLayerName: cstring , pPropertyCount: ptr uint32 , pProperties: ptr VkExtensionProperties ): VkResult {.stdcall.}
  vkGetDeviceQueue*: proc(device: VkDevice, queueFamilyIndex: uint32, queueIndex: uint32, pQueue: ptr VkQueue ): void {.stdcall.}
  vkQueueSubmit*: proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo , fence: VkFence): VkResult {.stdcall.}
  vkQueueWaitIdle*: proc(queue: VkQueue): VkResult {.stdcall.}
  vkDeviceWaitIdle*: proc(device: VkDevice): VkResult {.stdcall.}
  vkAllocateMemory*: proc(device: VkDevice, pAllocateInfo: ptr VkMemoryAllocateInfo , pAllocator: ptr VkAllocationCallbacks , pMemory: ptr VkDeviceMemory ): VkResult {.stdcall.}
  vkFreeMemory*: proc(device: VkDevice, memory: VkDeviceMemory, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkMapMemory*: proc(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: ptr pointer ): VkResult {.stdcall.}
  vkUnmapMemory*: proc(device: VkDevice, memory: VkDeviceMemory): void {.stdcall.}
  vkFlushMappedMemoryRanges*: proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange ): VkResult {.stdcall.}
  vkInvalidateMappedMemoryRanges*: proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange ): VkResult {.stdcall.}
  vkGetDeviceMemoryCommitment*: proc(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: ptr VkDeviceSize ): void {.stdcall.}
  vkGetBufferMemoryRequirements*: proc(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: ptr VkMemoryRequirements ): void {.stdcall.}
  vkBindBufferMemory*: proc(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}
  vkGetImageMemoryRequirements*: proc(device: VkDevice, image: VkImage, pMemoryRequirements: ptr VkMemoryRequirements ): void {.stdcall.}
  vkBindImageMemory*: proc(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}
  vkGetImageSparseMemoryRequirements*: proc(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: ptr uint32 , pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements ): void {.stdcall.}
  vkGetPhysicalDeviceSparseImageFormatProperties*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, typee: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: ptr uint32 , pProperties: ptr VkSparseImageFormatProperties ): void {.stdcall.}
  vkQueueBindSparse*: proc(queue: VkQueue, bindInfoCount: uint32, pBindInfo: ptr VkBindSparseInfo , fence: VkFence): VkResult {.stdcall.}
  vkCreateFence*: proc(device: VkDevice, pCreateInfo: ptr VkFenceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}
  vkDestroyFence*: proc(device: VkDevice, fence: VkFence, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkResetFences*: proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence ): VkResult {.stdcall.}
  vkGetFenceStatus*: proc(device: VkDevice, fence: VkFence): VkResult {.stdcall.}
  vkWaitForFences*: proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence , waitAll: VkBool32, timeout: uint64): VkResult {.stdcall.}
  vkCreateSemaphore*: proc(device: VkDevice, pCreateInfo: ptr VkSemaphoreCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSemaphore: ptr VkSemaphore ): VkResult {.stdcall.}
  vkDestroySemaphore*: proc(device: VkDevice, semaphore: VkSemaphore, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateEvent*: proc(device: VkDevice, pCreateInfo: ptr VkEventCreateInfo , pAllocator: ptr VkAllocationCallbacks , pEvent: ptr VkEvent ): VkResult {.stdcall.}
  vkDestroyEvent*: proc(device: VkDevice, event: VkEvent, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetEventStatus*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}
  vkSetEvent*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}
  vkResetEvent*: proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}
  vkCreateQueryPool*: proc(device: VkDevice, pCreateInfo: ptr VkQueryPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pQueryPool: ptr VkQueryPool ): VkResult {.stdcall.}
  vkDestroyQueryPool*: proc(device: VkDevice, queryPool: VkQueryPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetQueryPoolResults*: proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dataSize: uint, pData: pointer , stride: VkDeviceSize, flags: VkQueryResultFlags): VkResult {.stdcall.}
  vkResetQueryPool*: proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}
  vkCreateBuffer*: proc(device: VkDevice, pCreateInfo: ptr VkBufferCreateInfo , pAllocator: ptr VkAllocationCallbacks , pBuffer: ptr VkBuffer ): VkResult {.stdcall.}
  vkDestroyBuffer*: proc(device: VkDevice, buffer: VkBuffer, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateBufferView*: proc(device: VkDevice, pCreateInfo: ptr VkBufferViewCreateInfo , pAllocator: ptr VkAllocationCallbacks , pView: ptr VkBufferView ): VkResult {.stdcall.}
  vkDestroyBufferView*: proc(device: VkDevice, bufferView: VkBufferView, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateImage*: proc(device: VkDevice, pCreateInfo: ptr VkImageCreateInfo , pAllocator: ptr VkAllocationCallbacks , pImage: ptr VkImage ): VkResult {.stdcall.}
  vkDestroyImage*: proc(device: VkDevice, image: VkImage, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetImageSubresourceLayout*: proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource , pLayout: ptr VkSubresourceLayout ): void {.stdcall.}
  vkCreateImageView*: proc(device: VkDevice, pCreateInfo: ptr VkImageViewCreateInfo , pAllocator: ptr VkAllocationCallbacks , pView: ptr VkImageView ): VkResult {.stdcall.}
  vkDestroyImageView*: proc(device: VkDevice, imageView: VkImageView, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateShaderModule*: proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo , pAllocator: ptr VkAllocationCallbacks , pShaderModule: ptr VkShaderModule ): VkResult {.stdcall.}
  vkDestroyShaderModule*: proc(device: VkDevice, shaderModule: VkShaderModule, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreatePipelineCache*: proc(device: VkDevice, pCreateInfo: ptr VkPipelineCacheCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelineCache: ptr VkPipelineCache ): VkResult {.stdcall.}
  vkDestroyPipelineCache*: proc(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetPipelineCacheData*: proc(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: ptr uint , pData: pointer ): VkResult {.stdcall.}
  vkMergePipelineCaches*: proc(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32, pSrcCaches: ptr VkPipelineCache ): VkResult {.stdcall.}
  vkCreateGraphicsPipelines*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkGraphicsPipelineCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}
  vkCreateComputePipelines*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkComputePipelineCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}
  vkDestroyPipeline*: proc(device: VkDevice, pipeline: VkPipeline, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreatePipelineLayout*: proc(device: VkDevice, pCreateInfo: ptr VkPipelineLayoutCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelineLayout: ptr VkPipelineLayout ): VkResult {.stdcall.}
  vkDestroyPipelineLayout*: proc(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateSampler*: proc(device: VkDevice, pCreateInfo: ptr VkSamplerCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSampler: ptr VkSampler ): VkResult {.stdcall.}
  vkDestroySampler*: proc(device: VkDevice, sampler: VkSampler, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateDescriptorSetLayout*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSetLayout: ptr VkDescriptorSetLayout ): VkResult {.stdcall.}
  vkDestroyDescriptorSetLayout*: proc(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateDescriptorPool*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDescriptorPool: ptr VkDescriptorPool ): VkResult {.stdcall.}
  vkDestroyDescriptorPool*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkResetDescriptorPool*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags): VkResult {.stdcall.}
  vkAllocateDescriptorSets*: proc(device: VkDevice, pAllocateInfo: ptr VkDescriptorSetAllocateInfo , pDescriptorSets: ptr VkDescriptorSet ): VkResult {.stdcall.}
  vkFreeDescriptorSets*: proc(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet ): VkResult {.stdcall.}
  vkUpdateDescriptorSets*: proc(device: VkDevice, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet , descriptorCopyCount: uint32, pDescriptorCopies: ptr VkCopyDescriptorSet ): void {.stdcall.}
  vkCreateFramebuffer*: proc(device: VkDevice, pCreateInfo: ptr VkFramebufferCreateInfo , pAllocator: ptr VkAllocationCallbacks , pFramebuffer: ptr VkFramebuffer ): VkResult {.stdcall.}
  vkDestroyFramebuffer*: proc(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkCreateRenderPass*: proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo , pAllocator: ptr VkAllocationCallbacks , pRenderPass: ptr VkRenderPass ): VkResult {.stdcall.}
  vkDestroyRenderPass*: proc(device: VkDevice, render_pass: VkRenderPass, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetRenderAreaGranularity*: proc(device: VkDevice, render_pass: VkRenderPass, pGranularity: ptr VkExtent2D ): void {.stdcall.}
  vkCreateCommandPool*: proc(device: VkDevice, pCreateInfo: ptr VkCommandPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pCommandPool: ptr VkCommandPool ): VkResult {.stdcall.}
  vkDestroyCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkResetCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags): VkResult {.stdcall.}
  vkAllocateCommandBuffers*: proc(device: VkDevice, pAllocateInfo: ptr VkCommandBufferAllocateInfo , pCommandBuffers: ptr VkCommandBuffer ): VkResult {.stdcall.}
  vkFreeCommandBuffers*: proc(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer ): void {.stdcall.}
  vkBeginCommandBuffer*: proc(commandBuffer: VkCommandBuffer, pBeginInfo: ptr VkCommandBufferBeginInfo ): VkResult {.stdcall.}
  vkEndCommandBuffer*: proc(commandBuffer: VkCommandBuffer): VkResult {.stdcall.}
  vkResetCommandBuffer*: proc(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags): VkResult {.stdcall.}
  vkCmdBindPipeline*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline): void {.stdcall.}
  vkCmdSetViewport*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewports: ptr VkViewport ): void {.stdcall.}
  vkCmdSetScissor*: proc(commandBuffer: VkCommandBuffer, firstScissor: uint32, scissorCount: uint32, pScissors: ptr VkRect2D ): void {.stdcall.}
  vkCmdSetLineWidth*: proc(commandBuffer: VkCommandBuffer, lineWidth: float32): void {.stdcall.}
  vkCmdSetDepthBias*: proc(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: float32, depthBiasClamp: float32, depthBiasSlopeFactor: float32): void {.stdcall.}
  vkCmdSetBlendConstants*: proc(commandBuffer: VkCommandBuffer, blendConstants: array[4, float32]): void {.stdcall.}
  vkCmdSetDepthBounds*: proc(commandBuffer: VkCommandBuffer, minDepthBounds: float32, maxDepthBounds: float32): void {.stdcall.}
  vkCmdSetStencilCompareMask*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32): void {.stdcall.}
  vkCmdSetStencilWriteMask*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32): void {.stdcall.}
  vkCmdSetStencilReference*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32): void {.stdcall.}
  vkCmdBindDescriptorSets*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet , dynamicOffsetCount: uint32, pDynamicOffsets: ptr uint32 ): void {.stdcall.}
  vkCmdBindIndexBuffer*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType): void {.stdcall.}
  vkCmdBindVertexBuffers*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize ): void {.stdcall.}
  vkCmdDraw*: proc(commandBuffer: VkCommandBuffer, vertexCount: uint32, instanceCount: uint32, firstVertex: uint32, firstInstance: uint32): void {.stdcall.}
  vkCmdDrawIndexed*: proc(commandBuffer: VkCommandBuffer, indexCount: uint32, instanceCount: uint32, firstIndex: uint32, vertexOffset: int32, firstInstance: uint32): void {.stdcall.}
  vkCmdDrawIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}
  vkCmdDrawIndexedIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}
  vkCmdDispatch*: proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}
  vkCmdDispatchIndirect*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}
  vkCmdCopyBuffer*: proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferCopy ): void {.stdcall.}
  vkCmdCopyImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageCopy ): void {.stdcall.}
  vkCmdBlitImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageBlit , filter: VkFilter): void {.stdcall.}
  vkCmdCopyBufferToImage*: proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkBufferImageCopy ): void {.stdcall.}
  vkCmdCopyImageToBuffer*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferImageCopy ): void {.stdcall.}
  vkCmdUpdateBuffer*: proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: pointer ): void {.stdcall.}
  vkCmdFillBuffer*: proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32): void {.stdcall.}
  vkCmdClearColorImage*: proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: ptr VkClearColorValue , rangeCount: uint32, pRanges: ptr VkImageSubresourceRange ): void {.stdcall.}
  vkCmdClearDepthStencilImage*: proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: ptr VkClearDepthStencilValue , rangeCount: uint32, pRanges: ptr VkImageSubresourceRange ): void {.stdcall.}
  vkCmdClearAttachments*: proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pAttachments: ptr VkClearAttachment , rectCount: uint32, pRects: ptr VkClearRect ): void {.stdcall.}
  vkCmdResolveImage*: proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageResolve ): void {.stdcall.}
  vkCmdSetEvent*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}
  vkCmdResetEvent*: proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}
  vkCmdWaitEvents*: proc(commandBuffer: VkCommandBuffer, eventCount: uint32, pEvents: ptr VkEvent , srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier , bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier , imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier ): void {.stdcall.}
  vkCmdPipelineBarrier*: proc(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier , bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier , imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier ): void {.stdcall.}
  vkCmdBeginQuery*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags): void {.stdcall.}
  vkCmdEndQuery*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32): void {.stdcall.}
  vkCmdBeginConditionalRenderingEXT*: proc(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: ptr VkConditionalRenderingBeginInfoEXT ): void {.stdcall.}
  vkCmdEndConditionalRenderingEXT*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
  vkCmdResetQueryPool*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}
  vkCmdWriteTimestamp*: proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: uint32): void {.stdcall.}
  vkCmdCopyQueryPoolResults*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags): void {.stdcall.}
  vkCmdPushConstants*: proc(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32, size: uint32, pValues: pointer ): void {.stdcall.}
  vkCmdBeginRenderPass*: proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo , contents: VkSubpassContents): void {.stdcall.}
  vkCmdNextSubpass*: proc(commandBuffer: VkCommandBuffer, contents: VkSubpassContents): void {.stdcall.}
  vkCmdEndRenderPass*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
  vkCmdExecuteCommands*: proc(commandBuffer: VkCommandBuffer, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer ): void {.stdcall.}
  vkCreateAndroidSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkAndroidSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceDisplayPropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPropertiesKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceDisplayPlanePropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPlanePropertiesKHR ): VkResult {.stdcall.}
  vkGetDisplayPlaneSupportedDisplaysKHR*: proc(physicalDevice: VkPhysicalDevice, planeIndex: uint32, pDisplayCount: ptr uint32 , pDisplays: ptr VkDisplayKHR ): VkResult {.stdcall.}
  vkGetDisplayModePropertiesKHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayModePropertiesKHR ): VkResult {.stdcall.}
  vkCreateDisplayModeKHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: ptr VkDisplayModeCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pMode: ptr VkDisplayModeKHR ): VkResult {.stdcall.}
  vkGetDisplayPlaneCapabilitiesKHR*: proc(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: uint32, pCapabilities: ptr VkDisplayPlaneCapabilitiesKHR ): VkResult {.stdcall.}
  vkCreateDisplayPlaneSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkDisplaySurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateSharedSwapchainsKHR*: proc(device: VkDevice, swapchainCount: uint32, pCreateInfos: ptr VkSwapchainCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSwapchains: ptr VkSwapchainKHR ): VkResult {.stdcall.}
  vkDestroySurfaceKHR*: proc(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetPhysicalDeviceSurfaceSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, surface: VkSurfaceKHR, pSupported: ptr VkBool32 ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfaceCapabilitiesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilitiesKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfaceFormatsKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: ptr uint32 , pSurfaceFormats: ptr VkSurfaceFormatKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfacePresentModesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: ptr uint32 , pPresentModes: ptr VkPresentModeKHR ): VkResult {.stdcall.}
  vkCreateSwapchainKHR*: proc(device: VkDevice, pCreateInfo: ptr VkSwapchainCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSwapchain: ptr VkSwapchainKHR ): VkResult {.stdcall.}
  vkDestroySwapchainKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetSwapchainImagesKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: ptr uint32 , pSwapchainImages: ptr VkImage ): VkResult {.stdcall.}
  vkAcquireNextImageKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR, timeout: uint64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: ptr uint32 ): VkResult {.stdcall.}
  vkQueuePresentKHR*: proc(queue: VkQueue, pPresentInfo: ptr VkPresentInfoKHR ): VkResult {.stdcall.}
  vkCreateViSurfaceNN*: proc(instance: VkInstance, pCreateInfo: ptr VkViSurfaceCreateInfoNN , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateWaylandSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkWaylandSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceWaylandPresentationSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, display: ptr wl_display ): VkBool32 {.stdcall.}
  vkCreateWin32SurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkWin32SurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceWin32PresentationSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32): VkBool32 {.stdcall.}
  vkCreateXlibSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkXlibSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceXlibPresentationSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, dpy: ptr Display , visualID: VisualID): VkBool32 {.stdcall.}
  vkCreateXcbSurfaceKHR*: proc(instance: VkInstance, pCreateInfo: ptr VkXcbSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceXcbPresentationSupportKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, connection: ptr xcb_connection_t , visual_id: xcb_visualid_t): VkBool32 {.stdcall.}
  vkCreateDirectFBSurfaceEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkDirectFBSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceDirectFBPresentationSupportEXT*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, dfb: ptr IDirectFB ): VkBool32 {.stdcall.}
  vkCreateImagePipeSurfaceFUCHSIA*: proc(instance: VkInstance, pCreateInfo: ptr VkImagePipeSurfaceCreateInfoFUCHSIA , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateStreamDescriptorSurfaceGGP*: proc(instance: VkInstance, pCreateInfo: ptr VkStreamDescriptorSurfaceCreateInfoGGP , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateDebugReportCallbackEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkDebugReportCallbackCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pCallback: ptr VkDebugReportCallbackEXT ): VkResult {.stdcall.}
  vkDestroyDebugReportCallbackEXT*: proc(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkDebugReportMessageEXT*: proc(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, `object`: uint64, location: uint, messageCode: int32, pLayerPrefix: cstring , pMessage: cstring ): void {.stdcall.}
  vkDebugMarkerSetObjectNameEXT*: proc(device: VkDevice, pNameInfo: ptr VkDebugMarkerObjectNameInfoEXT ): VkResult {.stdcall.}
  vkDebugMarkerSetObjectTagEXT*: proc(device: VkDevice, pTagInfo: ptr VkDebugMarkerObjectTagInfoEXT ): VkResult {.stdcall.}
  vkCmdDebugMarkerBeginEXT*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT ): void {.stdcall.}
  vkCmdDebugMarkerEndEXT*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
  vkCmdDebugMarkerInsertEXT*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT ): void {.stdcall.}
  vkGetPhysicalDeviceExternalImageFormatPropertiesNV*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, typee: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: ptr VkExternalImageFormatPropertiesNV ): VkResult {.stdcall.}
  vkGetMemoryWin32HandleNV*: proc(device: VkDevice, memory: VkDeviceMemory, handleType: VkExternalMemoryHandleTypeFlagsNV, pHandle: ptr HANDLE ): VkResult {.stdcall.}
  vkCmdExecuteGeneratedCommandsNV*: proc(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV ): void {.stdcall.}
  vkCmdPreprocessGeneratedCommandsNV*: proc(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV ): void {.stdcall.}
  vkCmdBindPipelineShaderGroupNV*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: uint32): void {.stdcall.}
  vkGetGeneratedCommandsMemoryRequirementsNV*: proc(device: VkDevice, pInfo: ptr VkGeneratedCommandsMemoryRequirementsInfoNV , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}
  vkCreateIndirectCommandsLayoutNV*: proc(device: VkDevice, pCreateInfo: ptr VkIndirectCommandsLayoutCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pIndirectCommandsLayout: ptr VkIndirectCommandsLayoutNV ): VkResult {.stdcall.}
  vkDestroyIndirectCommandsLayoutNV*: proc(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetPhysicalDeviceFeatures2*: proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures2 ): void {.stdcall.}
  vkGetPhysicalDeviceProperties2*: proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties2 ): void {.stdcall.}
  vkGetPhysicalDeviceFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties2 ): void {.stdcall.}
  vkGetPhysicalDeviceImageFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, pImageFormatInfo: ptr VkPhysicalDeviceImageFormatInfo2 , pImageFormatProperties: ptr VkImageFormatProperties2 ): VkResult {.stdcall.}
  vkGetPhysicalDeviceQueueFamilyProperties2*: proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32 , pQueueFamilyProperties: ptr VkQueueFamilyProperties2 ): void {.stdcall.}
  vkGetPhysicalDeviceMemoryProperties2*: proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties2 ): void {.stdcall.}
  vkGetPhysicalDeviceSparseImageFormatProperties2*: proc(physicalDevice: VkPhysicalDevice, pFormatInfo: ptr VkPhysicalDeviceSparseImageFormatInfo2 , pPropertyCount: ptr uint32 , pProperties: ptr VkSparseImageFormatProperties2 ): void {.stdcall.}
  vkCmdPushDescriptorSetKHR*: proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet ): void {.stdcall.}
  vkTrimCommandPool*: proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags): void {.stdcall.}
  vkGetPhysicalDeviceExternalBufferProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: ptr VkPhysicalDeviceExternalBufferInfo , pExternalBufferProperties: ptr VkExternalBufferProperties ): void {.stdcall.}
  vkGetMemoryWin32HandleKHR*: proc(device: VkDevice, pGetWin32HandleInfo: ptr VkMemoryGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}
  vkGetMemoryWin32HandlePropertiesKHR*: proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, handle: HANDLE, pMemoryWin32HandleProperties: ptr VkMemoryWin32HandlePropertiesKHR ): VkResult {.stdcall.}
  vkGetMemoryFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkMemoryGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}
  vkGetMemoryFdPropertiesKHR*: proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: int, pMemoryFdProperties: ptr VkMemoryFdPropertiesKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceExternalSemaphoreProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: ptr VkPhysicalDeviceExternalSemaphoreInfo , pExternalSemaphoreProperties: ptr VkExternalSemaphoreProperties ): void {.stdcall.}
  vkGetSemaphoreWin32HandleKHR*: proc(device: VkDevice, pGetWin32HandleInfo: ptr VkSemaphoreGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}
  vkImportSemaphoreWin32HandleKHR*: proc(device: VkDevice, pImportSemaphoreWin32HandleInfo: ptr VkImportSemaphoreWin32HandleInfoKHR ): VkResult {.stdcall.}
  vkGetSemaphoreFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkSemaphoreGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}
  vkImportSemaphoreFdKHR*: proc(device: VkDevice, pImportSemaphoreFdInfo: ptr VkImportSemaphoreFdInfoKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceExternalFenceProperties*: proc(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: ptr VkPhysicalDeviceExternalFenceInfo , pExternalFenceProperties: ptr VkExternalFenceProperties ): void {.stdcall.}
  vkGetFenceWin32HandleKHR*: proc(device: VkDevice, pGetWin32HandleInfo: ptr VkFenceGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}
  vkImportFenceWin32HandleKHR*: proc(device: VkDevice, pImportFenceWin32HandleInfo: ptr VkImportFenceWin32HandleInfoKHR ): VkResult {.stdcall.}
  vkGetFenceFdKHR*: proc(device: VkDevice, pGetFdInfo: ptr VkFenceGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}
  vkImportFenceFdKHR*: proc(device: VkDevice, pImportFenceFdInfo: ptr VkImportFenceFdInfoKHR ): VkResult {.stdcall.}
  vkReleaseDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR): VkResult {.stdcall.}
  vkAcquireXlibDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, dpy: ptr Display , display: VkDisplayKHR): VkResult {.stdcall.}
  vkGetRandROutputDisplayEXT*: proc(physicalDevice: VkPhysicalDevice, dpy: ptr Display , rrOutput: RROutput, pDisplay: ptr VkDisplayKHR ): VkResult {.stdcall.}
  vkDisplayPowerControlEXT*: proc(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: ptr VkDisplayPowerInfoEXT ): VkResult {.stdcall.}
  vkRegisterDeviceEventEXT*: proc(device: VkDevice, pDeviceEventInfo: ptr VkDeviceEventInfoEXT , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}
  vkRegisterDisplayEventEXT*: proc(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: ptr VkDisplayEventInfoEXT , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}
  vkGetSwapchainCounterEXT*: proc(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: ptr uint64 ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfaceCapabilities2EXT*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2EXT ): VkResult {.stdcall.}
  vkEnumeratePhysicalDeviceGroups*: proc(instance: VkInstance, pPhysicalDeviceGroupCount: ptr uint32 , pPhysicalDeviceGroupProperties: ptr VkPhysicalDeviceGroupProperties ): VkResult {.stdcall.}
  vkGetDeviceGroupPeerMemoryFeatures*: proc(device: VkDevice, heapIndex: uint32, localDeviceIndex: uint32, remoteDeviceIndex: uint32, pPeerMemoryFeatures: ptr VkPeerMemoryFeatureFlags ): void {.stdcall.}
  vkBindBufferMemory2*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindBufferMemoryInfo ): VkResult {.stdcall.}
  vkBindImageMemory2*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindImageMemoryInfo ): VkResult {.stdcall.}
  vkCmdSetDeviceMask*: proc(commandBuffer: VkCommandBuffer, deviceMask: uint32): void {.stdcall.}
  vkGetDeviceGroupPresentCapabilitiesKHR*: proc(device: VkDevice, pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR ): VkResult {.stdcall.}
  vkGetDeviceGroupSurfacePresentModesKHR*: proc(device: VkDevice, surface: VkSurfaceKHR, pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}
  vkAcquireNextImage2KHR*: proc(device: VkDevice, pAcquireInfo: ptr VkAcquireNextImageInfoKHR , pImageIndex: ptr uint32 ): VkResult {.stdcall.}
  vkCmdDispatchBase*: proc(commandBuffer: VkCommandBuffer, baseGroupX: uint32, baseGroupY: uint32, baseGroupZ: uint32, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}
  vkGetPhysicalDevicePresentRectanglesKHR*: proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: ptr uint32 , pRects: ptr VkRect2D ): VkResult {.stdcall.}
  vkCreateDescriptorUpdateTemplate*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorUpdateTemplateCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDescriptorUpdateTemplate: ptr VkDescriptorUpdateTemplate ): VkResult {.stdcall.}
  vkDestroyDescriptorUpdateTemplate*: proc(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkUpdateDescriptorSetWithTemplate*: proc(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: pointer ): void {.stdcall.}
  vkCmdPushDescriptorSetWithTemplateKHR*: proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer ): void {.stdcall.}
  vkSetHdrMetadataEXT*: proc(device: VkDevice, swapchainCount: uint32, pSwapchains: ptr VkSwapchainKHR , pMetadata: ptr VkHdrMetadataEXT ): void {.stdcall.}
  vkGetSwapchainStatusKHR*: proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}
  vkGetRefreshCycleDurationGOOGLE*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: ptr VkRefreshCycleDurationGOOGLE ): VkResult {.stdcall.}
  vkGetPastPresentationTimingGOOGLE*: proc(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: ptr uint32 , pPresentationTimings: ptr VkPastPresentationTimingGOOGLE ): VkResult {.stdcall.}
  vkCreateIOSSurfaceMVK*: proc(instance: VkInstance, pCreateInfo: ptr VkIOSSurfaceCreateInfoMVK , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateMacOSSurfaceMVK*: proc(instance: VkInstance, pCreateInfo: ptr VkMacOSSurfaceCreateInfoMVK , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCreateMetalSurfaceEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkMetalSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkCmdSetViewportWScalingNV*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportWScalings: ptr VkViewportWScalingNV ): void {.stdcall.}
  vkCmdSetDiscardRectangleEXT*: proc(commandBuffer: VkCommandBuffer, firstDiscardRectangle: uint32, discardRectangleCount: uint32, pDiscardRectangles: ptr VkRect2D ): void {.stdcall.}
  vkCmdSetSampleLocationsEXT*: proc(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: ptr VkSampleLocationsInfoEXT ): void {.stdcall.}
  vkGetPhysicalDeviceMultisamplePropertiesEXT*: proc(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: ptr VkMultisamplePropertiesEXT ): void {.stdcall.}
  vkGetPhysicalDeviceSurfaceCapabilities2KHR*: proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pSurfaceCapabilities: ptr VkSurfaceCapabilities2KHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfaceFormats2KHR*: proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pSurfaceFormatCount: ptr uint32 , pSurfaceFormats: ptr VkSurfaceFormat2KHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceDisplayProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayProperties2KHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceDisplayPlaneProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPlaneProperties2KHR ): VkResult {.stdcall.}
  vkGetDisplayModeProperties2KHR*: proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayModeProperties2KHR ): VkResult {.stdcall.}
  vkGetDisplayPlaneCapabilities2KHR*: proc(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: ptr VkDisplayPlaneInfo2KHR , pCapabilities: ptr VkDisplayPlaneCapabilities2KHR ): VkResult {.stdcall.}
  vkGetBufferMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkBufferMemoryRequirementsInfo2 , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}
  vkGetImageMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkImageMemoryRequirementsInfo2 , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}
  vkGetImageSparseMemoryRequirements2*: proc(device: VkDevice, pInfo: ptr VkImageSparseMemoryRequirementsInfo2 , pSparseMemoryRequirementCount: ptr uint32 , pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2 ): void {.stdcall.}
  vkCreateSamplerYcbcrConversion*: proc(device: VkDevice, pCreateInfo: ptr VkSamplerYcbcrConversionCreateInfo , pAllocator: ptr VkAllocationCallbacks , pYcbcrConversion: ptr VkSamplerYcbcrConversion ): VkResult {.stdcall.}
  vkDestroySamplerYcbcrConversion*: proc(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetDeviceQueue2*: proc(device: VkDevice, pQueueInfo: ptr VkDeviceQueueInfo2 , pQueue: ptr VkQueue ): void {.stdcall.}
  vkCreateValidationCacheEXT*: proc(device: VkDevice, pCreateInfo: ptr VkValidationCacheCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pValidationCache: ptr VkValidationCacheEXT ): VkResult {.stdcall.}
  vkDestroyValidationCacheEXT*: proc(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetValidationCacheDataEXT*: proc(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: ptr uint , pData: pointer ): VkResult {.stdcall.}
  vkMergeValidationCachesEXT*: proc(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: uint32, pSrcCaches: ptr VkValidationCacheEXT ): VkResult {.stdcall.}
  vkGetDescriptorSetLayoutSupport*: proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo , pSupport: ptr VkDescriptorSetLayoutSupport ): void {.stdcall.}
  vkGetSwapchainGrallocUsageANDROID*: proc(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, grallocUsage: ptr int ): VkResult {.stdcall.}
  vkGetSwapchainGrallocUsage2ANDROID*: proc(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, swapchainImageUsage: VkSwapchainImageUsageFlagsANDROID, grallocConsumerUsage: ptr uint64 , grallocProducerUsage: ptr uint64 ): VkResult {.stdcall.}
  vkAcquireImageANDROID*: proc(device: VkDevice, image: VkImage, nativeFenceFd: int, semaphore: VkSemaphore, fence: VkFence): VkResult {.stdcall.}
  vkQueueSignalReleaseImageANDROID*: proc(queue: VkQueue, waitSemaphoreCount: uint32, pWaitSemaphores: ptr VkSemaphore , image: VkImage, pNativeFenceFd: ptr int ): VkResult {.stdcall.}
  vkGetShaderInfoAMD*: proc(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: ptr uint , pInfo: pointer ): VkResult {.stdcall.}
  vkSetLocalDimmingAMD*: proc(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32): void {.stdcall.}
  vkGetPhysicalDeviceCalibrateableTimeDomainsEXT*: proc(physicalDevice: VkPhysicalDevice, pTimeDomainCount: ptr uint32 , pTimeDomains: ptr VkTimeDomainEXT ): VkResult {.stdcall.}
  vkGetCalibratedTimestampsEXT*: proc(device: VkDevice, timestampCount: uint32, pTimestampInfos: ptr VkCalibratedTimestampInfoEXT , pTimestamps: ptr uint64 , pMaxDeviation: ptr uint64 ): VkResult {.stdcall.}
  vkSetDebugUtilsObjectNameEXT*: proc(device: VkDevice, pNameInfo: ptr VkDebugUtilsObjectNameInfoEXT ): VkResult {.stdcall.}
  vkSetDebugUtilsObjectTagEXT*: proc(device: VkDevice, pTagInfo: ptr VkDebugUtilsObjectTagInfoEXT ): VkResult {.stdcall.}
  vkQueueBeginDebugUtilsLabelEXT*: proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}
  vkQueueEndDebugUtilsLabelEXT*: proc(queue: VkQueue): void {.stdcall.}
  vkQueueInsertDebugUtilsLabelEXT*: proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}
  vkCmdBeginDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}
  vkCmdEndDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer): void {.stdcall.}
  vkCmdInsertDebugUtilsLabelEXT*: proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}
  vkCreateDebugUtilsMessengerEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkDebugUtilsMessengerCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pMessenger: ptr VkDebugUtilsMessengerEXT ): VkResult {.stdcall.}
  vkDestroyDebugUtilsMessengerEXT*: proc(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkSubmitDebugUtilsMessageEXT*: proc(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT ): void {.stdcall.}
  vkGetMemoryHostPointerPropertiesEXT*: proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: pointer , pMemoryHostPointerProperties: ptr VkMemoryHostPointerPropertiesEXT ): VkResult {.stdcall.}
  vkCmdWriteBufferMarkerAMD*: proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32): void {.stdcall.}
  vkCreateRenderPass2*: proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo2 , pAllocator: ptr VkAllocationCallbacks , pRenderPass: ptr VkRenderPass ): VkResult {.stdcall.}
  vkCmdBeginRenderPass2*: proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo      , pSubpassBeginInfo: ptr VkSubpassBeginInfo      ): void {.stdcall.}
  vkCmdNextSubpass2*: proc(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: ptr VkSubpassBeginInfo      , pSubpassEndInfo: ptr VkSubpassEndInfo        ): void {.stdcall.}
  vkCmdEndRenderPass2*: proc(commandBuffer: VkCommandBuffer, pSubpassEndInfo: ptr VkSubpassEndInfo        ): void {.stdcall.}
  vkGetSemaphoreCounterValue*: proc(device: VkDevice, semaphore: VkSemaphore, pValue: ptr uint64 ): VkResult {.stdcall.}
  vkWaitSemaphores*: proc(device: VkDevice, pWaitInfo: ptr VkSemaphoreWaitInfo , timeout: uint64): VkResult {.stdcall.}
  vkSignalSemaphore*: proc(device: VkDevice, pSignalInfo: ptr VkSemaphoreSignalInfo ): VkResult {.stdcall.}
  vkGetAndroidHardwareBufferPropertiesANDROID*: proc(device: VkDevice, buffer: ptr AHardwareBuffer , pProperties: ptr VkAndroidHardwareBufferPropertiesANDROID ): VkResult {.stdcall.}
  vkGetMemoryAndroidHardwareBufferANDROID*: proc(device: VkDevice, pInfo: ptr VkMemoryGetAndroidHardwareBufferInfoANDROID , pBuffer: ptr ptr AHardwareBuffer ): VkResult {.stdcall.}
  vkCmdDrawIndirectCount*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}
  vkCmdDrawIndexedIndirectCount*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}
  vkCmdSetCheckpointNV*: proc(commandBuffer: VkCommandBuffer, pCheckpointMarker: pointer ): void {.stdcall.}
  vkGetQueueCheckpointDataNV*: proc(queue: VkQueue, pCheckpointDataCount: ptr uint32 , pCheckpointData: ptr VkCheckpointDataNV ): void {.stdcall.}
  vkCmdBindTransformFeedbackBuffersEXT*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize , pSizes: ptr VkDeviceSize ): void {.stdcall.}
  vkCmdBeginTransformFeedbackEXT*: proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer , pCounterBufferOffsets: ptr VkDeviceSize ): void {.stdcall.}
  vkCmdEndTransformFeedbackEXT*: proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer , pCounterBufferOffsets: ptr VkDeviceSize ): void {.stdcall.}
  vkCmdBeginQueryIndexedEXT*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags, index: uint32): void {.stdcall.}
  vkCmdEndQueryIndexedEXT*: proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, index: uint32): void {.stdcall.}
  vkCmdDrawIndirectByteCountEXT*: proc(commandBuffer: VkCommandBuffer, instanceCount: uint32, firstInstance: uint32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: uint32, vertexStride: uint32): void {.stdcall.}
  vkCmdSetExclusiveScissorNV*: proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissors: ptr VkRect2D ): void {.stdcall.}
  vkCmdBindShadingRateImageNV*: proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.}
  vkCmdSetViewportShadingRatePaletteNV*: proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pShadingRatePalettes: ptr VkShadingRatePaletteNV ): void {.stdcall.}
  vkCmdSetCoarseSampleOrderNV*: proc(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32, pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV ): void {.stdcall.}
  vkCmdDrawMeshTasksNV*: proc(commandBuffer: VkCommandBuffer, taskCount: uint32, firstTask: uint32): void {.stdcall.}
  vkCmdDrawMeshTasksIndirectNV*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}
  vkCmdDrawMeshTasksIndirectCountNV*: proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}
  vkCompileDeferredNV*: proc(device: VkDevice, pipeline: VkPipeline, shader: uint32): VkResult {.stdcall.}
  vkCreateAccelerationStructureNV*: proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pAccelerationStructure: ptr VkAccelerationStructureNV ): VkResult {.stdcall.}
  vkDestroyAccelerationStructureKHR*: proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetAccelerationStructureMemoryRequirementsKHR*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoKHR , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}
  vkGetAccelerationStructureMemoryRequirementsNV*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNV , pMemoryRequirements: ptr VkMemoryRequirements2KHR ): void {.stdcall.}
  vkBindAccelerationStructureMemoryKHR*: proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindAccelerationStructureMemoryInfoKHR ): VkResult {.stdcall.}
  vkCmdCopyAccelerationStructureNV*: proc(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureKHR, src: VkAccelerationStructureKHR, mode: VkCopyAccelerationStructureModeKHR): void {.stdcall.}
  vkCmdCopyAccelerationStructureKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureInfoKHR ): void {.stdcall.}
  vkCopyAccelerationStructureKHR*: proc(device: VkDevice, pInfo: ptr VkCopyAccelerationStructureInfoKHR ): VkResult {.stdcall.}
  vkCmdCopyAccelerationStructureToMemoryKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR ): void {.stdcall.}
  vkCopyAccelerationStructureToMemoryKHR*: proc(device: VkDevice, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR ): VkResult {.stdcall.}
  vkCmdCopyMemoryToAccelerationStructureKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR ): void {.stdcall.}
  vkCopyMemoryToAccelerationStructureKHR*: proc(device: VkDevice, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR ): VkResult {.stdcall.}
  vkCmdWriteAccelerationStructuresPropertiesKHR*: proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR , queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}
  vkCmdBuildAccelerationStructureNV*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureInfoNV , instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureKHR, src: VkAccelerationStructureKHR, scratch: VkBuffer, scratchOffset: VkDeviceSize): void {.stdcall.}
  vkWriteAccelerationStructuresPropertiesKHR*: proc(device: VkDevice, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR , queryType: VkQueryType, dataSize: uint, pData: pointer , stride: uint): VkResult {.stdcall.}
  vkCmdTraceRaysKHR*: proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedBufferRegionKHR , pMissShaderBindingTable: ptr VkStridedBufferRegionKHR , pHitShaderBindingTable: ptr VkStridedBufferRegionKHR , pCallableShaderBindingTable: ptr VkStridedBufferRegionKHR , width: uint32, height: uint32, depth: uint32): void {.stdcall.}
  vkCmdTraceRaysNV*: proc(commandBuffer: VkCommandBuffer, raygenShaderBindingTableBuffer: VkBuffer, raygenShaderBindingOffset: VkDeviceSize, missShaderBindingTableBuffer: VkBuffer, missShaderBindingOffset: VkDeviceSize, missShaderBindingStride: VkDeviceSize, hitShaderBindingTableBuffer: VkBuffer, hitShaderBindingOffset: VkDeviceSize, hitShaderBindingStride: VkDeviceSize, callableShaderBindingTableBuffer: VkBuffer, callableShaderBindingOffset: VkDeviceSize, callableShaderBindingStride: VkDeviceSize, width: uint32, height: uint32, depth: uint32): void {.stdcall.}
  vkGetRayTracingShaderGroupHandlesKHR*: proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: uint, pData: pointer ): VkResult {.stdcall.}
  vkGetRayTracingCaptureReplayShaderGroupHandlesKHR*: proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: uint, pData: pointer ): VkResult {.stdcall.}
  vkGetAccelerationStructureHandleNV*: proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, dataSize: uint, pData: pointer ): VkResult {.stdcall.}
  vkCreateRayTracingPipelinesNV*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}
  vkCreateRayTracingPipelinesKHR*: proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}
  vkGetPhysicalDeviceCooperativeMatrixPropertiesNV*: proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkCooperativeMatrixPropertiesNV ): VkResult {.stdcall.}
  vkCmdTraceRaysIndirectKHR*: proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedBufferRegionKHR , pMissShaderBindingTable: ptr VkStridedBufferRegionKHR , pHitShaderBindingTable: ptr VkStridedBufferRegionKHR , pCallableShaderBindingTable: ptr VkStridedBufferRegionKHR , buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}
  vkGetDeviceAccelerationStructureCompatibilityKHR*: proc(device: VkDevice, version: ptr VkAccelerationStructureVersionKHR ): VkResult {.stdcall.}
  vkGetImageViewHandleNVX*: proc(device: VkDevice, pInfo: ptr VkImageViewHandleInfoNVX ): uint32 {.stdcall.}
  vkGetImageViewAddressNVX*: proc(device: VkDevice, imageView: VkImageView, pProperties: ptr VkImageViewAddressPropertiesNVX ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSurfacePresentModes2EXT*: proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pPresentModeCount: ptr uint32 , pPresentModes: ptr VkPresentModeKHR ): VkResult {.stdcall.}
  vkGetDeviceGroupSurfacePresentModes2EXT*: proc(device: VkDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}
  vkAcquireFullScreenExclusiveModeEXT*: proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}
  vkReleaseFullScreenExclusiveModeEXT*: proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}
  vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR*: proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, pCounterCount: ptr uint32 , pCounters: ptr VkPerformanceCounterKHR , pCounterDescriptions: ptr VkPerformanceCounterDescriptionKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR*: proc(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: ptr VkQueryPoolPerformanceCreateInfoKHR , pNumPasses: ptr uint32 ): void {.stdcall.}
  vkAcquireProfilingLockKHR*: proc(device: VkDevice, pInfo: ptr VkAcquireProfilingLockInfoKHR ): VkResult {.stdcall.}
  vkReleaseProfilingLockKHR*: proc(device: VkDevice): void {.stdcall.}
  vkGetImageDrmFormatModifierPropertiesEXT*: proc(device: VkDevice, image: VkImage, pProperties: ptr VkImageDrmFormatModifierPropertiesEXT ): VkResult {.stdcall.}
  vkGetBufferOpaqueCaptureAddress*: proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo ): uint64 {.stdcall.}
  vkGetBufferDeviceAddress*: proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo ): VkDeviceAddress {.stdcall.}
  vkCreateHeadlessSurfaceEXT*: proc(instance: VkInstance, pCreateInfo: ptr VkHeadlessSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}
  vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV*: proc(physicalDevice: VkPhysicalDevice, pCombinationCount: ptr uint32 , pCombinations: ptr VkFramebufferMixedSamplesCombinationNV ): VkResult {.stdcall.}
  vkInitializePerformanceApiINTEL*: proc(device: VkDevice, pInitializeInfo: ptr VkInitializePerformanceApiInfoINTEL ): VkResult {.stdcall.}
  vkUninitializePerformanceApiINTEL*: proc(device: VkDevice): void {.stdcall.}
  vkCmdSetPerformanceMarkerINTEL*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceMarkerInfoINTEL ): VkResult {.stdcall.}
  vkCmdSetPerformanceStreamMarkerINTEL*: proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceStreamMarkerInfoINTEL ): VkResult {.stdcall.}
  vkCmdSetPerformanceOverrideINTEL*: proc(commandBuffer: VkCommandBuffer, pOverrideInfo: ptr VkPerformanceOverrideInfoINTEL ): VkResult {.stdcall.}
  vkAcquirePerformanceConfigurationINTEL*: proc(device: VkDevice, pAcquireInfo: ptr VkPerformanceConfigurationAcquireInfoINTEL , pConfiguration: ptr VkPerformanceConfigurationINTEL ): VkResult {.stdcall.}
  vkReleasePerformanceConfigurationINTEL*: proc(device: VkDevice, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}
  vkQueueSetPerformanceConfigurationINTEL*: proc(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}
  vkGetPerformanceParameterINTEL*: proc(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: ptr VkPerformanceValueINTEL ): VkResult {.stdcall.}
  vkGetDeviceMemoryOpaqueCaptureAddress*: proc(device: VkDevice, pInfo: ptr VkDeviceMemoryOpaqueCaptureAddressInfo ): uint64 {.stdcall.}
  vkGetPipelineExecutablePropertiesKHR*: proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoKHR        , pExecutableCount: ptr uint32 , pProperties: ptr VkPipelineExecutablePropertiesKHR ): VkResult {.stdcall.}
  vkGetPipelineExecutableStatisticsKHR*: proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR  , pStatisticCount: ptr uint32 , pStatistics: ptr VkPipelineExecutableStatisticKHR ): VkResult {.stdcall.}
  vkGetPipelineExecutableInternalRepresentationsKHR*: proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR  , pInternalRepresentationCount: ptr uint32 , pInternalRepresentations: ptr VkPipelineExecutableInternalRepresentationKHR ): VkResult {.stdcall.}
  vkCmdSetLineStippleEXT*: proc(commandBuffer: VkCommandBuffer, lineStippleFactor: uint32, lineStipplePattern: uint16): void {.stdcall.}
  vkGetPhysicalDeviceToolPropertiesEXT*: proc(physicalDevice: VkPhysicalDevice, pToolCount: ptr uint32 , pToolProperties: ptr VkPhysicalDeviceToolPropertiesEXT ): VkResult {.stdcall.}
  vkCreateAccelerationStructureKHR*: proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoKHR        , pAllocator: ptr VkAllocationCallbacks       , pAccelerationStructure: ptr VkAccelerationStructureKHR                        ): VkResult {.stdcall.}
  vkCmdBuildAccelerationStructureKHR*: proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR , ppOffsetInfos: ptr ptr VkAccelerationStructureBuildOffsetInfoKHR ): void {.stdcall.}
  vkCmdBuildAccelerationStructureIndirectKHR*: proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureBuildGeometryInfoKHR , indirectBuffer: VkBuffer, indirectOffset: VkDeviceSize, indirectStride: uint32): void {.stdcall.}
  vkBuildAccelerationStructureKHR*: proc(device: VkDevice, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR , ppOffsetInfos: ptr ptr VkAccelerationStructureBuildOffsetInfoKHR ): VkResult {.stdcall.}
  vkGetAccelerationStructureDeviceAddressKHR*: proc(device: VkDevice, pInfo: ptr VkAccelerationStructureDeviceAddressInfoKHR ): VkDeviceAddress {.stdcall.}
  vkCreateDeferredOperationKHR*: proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks , pDeferredOperation: ptr VkDeferredOperationKHR ): VkResult {.stdcall.}
  vkDestroyDeferredOperationKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkGetDeferredOperationMaxConcurrencyKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): uint32 {.stdcall.}
  vkGetDeferredOperationResultKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}
  vkDeferredOperationJoinKHR*: proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}
  vkCmdSetCullModeEXT*: proc(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags): void {.stdcall.}
  vkCmdSetFrontFaceEXT*: proc(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace): void {.stdcall.}
  vkCmdSetPrimitiveTopologyEXT*: proc(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology): void {.stdcall.}
  vkCmdSetViewportWithCountEXT*: proc(commandBuffer: VkCommandBuffer, viewportCount: uint32, pViewports: ptr VkViewport ): void {.stdcall.}
  vkCmdSetScissorWithCountEXT*: proc(commandBuffer: VkCommandBuffer, scissorCount: uint32, pScissors: ptr VkRect2D ): void {.stdcall.}
  vkCmdBindVertexBuffers2EXT*: proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize , pSizes: ptr VkDeviceSize , pStrides: ptr VkDeviceSize ): void {.stdcall.}
  vkCmdSetDepthTestEnableEXT*: proc(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32): void {.stdcall.}
  vkCmdSetDepthWriteEnableEXT*: proc(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32): void {.stdcall.}
  vkCmdSetDepthCompareOpEXT*: proc(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp): void {.stdcall.}
  vkCmdSetDepthBoundsTestEnableEXT*: proc(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32): void {.stdcall.}
  vkCmdSetStencilTestEnableEXT*: proc(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32): void {.stdcall.}
  vkCmdSetStencilOpEXT*: proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp): void {.stdcall.}
  vkCreatePrivateDataSlotEXT*: proc(device: VkDevice, pCreateInfo: ptr VkPrivateDataSlotCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pPrivateDataSlot: ptr VkPrivateDataSlotEXT ): VkResult {.stdcall.}
  vkDestroyPrivateDataSlotEXT*: proc(device: VkDevice, privateDataSlot: VkPrivateDataSlotEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
  vkSetPrivateDataEXT*: proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlotEXT, data: uint64): VkResult {.stdcall.}
  vkGetPrivateDataEXT*: proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlotEXT, pData: ptr uint64 ): void {.stdcall.}
# Vulkan 1_0
proc vkLoad1_0*() =
 when defined linux:
  vkCreateInstance = cast[proc(pCreateInfo: ptr VkInstanceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pInstance: ptr VkInstance ): VkResult {.stdcall.}](vkGetProc("vkCreateInstance"))
  vkDestroyInstance = cast[proc(instance: VkInstance, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyInstance"))
  vkEnumeratePhysicalDevices = cast[proc(instance: VkInstance, pPhysicalDeviceCount: ptr uint32 , pPhysicalDevices: ptr VkPhysicalDevice ): VkResult {.stdcall.}](vkGetProc("vkEnumeratePhysicalDevices"))
  vkGetPhysicalDeviceFeatures = cast[proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceFeatures"))
  vkGetPhysicalDeviceFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceFormatProperties"))
  vkGetPhysicalDeviceImageFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, typee: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: ptr VkImageFormatProperties ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceImageFormatProperties"))
  vkGetPhysicalDeviceProperties = cast[proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceProperties"))
  vkGetPhysicalDeviceQueueFamilyProperties = cast[proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32 , pQueueFamilyProperties: ptr VkQueueFamilyProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceQueueFamilyProperties"))
  vkGetPhysicalDeviceMemoryProperties = cast[proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceMemoryProperties"))
  vkGetInstanceProcAddr = cast[proc(instance: VkInstance, pName: cstring ): PFN_vkVoidFunction {.stdcall.}](vkGetProc("vkGetInstanceProcAddr"))
  vkGetDeviceProcAddr = cast[proc(device: VkDevice, pName: cstring ): PFN_vkVoidFunction {.stdcall.}](vkGetProc("vkGetDeviceProcAddr"))
  vkCreateDevice = cast[proc(physicalDevice: VkPhysicalDevice, pCreateInfo: ptr VkDeviceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDevice: ptr VkDevice ): VkResult {.stdcall.}](vkGetProc("vkCreateDevice"))
  vkDestroyDevice = cast[proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDevice"))
  vkEnumerateInstanceExtensionProperties = cast[proc(pLayerName: cstring , pPropertyCount: ptr uint32 , pProperties: ptr VkExtensionProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateInstanceExtensionProperties"))
  vkEnumerateDeviceExtensionProperties = cast[proc(physicalDevice: VkPhysicalDevice, pLayerName: cstring , pPropertyCount: ptr uint32 , pProperties: ptr VkExtensionProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateDeviceExtensionProperties"))
  
  
  vkEnumerateInstanceLayerProperties = cast[proc(pPropertyCount: ptr uint32 , pProperties: ptr VkLayerProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateInstanceLayerProperties"))
  vkEnumerateDeviceLayerProperties = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkLayerProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateDeviceLayerProperties"))
  vkGetDeviceQueue = cast[proc(device: VkDevice, queueFamilyIndex: uint32, queueIndex: uint32, pQueue: ptr VkQueue ): void {.stdcall.}](vkGetProc("vkGetDeviceQueue"))
  vkQueueSubmit = cast[proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo , fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkQueueSubmit"))
  vkQueueWaitIdle = cast[proc(queue: VkQueue): VkResult {.stdcall.}](vkGetProc("vkQueueWaitIdle"))
  vkDeviceWaitIdle = cast[proc(device: VkDevice): VkResult {.stdcall.}](vkGetProc("vkDeviceWaitIdle"))
  vkAllocateMemory = cast[proc(device: VkDevice, pAllocateInfo: ptr VkMemoryAllocateInfo , pAllocator: ptr VkAllocationCallbacks , pMemory: ptr VkDeviceMemory ): VkResult {.stdcall.}](vkGetProc("vkAllocateMemory"))
  vkFreeMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkFreeMemory"))
  vkMapMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: ptr pointer ): VkResult {.stdcall.}](vkGetProc("vkMapMemory"))
  vkUnmapMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory): void {.stdcall.}](vkGetProc("vkUnmapMemory"))
  vkFlushMappedMemoryRanges = cast[proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange ): VkResult {.stdcall.}](vkGetProc("vkFlushMappedMemoryRanges"))
  vkInvalidateMappedMemoryRanges = cast[proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange ): VkResult {.stdcall.}](vkGetProc("vkInvalidateMappedMemoryRanges"))
  vkGetDeviceMemoryCommitment = cast[proc(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkGetDeviceMemoryCommitment"))
  vkBindBufferMemory = cast[proc(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}](vkGetProc("vkBindBufferMemory"))
  vkBindImageMemory = cast[proc(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}](vkGetProc("vkBindImageMemory"))
  vkGetBufferMemoryRequirements = cast[proc(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: ptr VkMemoryRequirements ): void {.stdcall.}](vkGetProc("vkGetBufferMemoryRequirements"))
  vkGetImageMemoryRequirements = cast[proc(device: VkDevice, image: VkImage, pMemoryRequirements: ptr VkMemoryRequirements ): void {.stdcall.}](vkGetProc("vkGetImageMemoryRequirements"))
  vkGetImageSparseMemoryRequirements = cast[proc(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: ptr uint32 , pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements ): void {.stdcall.}](vkGetProc("vkGetImageSparseMemoryRequirements"))
  vkGetPhysicalDeviceSparseImageFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, typee: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: ptr uint32 , pProperties: ptr VkSparseImageFormatProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSparseImageFormatProperties"))
  vkQueueBindSparse = cast[proc(queue: VkQueue, bindInfoCount: uint32, pBindInfo: ptr VkBindSparseInfo , fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkQueueBindSparse"))
  vkCreateFence = cast[proc(device: VkDevice, pCreateInfo: ptr VkFenceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}](vkGetProc("vkCreateFence"))
  vkDestroyFence = cast[proc(device: VkDevice, fence: VkFence, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyFence"))
  vkResetFences = cast[proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence ): VkResult {.stdcall.}](vkGetProc("vkResetFences"))
  vkGetFenceStatus = cast[proc(device: VkDevice, fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkGetFenceStatus"))
  vkWaitForFences = cast[proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence , waitAll: VkBool32, timeout: uint64): VkResult {.stdcall.}](vkGetProc("vkWaitForFences"))
  vkCreateSemaphore = cast[proc(device: VkDevice, pCreateInfo: ptr VkSemaphoreCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSemaphore: ptr VkSemaphore ): VkResult {.stdcall.}](vkGetProc("vkCreateSemaphore"))
  vkDestroySemaphore = cast[proc(device: VkDevice, semaphore: VkSemaphore, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySemaphore"))
  vkCreateEvent = cast[proc(device: VkDevice, pCreateInfo: ptr VkEventCreateInfo , pAllocator: ptr VkAllocationCallbacks , pEvent: ptr VkEvent ): VkResult {.stdcall.}](vkGetProc("vkCreateEvent"))
  vkDestroyEvent = cast[proc(device: VkDevice, event: VkEvent, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyEvent"))
  vkGetEventStatus = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetProc("vkGetEventStatus"))
  vkSetEvent = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetProc("vkSetEvent"))
  vkResetEvent = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetProc("vkResetEvent"))
  vkCreateQueryPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkQueryPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pQueryPool: ptr VkQueryPool ): VkResult {.stdcall.}](vkGetProc("vkCreateQueryPool"))
  vkDestroyQueryPool = cast[proc(device: VkDevice, queryPool: VkQueryPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyQueryPool"))
  vkGetQueryPoolResults = cast[proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dataSize: uint, pData: pointer , stride: VkDeviceSize, flags: VkQueryResultFlags): VkResult {.stdcall.}](vkGetProc("vkGetQueryPoolResults"))
  vkCreateBuffer = cast[proc(device: VkDevice, pCreateInfo: ptr VkBufferCreateInfo , pAllocator: ptr VkAllocationCallbacks , pBuffer: ptr VkBuffer ): VkResult {.stdcall.}](vkGetProc("vkCreateBuffer"))
  vkDestroyBuffer = cast[proc(device: VkDevice, buffer: VkBuffer, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyBuffer"))
  vkCreateBufferView = cast[proc(device: VkDevice, pCreateInfo: ptr VkBufferViewCreateInfo , pAllocator: ptr VkAllocationCallbacks , pView: ptr VkBufferView ): VkResult {.stdcall.}](vkGetProc("vkCreateBufferView"))
  vkDestroyBufferView = cast[proc(device: VkDevice, bufferView: VkBufferView, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyBufferView"))
  vkCreateImage = cast[proc(device: VkDevice, pCreateInfo: ptr VkImageCreateInfo , pAllocator: ptr VkAllocationCallbacks , pImage: ptr VkImage ): VkResult {.stdcall.}](vkGetProc("vkCreateImage"))
  vkDestroyImage = cast[proc(device: VkDevice, image: VkImage, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyImage"))
  vkGetImageSubresourceLayout = cast[proc(device: VkDevice, image: VkImage, pSubresource: ptr VkImageSubresource , pLayout: ptr VkSubresourceLayout ): void {.stdcall.}](vkGetProc("vkGetImageSubresourceLayout"))
  vkCreateImageView = cast[proc(device: VkDevice, pCreateInfo: ptr VkImageViewCreateInfo , pAllocator: ptr VkAllocationCallbacks , pView: ptr VkImageView ): VkResult {.stdcall.}](vkGetProc("vkCreateImageView"))
  vkDestroyImageView = cast[proc(device: VkDevice, imageView: VkImageView, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyImageView"))
  vkCreateShaderModule = cast[proc(device: VkDevice, pCreateInfo: ptr VkShaderModuleCreateInfo , pAllocator: ptr VkAllocationCallbacks , pShaderModule: ptr VkShaderModule ): VkResult {.stdcall.}](vkGetProc("vkCreateShaderModule"))
  vkDestroyShaderModule = cast[proc(device: VkDevice, shaderModule: VkShaderModule, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyShaderModule"))
  vkCreatePipelineCache = cast[proc(device: VkDevice, pCreateInfo: ptr VkPipelineCacheCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelineCache: ptr VkPipelineCache ): VkResult {.stdcall.}](vkGetProc("vkCreatePipelineCache"))
  vkDestroyPipelineCache = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyPipelineCache"))
  vkGetPipelineCacheData = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: ptr uint , pData: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetPipelineCacheData"))
  vkMergePipelineCaches = cast[proc(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32, pSrcCaches: ptr VkPipelineCache ): VkResult {.stdcall.}](vkGetProc("vkMergePipelineCaches"))
  vkCreateGraphicsPipelines = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkGraphicsPipelineCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}](vkGetProc("vkCreateGraphicsPipelines"))
  vkCreateComputePipelines = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkComputePipelineCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}](vkGetProc("vkCreateComputePipelines"))
  vkDestroyPipeline = cast[proc(device: VkDevice, pipeline: VkPipeline, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyPipeline"))
  vkCreatePipelineLayout = cast[proc(device: VkDevice, pCreateInfo: ptr VkPipelineLayoutCreateInfo , pAllocator: ptr VkAllocationCallbacks , pPipelineLayout: ptr VkPipelineLayout ): VkResult {.stdcall.}](vkGetProc("vkCreatePipelineLayout"))
  vkDestroyPipelineLayout = cast[proc(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyPipelineLayout"))
  vkCreateSampler = cast[proc(device: VkDevice, pCreateInfo: ptr VkSamplerCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSampler: ptr VkSampler ): VkResult {.stdcall.}](vkGetProc("vkCreateSampler"))
  vkDestroySampler = cast[proc(device: VkDevice, sampler: VkSampler, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySampler"))
  vkCreateDescriptorSetLayout = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo , pAllocator: ptr VkAllocationCallbacks , pSetLayout: ptr VkDescriptorSetLayout ): VkResult {.stdcall.}](vkGetProc("vkCreateDescriptorSetLayout"))
  vkDestroyDescriptorSetLayout = cast[proc(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDescriptorSetLayout"))
  vkCreateDescriptorPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDescriptorPool: ptr VkDescriptorPool ): VkResult {.stdcall.}](vkGetProc("vkCreateDescriptorPool"))
  vkDestroyDescriptorPool = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDescriptorPool"))
  vkResetDescriptorPool = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags): VkResult {.stdcall.}](vkGetProc("vkResetDescriptorPool"))
  vkAllocateDescriptorSets = cast[proc(device: VkDevice, pAllocateInfo: ptr VkDescriptorSetAllocateInfo , pDescriptorSets: ptr VkDescriptorSet ): VkResult {.stdcall.}](vkGetProc("vkAllocateDescriptorSets"))
  vkFreeDescriptorSets = cast[proc(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet ): VkResult {.stdcall.}](vkGetProc("vkFreeDescriptorSets"))
  vkUpdateDescriptorSets = cast[proc(device: VkDevice, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet , descriptorCopyCount: uint32, pDescriptorCopies: ptr VkCopyDescriptorSet ): void {.stdcall.}](vkGetProc("vkUpdateDescriptorSets"))
  vkCreateFramebuffer = cast[proc(device: VkDevice, pCreateInfo: ptr VkFramebufferCreateInfo , pAllocator: ptr VkAllocationCallbacks , pFramebuffer: ptr VkFramebuffer ): VkResult {.stdcall.}](vkGetProc("vkCreateFramebuffer"))
  vkDestroyFramebuffer = cast[proc(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyFramebuffer"))
  vkCreateRenderPass = cast[proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo , pAllocator: ptr VkAllocationCallbacks , pRenderPass: ptr VkRenderPass ): VkResult {.stdcall.}](vkGetProc("vkCreateRenderPass"))
  vkDestroyRenderPass = cast[proc(device: VkDevice, render_pass: VkRenderPass, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyRenderPass"))
  vkGetRenderAreaGranularity = cast[proc(device: VkDevice, render_pass: VkRenderPass, pGranularity: ptr VkExtent2D ): void {.stdcall.}](vkGetProc("vkGetRenderAreaGranularity"))
  vkCreateCommandPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkCommandPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pCommandPool: ptr VkCommandPool ): VkResult {.stdcall.}](vkGetProc("vkCreateCommandPool"))
  vkDestroyCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyCommandPool"))
  vkResetCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags): VkResult {.stdcall.}](vkGetProc("vkResetCommandPool"))
  vkAllocateCommandBuffers = cast[proc(device: VkDevice, pAllocateInfo: ptr VkCommandBufferAllocateInfo , pCommandBuffers: ptr VkCommandBuffer ): VkResult {.stdcall.}](vkGetProc("vkAllocateCommandBuffers"))
  vkFreeCommandBuffers = cast[proc(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer ): void {.stdcall.}](vkGetProc("vkFreeCommandBuffers"))
  vkBeginCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer, pBeginInfo: ptr VkCommandBufferBeginInfo ): VkResult {.stdcall.}](vkGetProc("vkBeginCommandBuffer"))
  vkEndCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer): VkResult {.stdcall.}](vkGetProc("vkEndCommandBuffer"))
  vkResetCommandBuffer = cast[proc(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags): VkResult {.stdcall.}](vkGetProc("vkResetCommandBuffer"))
  vkCmdBindPipeline = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline): void {.stdcall.}](vkGetProc("vkCmdBindPipeline"))
  vkCmdSetViewport = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewports: ptr VkViewport ): void {.stdcall.}](vkGetProc("vkCmdSetViewport"))
  vkCmdSetScissor = cast[proc(commandBuffer: VkCommandBuffer, firstScissor: uint32, scissorCount: uint32, pScissors: ptr VkRect2D ): void {.stdcall.}](vkGetProc("vkCmdSetScissor"))
  vkCmdSetLineWidth = cast[proc(commandBuffer: VkCommandBuffer, lineWidth: float32): void {.stdcall.}](vkGetProc("vkCmdSetLineWidth"))
  vkCmdSetDepthBias = cast[proc(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: float32, depthBiasClamp: float32, depthBiasSlopeFactor: float32): void {.stdcall.}](vkGetProc("vkCmdSetDepthBias"))
  vkCmdSetBlendConstants = cast[proc(commandBuffer: VkCommandBuffer, blendConstants: array[4, float32]): void {.stdcall.}](vkGetProc("vkCmdSetBlendConstants"))
  vkCmdSetDepthBounds = cast[proc(commandBuffer: VkCommandBuffer, minDepthBounds: float32, maxDepthBounds: float32): void {.stdcall.}](vkGetProc("vkCmdSetDepthBounds"))
  vkCmdSetStencilCompareMask = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32): void {.stdcall.}](vkGetProc("vkCmdSetStencilCompareMask"))
  vkCmdSetStencilWriteMask = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32): void {.stdcall.}](vkGetProc("vkCmdSetStencilWriteMask"))
  vkCmdSetStencilReference = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32): void {.stdcall.}](vkGetProc("vkCmdSetStencilReference"))
  vkCmdBindDescriptorSets = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32, descriptorSetCount: uint32, pDescriptorSets: ptr VkDescriptorSet , dynamicOffsetCount: uint32, pDynamicOffsets: ptr uint32 ): void {.stdcall.}](vkGetProc("vkCmdBindDescriptorSets"))
  vkCmdBindIndexBuffer = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType): void {.stdcall.}](vkGetProc("vkCmdBindIndexBuffer"))
  vkCmdBindVertexBuffers = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkCmdBindVertexBuffers"))
  vkCmdDraw = cast[proc(commandBuffer: VkCommandBuffer, vertexCount: uint32, instanceCount: uint32, firstVertex: uint32, firstInstance: uint32): void {.stdcall.}](vkGetProc("vkCmdDraw"))
  vkCmdDrawIndexed = cast[proc(commandBuffer: VkCommandBuffer, indexCount: uint32, instanceCount: uint32, firstIndex: uint32, vertexOffset: int32, firstInstance: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndexed"))
  vkCmdDrawIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndirect"))
  vkCmdDrawIndexedIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndexedIndirect"))
  vkCmdDispatch = cast[proc(commandBuffer: VkCommandBuffer, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetProc("vkCmdDispatch"))
  vkCmdDispatchIndirect = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}](vkGetProc("vkCmdDispatchIndirect"))
  vkCmdCopyBuffer = cast[proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferCopy ): void {.stdcall.}](vkGetProc("vkCmdCopyBuffer"))
  vkCmdCopyImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageCopy ): void {.stdcall.}](vkGetProc("vkCmdCopyImage"))
  vkCmdBlitImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageBlit , filter: VkFilter): void {.stdcall.}](vkGetProc("vkCmdBlitImage"))
  vkCmdCopyBufferToImage = cast[proc(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkBufferImageCopy ): void {.stdcall.}](vkGetProc("vkCmdCopyBufferToImage"))
  vkCmdCopyImageToBuffer = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32, pRegions: ptr VkBufferImageCopy ): void {.stdcall.}](vkGetProc("vkCmdCopyImageToBuffer"))
  vkCmdUpdateBuffer = cast[proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: pointer ): void {.stdcall.}](vkGetProc("vkCmdUpdateBuffer"))
  vkCmdFillBuffer = cast[proc(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32): void {.stdcall.}](vkGetProc("vkCmdFillBuffer"))
  vkCmdClearColorImage = cast[proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: ptr VkClearColorValue , rangeCount: uint32, pRanges: ptr VkImageSubresourceRange ): void {.stdcall.}](vkGetProc("vkCmdClearColorImage"))
  vkCmdClearDepthStencilImage = cast[proc(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: ptr VkClearDepthStencilValue , rangeCount: uint32, pRanges: ptr VkImageSubresourceRange ): void {.stdcall.}](vkGetProc("vkCmdClearDepthStencilImage"))
  vkCmdClearAttachments = cast[proc(commandBuffer: VkCommandBuffer, attachmentCount: uint32, pAttachments: ptr VkClearAttachment , rectCount: uint32, pRects: ptr VkClearRect ): void {.stdcall.}](vkGetProc("vkCmdClearAttachments"))
  vkCmdResolveImage = cast[proc(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32, pRegions: ptr VkImageResolve ): void {.stdcall.}](vkGetProc("vkCmdResolveImage"))
  vkCmdSetEvent = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}](vkGetProc("vkCmdSetEvent"))
  vkCmdResetEvent = cast[proc(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags): void {.stdcall.}](vkGetProc("vkCmdResetEvent"))
  vkCmdWaitEvents = cast[proc(commandBuffer: VkCommandBuffer, eventCount: uint32, pEvents: ptr VkEvent , srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier , bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier , imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier ): void {.stdcall.}](vkGetProc("vkCmdWaitEvents"))
  vkCmdPipelineBarrier = cast[proc(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: uint32, pMemoryBarriers: ptr VkMemoryBarrier , bufferMemoryBarrierCount: uint32, pBufferMemoryBarriers: ptr VkBufferMemoryBarrier , imageMemoryBarrierCount: uint32, pImageMemoryBarriers: ptr VkImageMemoryBarrier ): void {.stdcall.}](vkGetProc("vkCmdPipelineBarrier"))
  vkCmdBeginQuery = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags): void {.stdcall.}](vkGetProc("vkCmdBeginQuery"))
  vkCmdEndQuery = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32): void {.stdcall.}](vkGetProc("vkCmdEndQuery"))
  vkCmdResetQueryPool = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}](vkGetProc("vkCmdResetQueryPool"))
  vkCmdWriteTimestamp = cast[proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: uint32): void {.stdcall.}](vkGetProc("vkCmdWriteTimestamp"))
  vkCmdCopyQueryPoolResults = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags): void {.stdcall.}](vkGetProc("vkCmdCopyQueryPoolResults"))
  vkCmdPushConstants = cast[proc(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32, size: uint32, pValues: pointer ): void {.stdcall.}](vkGetProc("vkCmdPushConstants"))
  vkCmdBeginRenderPass = cast[proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo , contents: VkSubpassContents): void {.stdcall.}](vkGetProc("vkCmdBeginRenderPass"))
  vkCmdNextSubpass = cast[proc(commandBuffer: VkCommandBuffer, contents: VkSubpassContents): void {.stdcall.}](vkGetProc("vkCmdNextSubpass"))
  vkCmdEndRenderPass = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetProc("vkCmdEndRenderPass"))
  vkCmdExecuteCommands = cast[proc(commandBuffer: VkCommandBuffer, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer ): void {.stdcall.}](vkGetProc("vkCmdExecuteCommands"))
 
 when defined windows:
  vkCreateInstance = cast[proc(pCreateInfo: ptr VkInstanceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pInstance: ptr VkInstance ): VkResult {.stdcall.}](vkGetProcAddress("vkCreateInstance"))
  vkGetInstanceProcAddr = cast[proc(instance: VkInstance, pName: cstring ): PFN_vkVoidFunction {.stdcall.}](vkGetProcAddress("vkGetInstanceProcAddr"))
  
 #[  vkDestroyInstance = cast[proc(instance: VkInstance, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyInstance"))
  vkGetPhysicalDeviceFeatures = cast[proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceFeatures"))
  vkGetPhysicalDeviceFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceFormatProperties"))
  vkGetPhysicalDeviceImageFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, typee: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: ptr VkImageFormatProperties ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceImageFormatProperties"))
  vkGetPhysicalDeviceProperties = cast[proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceProperties"))
  
  vkGetPhysicalDeviceMemoryProperties = cast[proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceMemoryProperties"))
  vkGetDeviceProcAddr = cast[proc(device: VkDevice, pName: cstring ): PFN_vkVoidFunction {.stdcall.}](vkGetProc("vkGetDeviceProcAddr"))
  vkCreateDevice = cast[proc(physicalDevice: VkPhysicalDevice, pCreateInfo: ptr VkDeviceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDevice: ptr VkDevice ): VkResult {.stdcall.}](vkGetProc("vkCreateDevice"))
  vkDestroyDevice = cast[proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDevice"))
  vkEnumerateDeviceExtensionProperties = cast[proc(physicalDevice: VkPhysicalDevice, pLayerName: cstring , pPropertyCount: ptr uint32 , pProperties: ptr VkExtensionProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateDeviceExtensionProperties"))
  vkEnumerateInstanceLayerProperties = cast[proc(pPropertyCount: ptr uint32 , pProperties: ptr VkLayerProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateInstanceLayerProperties"))
  vkEnumerateDeviceLayerProperties = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkLayerProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumerateDeviceLayerProperties"))
  vkGetDeviceQueue = cast[proc(device: VkDevice, queueFamilyIndex: uint32, queueIndex: uint32, pQueue: ptr VkQueue ): void {.stdcall.}](vkGetProc("vkGetDeviceQueue"))
  vkQueueSubmit = cast[proc(queue: VkQueue, submitCount: uint32, pSubmits: ptr VkSubmitInfo , fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkQueueSubmit"))
  vkQueueWaitIdle = cast[proc(queue: VkQueue): VkResult {.stdcall.}](vkGetProc("vkQueueWaitIdle"))
  vkDeviceWaitIdle = cast[proc(device: VkDevice): VkResult {.stdcall.}](vkGetProc("vkDeviceWaitIdle"))
  vkAllocateMemory = cast[proc(device: VkDevice, pAllocateInfo: ptr VkMemoryAllocateInfo , pAllocator: ptr VkAllocationCallbacks , pMemory: ptr VkDeviceMemory ): VkResult {.stdcall.}](vkGetProc("vkAllocateMemory"))
  vkFreeMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkFreeMemory"))
  vkMapMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: ptr pointer ): VkResult {.stdcall.}](vkGetProc("vkMapMemory"))
  vkUnmapMemory = cast[proc(device: VkDevice, memory: VkDeviceMemory): void {.stdcall.}](vkGetProc("vkUnmapMemory"))
  vkFlushMappedMemoryRanges = cast[proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange ): VkResult {.stdcall.}](vkGetProc("vkFlushMappedMemoryRanges"))
  vkInvalidateMappedMemoryRanges = cast[proc(device: VkDevice, memoryRangeCount: uint32, pMemoryRanges: ptr VkMappedMemoryRange ): VkResult {.stdcall.}](vkGetProc("vkInvalidateMappedMemoryRanges"))
  vkGetDeviceMemoryCommitment = cast[proc(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkGetDeviceMemoryCommitment"))
  vkBindBufferMemory = cast[proc(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}](vkGetProc("vkBindBufferMemory"))
  vkBindImageMemory = cast[proc(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkResult {.stdcall.}](vkGetProc("vkBindImageMemory"))
  vkGetBufferMemoryRequirements = cast[proc(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: ptr VkMemoryRequirements ): void {.stdcall.}](vkGetProc("vkGetBufferMemoryRequirements"))
  vkGetImageMemoryRequirements = cast[proc(device: VkDevice, image: VkImage, pMemoryRequirements: ptr VkMemoryRequirements ): void {.stdcall.}](vkGetProc("vkGetImageMemoryRequirements"))
  vkGetImageSparseMemoryRequirements = cast[proc(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: ptr uint32 , pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements ): void {.stdcall.}](vkGetProc("vkGetImageSparseMemoryRequirements"))
  vkGetPhysicalDeviceSparseImageFormatProperties = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, typee: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: ptr uint32 , pProperties: ptr VkSparseImageFormatProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSparseImageFormatProperties"))
  vkQueueBindSparse = cast[proc(queue: VkQueue, bindInfoCount: uint32, pBindInfo: ptr VkBindSparseInfo , fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkQueueBindSparse"))
  vkCreateFence = cast[proc(device: VkDevice, pCreateInfo: ptr VkFenceCreateInfo , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}](vkGetProc("vkCreateFence"))
  vkDestroyFence = cast[proc(device: VkDevice, fence: VkFence, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyFence"))
  vkResetFences = cast[proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence ): VkResult {.stdcall.}](vkGetProc("vkResetFences"))
  vkGetFenceStatus = cast[proc(device: VkDevice, fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkGetFenceStatus"))
  vkWaitForFences = cast[proc(device: VkDevice, fenceCount: uint32, pFences: ptr VkFence , waitAll: VkBool32, timeout: uint64): VkResult {.stdcall.}](vkGetProc("vkWaitForFences"))
  
  vkDestroySemaphore = cast[proc(device: VkDevice, semaphore: VkSemaphore, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySemaphore"))
  vkCreateEvent = cast[proc(device: VkDevice, pCreateInfo: ptr VkEventCreateInfo , pAllocator: ptr VkAllocationCallbacks , pEvent: ptr VkEvent ): VkResult {.stdcall.}](vkGetProc("vkCreateEvent"))
  vkDestroyEvent = cast[proc(device: VkDevice, event: VkEvent, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyEvent"))
  vkGetEventStatus = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetProc("vkGetEventStatus"))
  vkSetEvent = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetProc("vkSetEvent"))
  vkResetEvent = cast[proc(device: VkDevice, event: VkEvent): VkResult {.stdcall.}](vkGetProc("vkResetEvent"))
  vkCreateQueryPool = cast[proc(device: VkDevice, pCreateInfo: ptr VkQueryPoolCreateInfo , pAllocator: ptr VkAllocationCallbacks , pQueryPool: ptr VkQueryPool ): VkResult {.stdcall.}](vkGetProc("vkCreateQueryPool"))