--- a/examples/alotof_triangles.nim	Wed Jan 18 13:49:12 2023 +0700
+++ b/examples/alotof_triangles.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -4,14 +4,14 @@
 import std/random
 import std/enumerate
 
-import zamikongine/engine
-import zamikongine/math/vector
-import zamikongine/math/matrix
-import zamikongine/vertex
-import zamikongine/descriptor
-import zamikongine/mesh
-import zamikongine/thing
-import zamikongine/shader
+import semicongine/engine
+import semicongine/math/vector
+import semicongine/math/matrix
+import semicongine/vertex
+import semicongine/descriptor
+import semicongine/mesh
+import semicongine/thing
+import semicongine/shader
 
 type
   VertexDataA = object

--- a/examples/hello_cube.nim	Wed Jan 18 13:49:12 2023 +0700
+++ b/examples/hello_cube.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -12,15 +12,15 @@
 import std/strutils
 import std/enumerate
 
-import zamikongine/engine
-import zamikongine/math/vector
-import zamikongine/math/matrix
-import zamikongine/vertex
-import zamikongine/descriptor
-import zamikongine/mesh
-import zamikongine/thing
-import zamikongine/shader
-import zamikongine/buffer
+import semicongine/engine
+import semicongine/math/vector
+import semicongine/math/matrix
+import semicongine/vertex
+import semicongine/descriptor
+import semicongine/mesh
+import semicongine/thing
+import semicongine/shader
+import semicongine/buffer
 
 type
   # define type of vertex

--- a/examples/hello_triangle.nim	Wed Jan 18 13:49:12 2023 +0700
+++ b/examples/hello_triangle.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -2,15 +2,15 @@
 import std/strutils
 import std/enumerate
 
-import zamikongine/engine
-import zamikongine/math/vector
-import zamikongine/math/matrix
-import zamikongine/vertex
-import zamikongine/descriptor
-import zamikongine/mesh
-import zamikongine/thing
-import zamikongine/shader
-import zamikongine/buffer
+import semicongine/engine
+import semicongine/math/vector
+import semicongine/math/matrix
+import semicongine/vertex
+import semicongine/descriptor
+import semicongine/mesh
+import semicongine/thing
+import semicongine/shader
+import semicongine/buffer
 
 type
   # define type of vertex

--- a/examples/input.nim	Wed Jan 18 13:49:12 2023 +0700
+++ b/examples/input.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -2,15 +2,15 @@
 import std/strutils
 import std/enumerate
 
-import zamikongine/engine
-import zamikongine/math/vector
-import zamikongine/math/matrix
-import zamikongine/vertex
-import zamikongine/descriptor
-import zamikongine/mesh
-import zamikongine/thing
-import zamikongine/shader
-import zamikongine/buffer
+import semicongine/engine
+import semicongine/math/vector
+import semicongine/math/matrix
+import semicongine/vertex
+import semicongine/descriptor
+import semicongine/mesh
+import semicongine/thing
+import semicongine/shader
+import semicongine/buffer
 
 type
   # define type of vertex

--- a/examples/squares.nim	Wed Jan 18 13:49:12 2023 +0700
+++ b/examples/squares.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -4,15 +4,15 @@
 import std/random
 import std/enumerate
 
-import zamikongine/engine
-import zamikongine/math/vector
-import zamikongine/math/matrix
-import zamikongine/vertex
-import zamikongine/descriptor
-import zamikongine/mesh
-import zamikongine/thing
-import zamikongine/shader
-import zamikongine/buffer
+import semicongine/engine
+import semicongine/math/vector
+import semicongine/math/matrix
+import semicongine/vertex
+import semicongine/descriptor
+import semicongine/mesh
+import semicongine/thing
+import semicongine/shader
+import semicongine/buffer
 
 type
   VertexDataA = object

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/buffer.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,128 @@
+import ./vulkan
+import ./vulkan_helpers
+
+type
+  BufferType* = enum
+    None = 0
+    TransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT
+    TransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT
+    UniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
+    IndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT
+    VertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
+  Buffer* = object
+    device*: VkDevice
+    vkBuffer*: VkBuffer
+    size*: uint64
+    memoryRequirements*: VkMemoryRequirements
+    memory*: VkDeviceMemory
+    bufferTypes*: set[BufferType]
+    persistentMapping: bool
+    mapped: pointer
+
+proc trash*(buffer: var Buffer) =
+  assert int64(buffer.vkBuffer) != 0
+  vkDestroyBuffer(buffer.device, buffer.vkBuffer, nil)
+  buffer.vkBuffer = VkBuffer(0)
+  if buffer.size == 0: # for zero-size buffers there are no memory allocations
+    return
+  assert int64(buffer.memory) != 0
+  vkFreeMemory(buffer.device, buffer.memory, nil)
+  buffer.memory = VkDeviceMemory(0)
+
+proc findMemoryType(buffer: Buffer, physicalDevice: VkPhysicalDevice, properties: VkMemoryPropertyFlags): uint32 =
+  var physicalProperties: VkPhysicalDeviceMemoryProperties
+  vkGetPhysicalDeviceMemoryProperties(physicalDevice, addr(physicalProperties))
+
+  for i in 0'u32 ..< physicalProperties.memoryTypeCount:
+    if bool(buffer.memoryRequirements.memoryTypeBits and (1'u32 shl i)) and (uint32(physicalProperties.memoryTypes[i].propertyFlags) and uint32(properties)) == uint32(properties):
+        return i
+
+proc InitBuffer*(
+  device: VkDevice,
+  physicalDevice: VkPhysicalDevice,
+  size: uint64,
+  bufferTypes: set[BufferType],
+  properties: set[VkMemoryPropertyFlagBits],
+  persistentMapping: bool = false
+): Buffer =
+  result = Buffer(device: device, size: size, bufferTypes: bufferTypes, persistentMapping: persistentMapping)
+  var usageFlags = 0
+  for usage in bufferTypes:
+    usageFlags = ord(usageFlags) or ord(usage)
+  var bufferInfo = VkBufferCreateInfo(
+    sType: VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+    size: VkDeviceSize(result.size),
+    usage: VkBufferUsageFlags(usageFlags),
+    sharingMode: VK_SHARING_MODE_EXCLUSIVE,
+  )
+  checkVkResult vkCreateBuffer(result.device, addr(bufferInfo), nil, addr(result.vkBuffer))
+  vkGetBufferMemoryRequirements(result.device, result.vkBuffer, addr(result.memoryRequirements))
+
+  var memoryProperties = 0'u32
+  for prop in properties:
+    memoryProperties = memoryProperties or uint32(prop)
+
+  var allocInfo = VkMemoryAllocateInfo(
+    sType: VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+    allocationSize: result.memoryRequirements.size,
+    memoryTypeIndex: result.findMemoryType(physicalDevice, VkMemoryPropertyFlags(memoryProperties))
+  )
+  if result.size > 0:
+    checkVkResult result.device.vkAllocateMemory(addr(allocInfo), nil, addr(result.memory))
+  checkVkResult result.device.vkBindBufferMemory(result.vkBuffer, result.memory, VkDeviceSize(0))
+  if persistentMapping:
+    checkVkResult vkMapMemory(
+      result.device,
+      result.memory,
+      offset=VkDeviceSize(0),
+      VkDeviceSize(result.size),
+      VkMemoryMapFlags(0),
+      addr(result.mapped)
+    )
+
+
+template withMapping*(buffer: Buffer, data: pointer, body: untyped): untyped =
+  assert not buffer.persistentMapping
+  checkVkResult vkMapMemory(buffer.device, buffer.memory, offset=VkDeviceSize(0), VkDeviceSize(buffer.size), VkMemoryMapFlags(0), addr(data))
+  body
+  vkUnmapMemory(buffer.device, buffer.memory)
+
+# note: does not work with seq, because of sizeof
+proc updateData*[T](buffer: Buffer, data: var T) =
+  if buffer.persistentMapping:
+    copyMem(buffer.mapped, addr(data), sizeof(T))
+  else:
+    var p: pointer
+    buffer.withMapping(p):
+      copyMem(p, addr(data), sizeof(T))
+
+proc copyBuffer*(commandPool: VkCommandPool, queue: VkQueue, src, dst: Buffer, size: uint64) =
+  assert uint64(src.device) == uint64(dst.device)
+  var
+    allocInfo = VkCommandBufferAllocateInfo(
+      sType: VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+      level: VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+      commandPool: commandPool,
+      commandBufferCount: 1,
+    )
+    commandBuffer: VkCommandBuffer
+  checkVkResult vkAllocateCommandBuffers(src.device, addr(allocInfo), addr(commandBuffer))
+
+  var beginInfo = VkCommandBufferBeginInfo(
+    sType: VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+    flags: VkCommandBufferUsageFlags(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT),
+  )
+  checkVkResult vkBeginCommandBuffer(commandBuffer, addr(beginInfo))
+  var copyRegion = VkBufferCopy(size: VkDeviceSize(size))
+  vkCmdCopyBuffer(commandBuffer, src.vkBuffer, dst.vkBuffer, 1, addr(copyRegion))
+  checkVkResult vkEndCommandBuffer(commandBuffer)
+
+  var submitInfo = VkSubmitInfo(
+    sType: VK_STRUCTURE_TYPE_SUBMIT_INFO,
+    commandBufferCount: 1,
+    pCommandBuffers: addr(commandBuffer),
+  )
+
+  checkVkResult vkQueueSubmit(queue, 1, addr(submitInfo), VkFence(0))
+  checkVkResult vkQueueWaitIdle(queue)
+  vkFreeCommandBuffers(src.device, commandPool, 1, addr(commandBuffer))

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/descriptor.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,65 @@
+import std/strutils
+import std/unicode
+import std/strformat
+import std/typetraits
+
+import ./vulkan
+import ./vulkan_helpers
+import ./math/vector
+import ./math/matrix
+import ./buffer
+import ./glsl_helpers
+
+# TODO: check for alignment in uniform blocks
+#
+type
+  DescriptorType = SomeNumber|Vec|Mat
+  Descriptor*[T:DescriptorType] = object
+    value*: T
+
+proc createUniformDescriptorLayout*(device: VkDevice, shaderStage: VkShaderStageFlags, binding: uint32): VkDescriptorSetLayout =
+  var
+    layoutbinding = VkDescriptorSetLayoutBinding(
+      binding: binding,
+      descriptorType: VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+      descriptorCount: 1,
+      stageFlags: shaderStage,
+      pImmutableSamplers: nil,
+    )
+    layoutInfo = VkDescriptorSetLayoutCreateInfo(
+      sType: VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+      bindingCount: 1,
+      pBindings: addr(layoutbinding)
+    )
+  checkVkResult device.vkCreateDescriptorSetLayout(addr(layoutInfo), nil, addr(result))
+
+proc createUniformBuffers*[nBuffers: static int, Uniforms](device: VkDevice, physicalDevice: VkPhysicalDevice): array[nBuffers, Buffer] =
+  let size = sizeof(Uniforms)
+  for i in 0 ..< nBuffers:
+    var buffer = InitBuffer(
+      device,
+      physicalDevice,
+      uint64(size),
+      {UniformBuffer},
+      {VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_MEMORY_PROPERTY_HOST_COHERENT_BIT},
+      persistentMapping=true,
+    )
+    result[i] = buffer
+
+template getDescriptorType*(v: Descriptor): auto = get(genericParams(typeof(v)), 0)
+
+func generateGLSLUniformDeclarations*[Uniforms](binding: int = 0): string {.compileTime.} =
+  var stmtList: seq[string]
+
+  when not (Uniforms is void):
+    let uniformTypeName = name(Uniforms).toUpper()
+    let uniformInstanceName = name(Uniforms).toLower()
+    stmtList.add(&"layout(binding = {binding}) uniform {uniformTypeName} {{")
+    for fieldname, value in Uniforms().fieldPairs:
+      when typeof(value) is Descriptor:
+        let glsltype = getGLSLType[getDescriptorType(value)]()
+        let n = fieldname
+        stmtList.add(&"    {glsltype} {n};")
+    stmtList.add(&"}} {uniformInstanceName};")
+
+  return stmtList.join("\n")

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/engine.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,796 @@
+import std/times
+import std/typetraits
+import std/strformat
+import std/enumerate
+import std/logging
+
+
+import ./vulkan
+import ./vulkan_helpers
+import ./window
+import ./events
+import ./shader
+import ./vertex
+import ./buffer
+import ./thing
+import ./mesh
+import ./descriptor
+
+const MAX_FRAMES_IN_FLIGHT = 2
+const DEBUG_LOG = not defined(release)
+
+var logger = newConsoleLogger()
+addHandler(logger)
+
+
+const VULKAN_VERSION = VK_MAKE_API_VERSION(0'u32, 1'u32, 2'u32, 0'u32)
+const ENGINE_NAME = "zamkongine"
+const ENGINE_VERSION = "0.1"
+const BUILD_VERSION = ENGINE_VERSION & '-' & gorge("git log -1 --format=format:'%H'")
+echo "Engine: " & ENGINE_NAME & " " & BUILD_VERSION
+
+type
+  Device = object
+    device: VkDevice
+    physicalDevice: PhysicalDevice
+    graphicsQueueFamily: uint32
+    presentationQueueFamily: uint32
+    graphicsQueue: VkQueue
+    presentationQueue: VkQueue
+  Swapchain = object
+    swapchain: VkSwapchainKHR
+    images: seq[VkImage]
+    imageviews: seq[VkImageView]
+  RenderPipeline*[VertexType, Uniforms] = object
+    device*: VkDevice
+    shaders*: seq[ShaderProgram[VertexType, Uniforms]]
+    layout*: VkPipelineLayout
+    pipeline*: VkPipeline
+    vertexBuffers*: seq[(seq[Buffer], uint32)]
+    indexedVertexBuffers*: seq[(seq[Buffer], Buffer, uint32, VkIndexType)]
+    descriptorSetLayout*: VkDescriptorSetLayout
+    uniformBuffers*: array[MAX_FRAMES_IN_FLIGHT, Buffer]
+    descriptorPool*: VkDescriptorPool
+    descriptors: array[MAX_FRAMES_IN_FLIGHT, VkDescriptorSet]
+  QueueFamily = object
+    properties*: VkQueueFamilyProperties
+    hasSurfaceSupport*: bool
+  PhysicalDevice = object
+    device*: VkPhysicalDevice
+    extensions*: seq[string]
+    properties*: VkPhysicalDeviceProperties
+    features*: VkPhysicalDeviceFeatures
+    queueFamilies*: seq[QueueFamily]
+    formats: seq[VkSurfaceFormatKHR]
+    presentModes: seq[VkPresentModeKHR]
+  Vulkan* = object
+    debugMessenger*: VkDebugUtilsMessengerEXT
+    instance*: VkInstance
+    deviceList*: seq[PhysicalDevice]
+    device*: Device
+    surface*: VkSurfaceKHR
+    surfaceFormat*: VkSurfaceFormatKHR
+    frameDimension*: VkExtent2D
+    swapchain*: Swapchain
+    framebuffers*: seq[VkFramebuffer]
+    renderPass*: VkRenderPass
+    commandPool*: VkCommandPool
+    commandBuffers*: array[MAX_FRAMES_IN_FLIGHT, VkCommandBuffer]
+    imageAvailableSemaphores*: array[MAX_FRAMES_IN_FLIGHT, VkSemaphore]
+    renderFinishedSemaphores*: array[MAX_FRAMES_IN_FLIGHT, VkSemaphore]
+    inFlightFences*: array[MAX_FRAMES_IN_FLIGHT, VkFence]
+  Input* = object
+    keysDown*: set[Key]
+    keysPressed*: set[Key]
+    keysReleased*: set[Key]
+    mouseDown*: set[MouseButton]
+    mousePressed*: set[MouseButton]
+    mouseReleased*: set[MouseButton]
+    mouseX*: int
+    mouseY*: int
+  Engine* = object
+    vulkan*: Vulkan
+    window*: NativeWindow
+    currentscenedata*: ref Thing
+    input*: Input
+
+proc getAllPhysicalDevices(instance: VkInstance, surface: VkSurfaceKHR): seq[PhysicalDevice] =
+  for vulkanPhysicalDevice in getVulkanPhysicalDevices(instance):
+    var device = PhysicalDevice(device: vulkanPhysicalDevice, extensions: getDeviceExtensions(vulkanPhysicalDevice))
+    vkGetPhysicalDeviceProperties(vulkanPhysicalDevice, addr(device.properties))
+    vkGetPhysicalDeviceFeatures(vulkanPhysicalDevice, addr(device.features))
+    device.formats = vulkanPhysicalDevice.getDeviceSurfaceFormats(surface)
+    device.presentModes = vulkanPhysicalDevice.getDeviceSurfacePresentModes(surface)
+
+    debug(&"Physical device nr {int(vulkanPhysicalDevice)} {cleanString(device.properties.deviceName)}")
+    for i, queueFamilyProperty in enumerate(getQueueFamilies(vulkanPhysicalDevice)):
+      var hasSurfaceSupport: VkBool32 = VK_FALSE
+      checkVkResult vkGetPhysicalDeviceSurfaceSupportKHR(vulkanPhysicalDevice, uint32(i), surface, addr(hasSurfaceSupport))
+      device.queueFamilies.add(QueueFamily(properties: queueFamilyProperty, hasSurfaceSupport: bool(hasSurfaceSupport)))
+      debug(&"  Queue family {i} {queueFamilyProperty}")
+
+    result.add(device)
+
+proc filterForDevice(devices: seq[PhysicalDevice]): seq[(PhysicalDevice, uint32, uint32)] =
+  for device in devices:
+    if not (device.formats.len > 0 and device.presentModes.len > 0 and "VK_KHR_swapchain" in device.extensions):
+      continue
+    var graphicsQueueFamily = high(uint32)
+    var presentationQueueFamily = high(uint32)
+    for i, queueFamily in enumerate(device.queueFamilies):
+      if queueFamily.hasSurfaceSupport:
+        presentationQueueFamily = uint32(i)
+      if bool(uint32(queueFamily.properties.queueFlags) and ord(VK_QUEUE_GRAPHICS_BIT)):
+        graphicsQueueFamily = uint32(i)
+    if graphicsQueueFamily != high(uint32) and presentationQueueFamily != high(uint32):
+      result.add((device, graphicsQueueFamily, presentationQueueFamily))
+
+  for (device, graphicsQueueFamily, presentationQueueFamily) in result:
+    debug(&"Viable device: {cleanString(device.properties.deviceName)} (graphics queue family {graphicsQueueFamily}, presentation queue family {presentationQueueFamily})")
+
+
+proc getFrameDimension(window: NativeWindow, device: VkPhysicalDevice, surface: VkSurfaceKHR): VkExtent2D =
+  let capabilities = device.getSurfaceCapabilities(surface)
+  if capabilities.currentExtent.width != high(uint32):
+    return capabilities.currentExtent
+  else:
+    let (width, height) = window.size()
+    return VkExtent2D(
+      width: min(max(uint32(width), capabilities.minImageExtent.width), capabilities.maxImageExtent.width),
+      height: min(max(uint32(height), capabilities.minImageExtent.height), capabilities.maxImageExtent.height),
+    )
+
+when DEBUG_LOG:
+  proc setupDebugLog(instance: VkInstance): VkDebugUtilsMessengerEXT =
+    var createInfo = VkDebugUtilsMessengerCreateInfoEXT(
+      sType: VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
+      messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT(
+        ord(VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) or
+        ord(VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) or
+        ord(VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)
+      ),
+      messageType: VkDebugUtilsMessageTypeFlagsEXT(
+        ord(VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) or
+        ord(VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) or
+        ord(VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT)
+      ),
+      pfnUserCallback: debugCallback,
+      pUserData: nil,
+    )
+    checkVkResult instance.vkCreateDebugUtilsMessengerEXT(addr(createInfo), nil, addr(result))
+
+proc setupVulkanDeviceAndQueues(instance: VkInstance, surface: VkSurfaceKHR): Device =
+  let usableDevices = instance.getAllPhysicalDevices(surface).filterForDevice()
+  if len(usableDevices) == 0:
+    raise newException(Exception, "No suitable graphics device found")
+  result.physicalDevice = usableDevices[0][0]
+  result.graphicsQueueFamily = usableDevices[0][1]
+  result.presentationQueueFamily = usableDevices[0][2]
+
+  debug(&"Chose device {cleanString(result.physicalDevice.properties.deviceName)}")
+  
+  (result.device, result.graphicsQueue, result.presentationQueue) = getVulcanDevice(
+    result.physicalDevice.device,
+    result.physicalDevice.features,
+    result.graphicsQueueFamily,
+    result.presentationQueueFamily,
+  )
+
+proc setupSwapChain(device: VkDevice, physicalDevice: PhysicalDevice, surface: VkSurfaceKHR, dimension: VkExtent2D, surfaceFormat: VkSurfaceFormatKHR): Swapchain =
+
+  let capabilities = physicalDevice.device.getSurfaceCapabilities(surface)
+  var selectedPresentationMode = getPresentMode(physicalDevice.presentModes)
+  # setup swapchain
+  var swapchainCreateInfo = VkSwapchainCreateInfoKHR(
+    sType: VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
+    surface: surface,
+    minImageCount: max(capabilities.minImageCount + 1, capabilities.maxImageCount),
+    imageFormat: surfaceFormat.format,
+    imageColorSpace: surfaceFormat.colorSpace,
+    imageExtent: dimension,
+    imageArrayLayers: 1,
+    imageUsage: VkImageUsageFlags(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT),
+    # VK_SHARING_MODE_CONCURRENT no supported (i.e cannot use different queue families for  drawing to swap surface?)
+    imageSharingMode: VK_SHARING_MODE_EXCLUSIVE,
+    preTransform: capabilities.currentTransform,
+    compositeAlpha: VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+    presentMode: selectedPresentationMode,
+    clipped: VK_TRUE,
+    oldSwapchain: VkSwapchainKHR(0),
+  )
+  checkVkResult device.vkCreateSwapchainKHR(addr(swapchainCreateInfo), nil, addr(result.swapchain))
+  result.images = device.getSwapChainImages(result.swapchain)
+
+  # setup swapchian image views
+
+  result.imageviews = newSeq[VkImageView](result.images.len)
+  for i, image in enumerate(result.images):
+    var imageViewCreateInfo = VkImageViewCreateInfo(
+      sType: VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+      image: image,
+      viewType: VK_IMAGE_VIEW_TYPE_2D,
+      format: surfaceFormat.format,
+      components: VkComponentMapping(
+        r: VK_COMPONENT_SWIZZLE_IDENTITY,
+        g: VK_COMPONENT_SWIZZLE_IDENTITY,
+        b: VK_COMPONENT_SWIZZLE_IDENTITY,
+        a: VK_COMPONENT_SWIZZLE_IDENTITY,
+      ),
+      subresourceRange: VkImageSubresourceRange(
+        aspectMask: VkImageAspectFlags(VK_IMAGE_ASPECT_COLOR_BIT),
+        baseMipLevel: 0,
+        levelCount: 1,
+        baseArrayLayer: 0,
+        layerCount: 1,
+      ),
+    )
+    checkVkResult device.vkCreateImageView(addr(imageViewCreateInfo), nil, addr(result.imageviews[i]))
+
+proc setupRenderPass(device: VkDevice, format: VkFormat): VkRenderPass =
+  var
+    colorAttachment = VkAttachmentDescription(
+      format: format,
+      samples: VK_SAMPLE_COUNT_1_BIT,
+      loadOp: VK_ATTACHMENT_LOAD_OP_CLEAR,
+      storeOp: VK_ATTACHMENT_STORE_OP_STORE,
+      stencilLoadOp: VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+      stencilStoreOp: VK_ATTACHMENT_STORE_OP_DONT_CARE,
+      initialLayout: VK_IMAGE_LAYOUT_UNDEFINED,
+      finalLayout: VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+    )
+    colorAttachmentRef = VkAttachmentReference(
+      attachment: 0,
+      layout: VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+    )
+    subpass = VkSubpassDescription(
+      pipelineBindPoint: VK_PIPELINE_BIND_POINT_GRAPHICS,
+      colorAttachmentCount: 1,
+      pColorAttachments: addr(colorAttachmentRef)
+    )
+    dependency = VkSubpassDependency(
+      srcSubpass: VK_SUBPASS_EXTERNAL,
+      dstSubpass: 0,
+      srcStageMask: VkPipelineStageFlags(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT),
+      srcAccessMask: VkAccessFlags(0),
+      dstStageMask: VkPipelineStageFlags(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT),
+      dstAccessMask: VkAccessFlags(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT),
+    )
+    renderPassCreateInfo = VkRenderPassCreateInfo(
+      sType: VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
+      attachmentCount: 1,
+      pAttachments: addr(colorAttachment),
+      subpassCount: 1,
+      pSubpasses: addr(subpass),
+      dependencyCount: 1,
+      pDependencies: addr(dependency),
+    )
+  checkVkResult device.vkCreateRenderPass(addr(renderPassCreateInfo), nil, addr(result))
+
+proc initRenderPipeline[VertexType, Uniforms](device: VkDevice, frameDimension: VkExtent2D, renderPass: VkRenderPass, vertexShader, fragmentShader: static string): RenderPipeline[VertexType, Uniforms] =
+  # load shaders
+  result.device = device
+  result.shaders.add(initShaderProgram[VertexType, Uniforms](device, VK_SHADER_STAGE_VERTEX_BIT, vertexShader))
+  result.shaders.add(initShaderProgram[VertexType, Uniforms](device, VK_SHADER_STAGE_FRAGMENT_BIT, fragmentShader))
+
+  var
+    # define which parts can be dynamic (pipeline is fixed after setup)
+    dynamicStates = [VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR]
+    dynamicState = VkPipelineDynamicStateCreateInfo(
+      sType: VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
+      dynamicStateCount: uint32(dynamicStates.len),
+      pDynamicStates: addr(dynamicStates[0]),
+    )
+    vertexbindings = generateInputVertexBinding[VertexType]()
+    attributebindings = generateInputAttributeBinding[VertexType]()
+
+    # define input data format
+    vertexInputInfo = VkPipelineVertexInputStateCreateInfo(
+      sType: VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+      vertexBindingDescriptionCount: uint32(vertexbindings.len),
+      pVertexBindingDescriptions: addr(vertexbindings[0]),
+      vertexAttributeDescriptionCount: uint32(attributebindings.len),
+      pVertexAttributeDescriptions: addr(attributebindings[0]),
+    )
+    inputAssembly = VkPipelineInputAssemblyStateCreateInfo(
+      sType: VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
+      topology: VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
+      primitiveRestartEnable: VK_FALSE,
+    )
+
+  # setup viewport
+  var viewportState = VkPipelineViewportStateCreateInfo(
+    sType: VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+    viewportCount: 1,
+    scissorCount: 1,
+  )
+
+  # rasterizerization config
+  var
+    rasterizer = VkPipelineRasterizationStateCreateInfo(
+      sType: VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
+      depthClampEnable: VK_FALSE,
+      rasterizerDiscardEnable: VK_FALSE,
+      polygonMode: VK_POLYGON_MODE_FILL,
+      lineWidth: 1.0,
+      cullMode: VkCullModeFlags(VK_CULL_MODE_BACK_BIT),
+      frontFace: VK_FRONT_FACE_CLOCKWISE,
+      depthBiasEnable: VK_FALSE,
+      depthBiasConstantFactor: 0.0,
+      depthBiasClamp: 0.0,
+      depthBiasSlopeFactor: 0.0,
+    )
+    multisampling = VkPipelineMultisampleStateCreateInfo(
+      sType: VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
+      sampleShadingEnable: VK_FALSE,
+      rasterizationSamples: VK_SAMPLE_COUNT_1_BIT,
+      minSampleShading: 1.0,
+      pSampleMask: nil,
+      alphaToCoverageEnable: VK_FALSE,
+      alphaToOneEnable: VK_FALSE,
+    )
+    colorBlendAttachment = VkPipelineColorBlendAttachmentState(
+      colorWriteMask: VkColorComponentFlags(
+        ord(VK_COLOR_COMPONENT_R_BIT) or
+        ord(VK_COLOR_COMPONENT_G_BIT) or
+        ord(VK_COLOR_COMPONENT_B_BIT) or
+        ord(VK_COLOR_COMPONENT_A_BIT)
+      ),
+      blendEnable: VK_TRUE,
+      srcColorBlendFactor: VK_BLEND_FACTOR_SRC_ALPHA,
+      dstColorBlendFactor: VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+      colorBlendOp: VK_BLEND_OP_ADD,
+      srcAlphaBlendFactor: VK_BLEND_FACTOR_ONE,
+      dstAlphaBlendFactor: VK_BLEND_FACTOR_ZERO,
+      alphaBlendOp: VK_BLEND_OP_ADD,
+    )
+    colorBlending = VkPipelineColorBlendStateCreateInfo(
+      sType: VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
+      logicOpEnable: VK_TRUE,
+      logicOp: VK_LOGIC_OP_COPY,
+      attachmentCount: 1,
+      pAttachments: addr(colorBlendAttachment),
+      blendConstants: [0.0'f, 0.0'f, 0.0'f, 0.0'f],
+    )
+
+  result.descriptorSetLayout = device.createUniformDescriptorLayout(VkShaderStageFlags(VK_SHADER_STAGE_VERTEX_BIT), 0)
+  var 
+    # "globals" that go into the shader, uniforms etc.
+    pipelineLayoutInfo = VkPipelineLayoutCreateInfo(
+      sType: VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
+      setLayoutCount: 1,
+      pSetLayouts: addr(result.descriptorSetLayout),
+      pushConstantRangeCount: 0,
+      pPushConstantRanges: nil,
+    )
+  checkVkResult vkCreatePipelineLayout(device, addr(pipelineLayoutInfo), nil, addr(result.layout))
+
+  var stages: seq[VkPipelineShaderStageCreateInfo]
+  for shader in result.shaders:
+    stages.add(shader.shader)
+  var pipelineInfo = VkGraphicsPipelineCreateInfo(
+    sType: VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
+    stageCount: uint32(stages.len),
+    pStages: addr(stages[0]),
+    pVertexInputState: addr(vertexInputInfo),
+    pInputAssemblyState: addr(inputAssembly),
+    pViewportState: addr(viewportState),
+    pRasterizationState: addr(rasterizer),
+    pMultisampleState: addr(multisampling),
+    pDepthStencilState: nil,
+    pColorBlendState: addr(colorBlending),
+    pDynamicState: addr(dynamicState),
+    layout: result.layout,
+    renderPass: renderPass,
+    subpass: 0,
+    basePipelineHandle: VkPipeline(0),
+    basePipelineIndex: -1,
+  )
+  checkVkResult vkCreateGraphicsPipelines(
+    device,
+    VkPipelineCache(0),
+    1,
+    addr(pipelineInfo),
+    nil,
+    addr(result.pipeline)
+  )
+
+proc setupFramebuffers(device: VkDevice, swapchain: var Swapchain, renderPass: VkRenderPass, dimension: VkExtent2D): seq[VkFramebuffer] =
+  result = newSeq[VkFramebuffer](swapchain.images.len)
+  for i, imageview in enumerate(swapchain.imageviews):
+    var framebufferInfo = VkFramebufferCreateInfo(
+      sType: VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+      renderPass: renderPass,
+      attachmentCount: 1,
+      pAttachments: addr(swapchain.imageviews[i]),
+      width: dimension.width,
+      height: dimension.height,
+      layers: 1,
+    )
+    checkVkResult device.vkCreateFramebuffer(addr(framebufferInfo), nil, addr(result[i]))
+  
+proc trash(device: VkDevice, swapchain: Swapchain, framebuffers: seq[VkFramebuffer]) =
+  for framebuffer in framebuffers:
+    device.vkDestroyFramebuffer(framebuffer, nil)
+  for imageview in swapchain.imageviews:
+    device.vkDestroyImageView(imageview, nil)
+  device.vkDestroySwapchainKHR(swapchain.swapchain, nil)
+
+proc recreateSwapchain(vulkan: Vulkan): (Swapchain, seq[VkFramebuffer]) =
+  debug(&"Recreate swapchain with dimension {vulkan.frameDimension}")
+  checkVkResult vulkan.device.device.vkDeviceWaitIdle()
+
+  vulkan.device.device.trash(vulkan.swapchain, vulkan.framebuffers)
+
+  result[0] = vulkan.device.device.setupSwapChain(
+    vulkan.device.physicalDevice,
+    vulkan.surface,
+    vulkan.frameDimension,
+    vulkan.surfaceFormat
+  )
+  result[1] = vulkan.device.device.setupFramebuffers(
+    result[0],
+    vulkan.renderPass,
+    vulkan.frameDimension
+  )
+
+
+proc setupCommandBuffers(device: VkDevice, graphicsQueueFamily: uint32): (VkCommandPool, array[MAX_FRAMES_IN_FLIGHT, VkCommandBuffer]) =
+  # set up command buffer
+  var poolInfo = VkCommandPoolCreateInfo(
+    sType: VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+    flags: VkCommandPoolCreateFlags(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT),
+    queueFamilyIndex: graphicsQueueFamily,
+  )
+  checkVkResult device.vkCreateCommandPool(addr(poolInfo), nil, addr(result[0]))
+
+  var allocInfo = VkCommandBufferAllocateInfo(
+    sType: VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+    commandPool: result[0],
+    level: VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+    commandBufferCount: result[1].len.uint32,
+  )
+  checkVkResult device.vkAllocateCommandBuffers(addr(allocInfo), addr(result[1][0]))
+
+proc setupSyncPrimitives(device: VkDevice): (
+    array[MAX_FRAMES_IN_FLIGHT, VkSemaphore],
+    array[MAX_FRAMES_IN_FLIGHT, VkSemaphore],
+    array[MAX_FRAMES_IN_FLIGHT, VkFence],
+) =
+  var semaphoreInfo = VkSemaphoreCreateInfo(sType: VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO)
+  var fenceInfo = VkFenceCreateInfo(
+    sType: VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
+    flags: VkFenceCreateFlags(VK_FENCE_CREATE_SIGNALED_BIT)
+  )
+  for i in 0 ..< MAX_FRAMES_IN_FLIGHT:
+    checkVkResult device.vkCreateSemaphore(addr(semaphoreInfo), nil, addr(result[0][i]))
+    checkVkResult device.vkCreateSemaphore(addr(semaphoreInfo), nil, addr(result[1][i]))
+    checkVkResult device.vkCreateFence(addr(fenceInfo), nil, addr(result[2][i]))
+
+proc igniteEngine*(windowTitle: string): Engine =
+
+  result.window = createWindow(windowTitle)
+
+  # setup vulkan functions
+  vkLoad1_0()
+  vkLoad1_1()
+  vkLoad1_2()
+
+  # create vulkan instance
+  result.vulkan.instance = createVulkanInstance(VULKAN_VERSION)
+  when DEBUG_LOG:
+    result.vulkan.debugMessenger = result.vulkan.instance.setupDebugLog()
+  result.vulkan.surface = result.vulkan.instance.createVulkanSurface(result.window)
+  result.vulkan.device = result.vulkan.instance.setupVulkanDeviceAndQueues(result.vulkan.surface)
+
+  # get basic frame information
+  result.vulkan.surfaceFormat = result.vulkan.device.physicalDevice.formats.getSuitableSurfaceFormat()
+  result.vulkan.frameDimension = result.window.getFrameDimension(result.vulkan.device.physicalDevice.device, result.vulkan.surface)
+
+  # setup swapchain and render pipeline
+  result.vulkan.swapchain = result.vulkan.device.device.setupSwapChain(
+    result.vulkan.device.physicalDevice,
+    result.vulkan.surface,
+    result.vulkan.frameDimension,
+    result.vulkan.surfaceFormat
+  )
+  result.vulkan.renderPass = result.vulkan.device.device.setupRenderPass(result.vulkan.surfaceFormat.format)
+  result.vulkan.framebuffers = result.vulkan.device.device.setupFramebuffers(
+    result.vulkan.swapchain,
+    result.vulkan.renderPass,
+    result.vulkan.frameDimension
+  )
+  (
+    result.vulkan.commandPool,
+    result.vulkan.commandBuffers,
+  ) = result.vulkan.device.device.setupCommandBuffers(result.vulkan.device.graphicsQueueFamily)
+
+  (
+    result.vulkan.imageAvailableSemaphores,
+    result.vulkan.renderFinishedSemaphores,
+    result.vulkan.inFlightFences,
+  ) = result.vulkan.device.device.setupSyncPrimitives()
+
+
+proc setupPipeline*[VertexType; UniformType; IndexType: uint16|uint32](engine: var Engine, scenedata: ref Thing, vertexShader, fragmentShader: static string): RenderPipeline[VertexType, UniformType] =
+  engine.currentscenedata = scenedata
+  result = initRenderPipeline[VertexType, UniformType](
+    engine.vulkan.device.device,
+    engine.vulkan.frameDimension,
+    engine.vulkan.renderPass,
+    vertexShader,
+    fragmentShader,
+  )
+  # vertex buffers
+  var allmeshes: seq[Mesh[VertexType]]
+  for mesh in partsOfType[ref Mesh[VertexType]](engine.currentscenedata):
+    allmeshes.add(mesh[])
+  if allmeshes.len > 0:
+    var ubermesh = createUberMesh(allmeshes)
+    result.vertexBuffers.add createVertexBuffers(ubermesh, result.device, engine.vulkan.device.physicalDevice.device, engine.vulkan.commandPool, engine.vulkan.device.graphicsQueue)
+
+  when not (IndexType is void):
+    # vertex buffers with indexes
+    var allindexedmeshes: seq[IndexedMesh[VertexType, IndexType]]
+    for mesh in partsOfType[ref IndexedMesh[VertexType, IndexType]](engine.currentscenedata):
+      allindexedmeshes.add(mesh[])
+    if allindexedmeshes.len > 0:
+      var indexedubermesh = createUberMesh(allindexedmeshes)
+      result.indexedVertexBuffers.add createIndexedVertexBuffers(indexedubermesh, result.device, engine.vulkan.device.physicalDevice.device, engine.vulkan.commandPool, engine.vulkan.device.graphicsQueue)
+
+  # uniform buffers
+  result.uniformBuffers = createUniformBuffers[MAX_FRAMES_IN_FLIGHT, UniformType](
+    result.device,
+    engine.vulkan.device.physicalDevice.device
+  )
+
+  var
+    poolSize = VkDescriptorPoolSize(
+      `type`: VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+      descriptorCount: uint32(MAX_FRAMES_IN_FLIGHT),
+    )
+    poolInfo = VkDescriptorPoolCreateInfo(
+      sType: VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
+      poolSizeCount: 1,
+      pPoolSizes: addr(poolSize),
+      maxSets: uint32(MAX_FRAMES_IN_FLIGHT),
+    )
+  checkVkResult vkCreateDescriptorPool(result.device, addr(poolInfo), nil, addr(result.descriptorPool))
+
+  var layouts: array[MAX_FRAMES_IN_FLIGHT, VkDescriptorSetLayout]
+  for i in 0 ..< MAX_FRAMES_IN_FLIGHT:
+    layouts[i] = result.descriptorSetLayout
+  var allocInfo = VkDescriptorSetAllocateInfo(
+    sType: VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
+    descriptorPool: result.descriptorPool,
+    descriptorSetCount: uint32(MAX_FRAMES_IN_FLIGHT),
+    pSetLayouts: addr(layouts[0]),
+  )
+
+  checkVkResult vkAllocateDescriptorSets(result.device, addr(allocInfo), addr(result.descriptors[0]))
+
+  var bufferInfos: array[MAX_FRAMES_IN_FLIGHT, array[1, VkDescriptorBufferInfo]] # because we use only one Uniform atm
+  for i in 0 ..< MAX_FRAMES_IN_FLIGHT:
+    bufferInfos[i][0] = VkDescriptorBufferInfo(
+      buffer: result.uniformBuffers[i].vkBuffer,
+      offset: VkDeviceSize(0),
+      range: VkDeviceSize(sizeof(UniformType)),
+    )
+    var descriptorWrite = VkWriteDescriptorSet(
+        sType: VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+        dstSet: result.descriptors[i],
+        dstBinding: 0,
+        dstArrayElement: 0,
+        descriptorType: VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+        descriptorCount: 1,
+        pBufferInfo: cast[ptr ptr VkDescriptorBufferInfo](addr(bufferInfos[i][0])),
+      )
+    vkUpdateDescriptorSets(result.device, 1, addr(descriptorWrite), 0, nil)
+
+
+proc runPipeline[VertexType; Uniforms](commandBuffer: VkCommandBuffer, pipeline: var RenderPipeline[VertexType, Uniforms], currentFrame: int) =
+  vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.pipeline)
+
+  vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.layout, 0, 1, addr(pipeline.descriptors[currentFrame]), 0, nil)
+  for (vertexBufferSet, vertexCount) in pipeline.vertexBuffers:
+    var
+      vertexBuffers: seq[VkBuffer]
+      offsets: seq[VkDeviceSize]
+    for buffer in vertexBufferSet:
+      vertexBuffers.add buffer.vkBuffer
+      offsets.add VkDeviceSize(0)
+
+    vkCmdBindVertexBuffers(commandBuffer, firstBinding=0'u32, bindingCount=uint32(vertexBuffers.len), pBuffers=addr(vertexBuffers[0]), pOffsets=addr(offsets[0]))
+    vkCmdDraw(commandBuffer, vertexCount=vertexCount, instanceCount=1'u32, firstVertex=0'u32, firstInstance=0'u32)
+
+  for (vertexBufferSet, indexBuffer, indicesCount, indexType) in pipeline.indexedVertexBuffers:
+    var
+      vertexBuffers: seq[VkBuffer]
+      offsets: seq[VkDeviceSize]
+    for buffer in vertexBufferSet:
+      vertexBuffers.add buffer.vkBuffer
+      offsets.add VkDeviceSize(0)
+
+    vkCmdBindVertexBuffers(commandBuffer, firstBinding=0'u32, bindingCount=uint32(vertexBuffers.len), pBuffers=addr(vertexBuffers[0]), pOffsets=addr(offsets[0]))
+    vkCmdBindIndexBuffer(commandBuffer, indexBuffer.vkBuffer, VkDeviceSize(0), indexType)
+    vkCmdDrawIndexed(commandBuffer, indicesCount, 1, 0, 0, 0)
+
+proc recordCommandBuffer(renderPass: VkRenderPass, pipeline: var RenderPipeline, commandBuffer: VkCommandBuffer, framebuffer: VkFramebuffer, frameDimension: VkExtent2D, currentFrame: int) =
+  var
+    beginInfo = VkCommandBufferBeginInfo(
+      sType: VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+      pInheritanceInfo: nil,
+    )
+    clearColor = VkClearValue(color: VkClearColorValue(float32: [0.2'f, 0.2'f, 0.2'f, 1.0'f]))
+    renderPassInfo = VkRenderPassBeginInfo(
+      sType: VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+      renderPass: renderPass,
+      framebuffer: framebuffer,
+      renderArea: VkRect2D(
+        offset: VkOffset2D(x: 0, y: 0),
+        extent: frameDimension,
+      ),
+      clearValueCount: 1,
+      pClearValues: addr(clearColor),
+    )
+    viewport = VkViewport(
+      x: 0.0,
+      y: 0.0,
+      width: (float) frameDimension.width,
+      height: (float) frameDimension.height,
+      minDepth: 0.0,
+      maxDepth: 1.0,
+    )
+    scissor = VkRect2D(
+      offset: VkOffset2D(x: 0, y: 0),
+      extent: frameDimension
+    )
+  checkVkResult vkBeginCommandBuffer(commandBuffer, addr(beginInfo))
+  block:
+    vkCmdBeginRenderPass(commandBuffer, addr(renderPassInfo), VK_SUBPASS_CONTENTS_INLINE)
+    vkCmdSetViewport(commandBuffer, firstViewport=0, viewportCount=1, addr(viewport))
+    vkCmdSetScissor(commandBuffer, firstScissor=0, scissorCount=1, addr(scissor))
+    runPipeline(commandBuffer, pipeline, currentFrame)
+    vkCmdEndRenderPass(commandBuffer)
+  checkVkResult vkEndCommandBuffer(commandBuffer)
+
+proc drawFrame(window: NativeWindow, vulkan: var Vulkan, currentFrame: int, resized: bool, pipeline: var RenderPipeline) =
+  checkVkResult vkWaitForFences(vulkan.device.device, 1, addr(vulkan.inFlightFences[currentFrame]), VK_TRUE, high(uint64))
+  var bufferImageIndex: uint32
+  let nextImageResult = vkAcquireNextImageKHR(
+    vulkan.device.device,
+    vulkan.swapchain.swapchain,
+    high(uint64),
+    vulkan.imageAvailableSemaphores[currentFrame],
+    VkFence(0),
+    addr(bufferImageIndex)
+  )
+  if nextImageResult == VK_ERROR_OUT_OF_DATE_KHR:
+    vulkan.frameDimension = window.getFrameDimension(vulkan.device.physicalDevice.device, vulkan.surface)
+    (vulkan.swapchain, vulkan.framebuffers) = vulkan.recreateSwapchain()
+  elif not (nextImageResult in [VK_SUCCESS, VK_SUBOPTIMAL_KHR]):
+    raise newException(Exception, "Vulkan error: vkAcquireNextImageKHR returned " & $nextImageResult)
+  checkVkResult vkResetFences(vulkan.device.device, 1, addr(vulkan.inFlightFences[currentFrame]))
+
+  checkVkResult vkResetCommandBuffer(vulkan.commandBuffers[currentFrame], VkCommandBufferResetFlags(0))
+  vulkan.renderPass.recordCommandBuffer(pipeline, vulkan.commandBuffers[currentFrame], vulkan.framebuffers[bufferImageIndex], vulkan.frameDimension, currentFrame)
+  var
+    waitSemaphores = [vulkan.imageAvailableSemaphores[currentFrame]]
+    waitStages = [VkPipelineStageFlags(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT)]
+    signalSemaphores = [vulkan.renderFinishedSemaphores[currentFrame]]
+    submitInfo = VkSubmitInfo(
+      sType: VK_STRUCTURE_TYPE_SUBMIT_INFO,
+      waitSemaphoreCount: 1,
+      pWaitSemaphores: addr(waitSemaphores[0]),
+      pWaitDstStageMask: addr(waitStages[0]),
+      commandBufferCount: 1,
+      pCommandBuffers: addr(vulkan.commandBuffers[currentFrame]),
+      signalSemaphoreCount: 1,
+      pSignalSemaphores: addr(signalSemaphores[0]),
+    )
+  checkVkResult vkQueueSubmit(vulkan.device.graphicsQueue, 1, addr(submitInfo), vulkan.inFlightFences[currentFrame])
+
+  var presentInfo = VkPresentInfoKHR(
+    sType: VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+    waitSemaphoreCount: 1,
+    pWaitSemaphores: addr(signalSemaphores[0]),
+    swapchainCount: 1,
+    pSwapchains: addr(vulkan.swapchain.swapchain),
+    pImageIndices: addr(bufferImageIndex),
+    pResults: nil,
+  )
+  let presentResult = vkQueuePresentKHR(vulkan.device.presentationQueue, addr(presentInfo))
+
+  if presentResult == VK_ERROR_OUT_OF_DATE_KHR or presentResult == VK_SUBOPTIMAL_KHR or resized:
+    vulkan.frameDimension = window.getFrameDimension(vulkan.device.physicalDevice.device, vulkan.surface)
+    (vulkan.swapchain, vulkan.framebuffers) = vulkan.recreateSwapchain()
+
+
+proc run*(engine: var Engine, pipeline: var RenderPipeline, globalUpdate: proc(engine: var Engine, dt: float32)) =
+  var
+    killed = false
+    currentFrame = 0
+    resized = false
+    lastUpdate = getTime()
+
+  while not killed:
+
+    # process input
+    engine.input.keysPressed = {}
+    engine.input.keysReleased = {}
+    engine.input.mousePressed = {}
+    engine.input.mouseReleased = {}
+    for event in engine.window.pendingEvents():
+      case event.eventType:
+        of Quit:
+          killed = true
+        of ResizedWindow:
+          resized = true
+        of KeyPressed:
+          engine.input.keysPressed.incl event.key
+          engine.input.keysDown.incl event.key
+        of KeyReleased:
+          engine.input.keysReleased.incl event.key
+          engine.input.keysDown.excl event.key
+        of MousePressed:
+          engine.input.mousePressed.incl event.button
+          engine.input.mouseDown.incl event.button
+        of MouseReleased:
+          engine.input.mouseReleased.incl event.button
+          engine.input.mouseDown.excl event.button
+        of MouseMoved:
+          engine.input.mouseX = event.x
+          engine.input.mouseY = event.y
+        else:
+          discard
+
+    # game logic update
+    let
+      now = getTime()
+      dt = float32(float64((now - lastUpdate).inNanoseconds) / 1_000_000_000'f64)
+    lastUpdate = now
+    engine.globalUpdate(dt)
+    for entity in allEntities(engine.currentscenedata):
+      entity.update(dt)
+
+    # submit frame for drawing
+    engine.window.drawFrame(engine.vulkan, currentFrame, resized, pipeline)
+    resized = false
+    currentFrame = (currentFrame + 1) mod MAX_FRAMES_IN_FLIGHT
+  checkVkResult vkDeviceWaitIdle(engine.vulkan.device.device)
+
+proc trash*(pipeline: var RenderPipeline) =
+  vkDestroyDescriptorPool(pipeline.device, pipeline.descriptorPool, nil)
+  vkDestroyDescriptorSetLayout(pipeline.device, pipeline.descriptorSetLayout, nil)
+  vkDestroyPipeline(pipeline.device, pipeline.pipeline, nil)
+  vkDestroyPipelineLayout(pipeline.device, pipeline.layout, nil)
+  for shader in pipeline.shaders:
+    vkDestroyShaderModule(pipeline.device, shader.shader.module, nil)
+
+  for (bufferset, cnt) in pipeline.vertexBuffers.mitems:
+    for buffer in bufferset.mitems:
+      buffer.trash()
+  for (bufferset, indexbuffer, cnt, t) in pipeline.indexedVertexBuffers.mitems:
+    indexbuffer.trash()
+    for buffer in bufferset.mitems:
+      buffer.trash()
+  for buffer in pipeline.uniformBuffers.mitems:
+    buffer.trash()
+
+proc trash*(engine: var Engine) =
+  checkVkResult vkDeviceWaitIdle(engine.vulkan.device.device)
+  engine.vulkan.device.device.trash(engine.vulkan.swapchain, engine.vulkan.framebuffers)
+
+  for i in 0 ..< MAX_FRAMES_IN_FLIGHT:
+    engine.vulkan.device.device.vkDestroySemaphore(engine.vulkan.imageAvailableSemaphores[i], nil)
+    engine.vulkan.device.device.vkDestroySemaphore(engine.vulkan.renderFinishedSemaphores[i], nil)
+    engine.vulkan.device.device.vkDestroyFence(engine.vulkan.inFlightFences[i], nil)
+
+  engine.vulkan.device.device.vkDestroyRenderPass(engine.vulkan.renderPass, nil)
+  engine.vulkan.device.device.vkDestroyCommandPool(engine.vulkan.commandPool, nil)
+
+  engine.vulkan.instance.vkDestroySurfaceKHR(engine.vulkan.surface, nil)
+  engine.vulkan.device.device.vkDestroyDevice(nil)
+  when DEBUG_LOG:
+    engine.vulkan.instance.vkDestroyDebugUtilsMessengerEXT(engine.vulkan.debugMessenger, nil)
+  engine.window.trash()
+  engine.vulkan.instance.vkDestroyInstance(nil) # needs to happen after window is trashed as the driver might have a hook registered for the window destruction

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/events.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,29 @@
+type
+  EventType* = enum
+    Quit
+    ResizedWindow
+    KeyPressed, KeyReleased
+    MousePressed, MouseReleased, MouseMoved,
+  Key* {.size: sizeof(cint), pure.} = enum
+    UNKNOWN
+    Escape, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12
+    NumberRowExtra1, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `0`, NumberRowExtra2, NumberRowExtra3 # tilde, minus, plus
+    A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z
+    Tab, CapsLock, ShiftL, ShiftR, CtrlL, CtrlR, SuperL, SuperR, AltL, AltR, Space, Enter, Backspace
+    LetterRow1Extra1, LetterRow1Extra2, LetterRow1Extra3 # open bracket, close brackt, backslash
+    LetterRow2Extra1, LetterRow2Extra2 # semicolon, quote
+    LetterRow3Extra1, LetterRow3Extra2, LetterRow3Extra3 # comma, period, slash
+    Up, Down, Left, Right
+    PageUp, PageDown, Home, End, Insert, Delete
+  MouseButton* {.size: sizeof(cint), pure.} = enum
+    UNKNOWN, Mouse1, Mouse2, Mouse3
+  Event* = object
+    case eventType*: EventType
+    of KeyPressed, KeyReleased:
+      key*: Key
+    of MousePressed, MouseReleased:
+      button*: MouseButton
+    of MouseMoved:
+      x*, y*: int
+    else:
+      discard

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/glsl_helpers.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,67 @@
+import ./math/vector
+import ./math/matrix
+
+func getGLSLType*[T](): string =
+  # todo: likely not correct as we would need to enable some 
+  # extensions somewhere (Vulkan/GLSL compiler?) to have 
+  # everything work as intended. Or maybe the GPU driver does
+  # some automagic conversion stuf..
+  when T is uint8:         "uint"
+  elif T is int8:          "int"
+  elif T is uint16:        "uint"
+  elif T is int16:         "int"
+  elif T is uint32:        "uint"
+  elif T is int32:         "int"
+  elif T is uint64:        "uint"
+  elif T is int64:         "int"
+  elif T is float32:       "float"
+  elif T is float64:       "double"
+
+  elif T is Vec2[uint8]:   "uvec2"
+  elif T is Vec2[int8]:    "ivec2"
+  elif T is Vec2[uint16]:  "uvec2"
+  elif T is Vec2[int16]:   "ivec2"
+  elif T is Vec2[uint32]:  "uvec2"
+  elif T is Vec2[int32]:   "ivec2"
+  elif T is Vec2[uint64]:  "uvec2"
+  elif T is Vec2[int64]:   "ivec2"
+  elif T is Vec2[float32]: "vec2"
+  elif T is Vec2[float64]: "dvec2"
+
+  elif T is Vec3[uint8]:   "uvec3"
+  elif T is Vec3[int8]:    "ivec3"
+  elif T is Vec3[uint16]:  "uvec3"
+  elif T is Vec3[int16]:   "ivec3"
+  elif T is Vec3[uint32]:  "uvec3"
+  elif T is Vec3[int32]:   "ivec3"
+  elif T is Vec3[uint64]:  "uvec3"
+  elif T is Vec3[int64]:   "ivec3"
+  elif T is Vec3[float32]: "vec3"
+  elif T is Vec3[float64]: "dvec3"
+
+  elif T is Vec4[uint8]:   "uvec4"
+  elif T is Vec4[int8]:    "ivec4"
+  elif T is Vec4[uint16]:  "uvec4"
+  elif T is Vec4[int16]:   "ivec4"
+  elif T is Vec4[uint32]:  "uvec4"
+  elif T is Vec4[int32]:   "ivec4"
+  elif T is Vec4[uint64]:  "uvec4"
+  elif T is Vec4[int64]:   "ivec4"
+  elif T is Vec4[float32]: "vec4"
+  elif T is Vec4[float64]: "dvec4"
+
+  elif T is Mat22[float32]: "mat2"
+  elif T is Mat23[float32]: "mat32"
+  elif T is Mat32[float32]: "mat23"
+  elif T is Mat33[float32]: "mat3"
+  elif T is Mat34[float32]: "mat43"
+  elif T is Mat43[float32]: "mat34"
+  elif T is Mat44[float32]: "mat4"
+
+  elif T is Mat22[float64]: "dmat2"
+  elif T is Mat23[float64]: "dmat32"
+  elif T is Mat32[float64]: "dmat23"
+  elif T is Mat33[float64]: "dmat3"
+  elif T is Mat34[float64]: "dmat43"
+  elif T is Mat43[float64]: "dmat34"
+  elif T is Mat44[float64]: "dmat4"

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/math/matrix.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,391 @@
+import std/math
+import std/macros
+import std/random
+import std/strutils
+import std/typetraits
+
+import ./vector
+
+export math
+
+type
+  # layout is row-first
+  # having an object instead of directly aliasing the array seems a bit ugly at
+  # first, but is necessary to be able to work correctly with distinguished
+  # types (i.e. Mat23 and Mat32 would be an alias for the same type array[6, T]
+  # which prevents the type system from identifying the correct type at times)
+  #
+  # Though, great news is that objects have zero overhead!
+  Mat22*[T: SomeNumber] = object
+    data*: array[4, T]
+  Mat23*[T: SomeNumber] = object
+    data*: array[6, T]
+  Mat32*[T: SomeNumber] = object
+    data*: array[6, T]
+  Mat33*[T: SomeNumber] = object
+    data*: array[9, T]
+  Mat34*[T: SomeNumber] = object
+    data*: array[12, T]
+  Mat43*[T: SomeNumber] = object
+    data*: array[12, T]
+  Mat44*[T: SomeNumber] = object
+    data*: array[16, T]
+  MatMM* = Mat22|Mat33|Mat44
+  MatMN* = Mat23|Mat32|Mat34|Mat43
+  Mat* = MatMM|MatMN
+
+func unit22[T: SomeNumber](): auto {.compiletime.} = Mat22[T](data:[
+  T(1), T(0),
+  T(0), T(1),
+])
+func unit33[T: SomeNumber](): auto {.compiletime.} = Mat33[T](data:[
+  T(1), T(0), T(0),
+  T(0), T(1), T(0),
+  T(0), T(0), T(1),
+])
+func unit44[T: SomeNumber](): auto {.compiletime.} = Mat44[T](data: [
+  T(1), T(0), T(0), T(0),
+  T(0), T(1), T(0), T(0),
+  T(0), T(0), T(1), T(0),
+  T(0), T(0), T(0), T(1),
+])
+
+# generates constants: Unit
+# Also for Y, Z, R, G, B
+# not sure if this is necessary or even a good idea...
+macro generateAllConsts() =
+  result = newStmtList()
+  for theType in ["int", "int8", "int16", "int32", "int64", "float", "float32", "float64"]:
+    var typename = theType[0 .. 0]
+    if theType[^2].isDigit:
+      typename = typename & theType[^2]
+    if theType[^1].isDigit:
+      typename = typename & theType[^1]
+    result.add(newConstStmt(
+      postfix(ident("Unit22" & typename), "*"),
+      newCall(nnkBracketExpr.newTree(ident("unit22"), ident(theType)))
+    ))
+    result.add(newConstStmt(
+      postfix(ident("Unit33" & typename), "*"),
+      newCall(nnkBracketExpr.newTree(ident("unit33"), ident(theType)))
+    ))
+    result.add(newConstStmt(
+      postfix(ident("Unit44" & typename), "*"),
+      newCall(nnkBracketExpr.newTree(ident("unit44"), ident(theType)))
+    ))
+
+generateAllConsts()
+
+const Unit22* = unit22[float]()
+const Unit33* = unit33[float]()
+const Unit44* = unit44[float]()
+
+template rowCount*(m: typedesc): int =
+  when m is Mat22: 2
+  elif m is Mat23: 2
+  elif m is Mat32: 3
+  elif m is Mat33: 3
+  elif m is Mat34: 3
+  elif m is Mat43: 4
+  elif m is Mat44: 4
+template columnCount*(m: typedesc): int =
+  when m is Mat22: 2
+  elif m is Mat23: 3
+  elif m is Mat32: 2
+  elif m is Mat33: 3
+  elif m is Mat34: 4
+  elif m is Mat43: 3
+  elif m is Mat44: 4
+
+
+func toString[T](value: T): string =
+  var
+    strvalues: seq[string]
+    maxwidth = 0
+
+  for n in value.data:
+    let strval = $n
+    strvalues.add(strval)
+    if strval.len > maxwidth:
+      maxwidth = strval.len
+
+  for i in 0 ..< strvalues.len:
+    let filler = " ".repeat(maxwidth - strvalues[i].len)
+    if i mod T.columnCount == T.columnCount - 1:
+      result &= filler & strvalues[i] & "\n"
+    else:
+      if i mod T.columnCount == 0:
+        result &= "  "
+      result &= filler & strvalues[i] & "  "
+  result = $T & "\n" & result
+
+func `$`*(v: Mat22[SomeNumber]): string = toString[Mat22[SomeNumber]](v)
+func `$`*(v: Mat23[SomeNumber]): string = toString[Mat23[SomeNumber]](v)
+func `$`*(v: Mat32[SomeNumber]): string = toString[Mat32[SomeNumber]](v)
+func `$`*(v: Mat33[SomeNumber]): string = toString[Mat33[SomeNumber]](v)
+func `$`*(v: Mat34[SomeNumber]): string = toString[Mat34[SomeNumber]](v)
+func `$`*(v: Mat43[SomeNumber]): string = toString[Mat43[SomeNumber]](v)
+func `$`*(v: Mat44[SomeNumber]): string = toString[Mat44[SomeNumber]](v)
+
+func `[]`*[T: Mat](m: T, row, col: int): auto = m.data[col + row * T.columnCount]
+proc `[]=`*[T: Mat, U](m: var T, row, col: int, value: U) = m.data[col + row * T.columnCount] = value
+
+func row*[T: Mat22](m: T, i: 0..1): auto = Vec2([m[i, 0], m[i, 1]])
+func row*[T: Mat32](m: T, i: 0..2): auto = Vec2([m[i, 0], m[i, 1]])
+func row*[T: Mat23](m: T, i: 0..1): auto = Vec3([m[i, 0], m[i, 1], m[i, 2]])
+func row*[T: Mat33](m: T, i: 0..2): auto = Vec3([m[i, 0], m[i, 1], m[i, 2]])
+func row*[T: Mat43](m: T, i: 0..3): auto = Vec3([m[i, 0], m[i, 1], m[i, 2]])
+func row*[T: Mat34](m: T, i: 0..2): auto = Vec4([m[i, 0], m[i, 1], m[i, 2], m[i, 3]])
+func row*[T: Mat44](m: T, i: 0..3): auto = Vec4([m[i, 0], m[i, 1], m[i, 2], m[i, 3]])
+
+func col*[T: Mat22](m: T, i: 0..1): auto = Vec2([m[0, i], m[1, i]])
+func col*[T: Mat23](m: T, i: 0..2): auto = Vec2([m[0, i], m[1, i]])
+func col*[T: Mat32](m: T, i: 0..1): auto = Vec3([m[0, i], m[1, i], m[2, i]])
+func col*[T: Mat33](m: T, i: 0..2): auto = Vec3([m[0, i], m[1, i], m[2, i]])
+func col*[T: Mat34](m: T, i: 0..3): auto = Vec3([m[0, i], m[1, i], m[2, i]])
+func col*[T: Mat43](m: T, i: 0..2): auto = Vec4([m[0, i], m[1, i], m[2, i], m[3, i]])
+func col*[T: Mat44](m: T, i: 0..3): auto = Vec4([m[0, i], m[1, i], m[2, i], m[3, i]])
+
+proc createMatMatMultiplicationOperator(leftType: typedesc, rightType: typedesc, outType: typedesc): NimNode =
+  var data = nnkBracket.newTree()
+  for i in 0 ..< rowCount(leftType):
+    for j in 0 ..< rightType.columnCount:
+      data.add(newCall(
+        ident("sum"),
+        infix(
+          newCall(newDotExpr(ident("a"), ident("row")), newLit(i)),
+          "*",
+          newCall(newDotExpr(ident("b"), ident("col")), newLit(j))
+        )
+      ))
+
+  return newProc(
+    postfix(nnkAccQuoted.newTree(ident("*")), "*"),
+    params=[
+      ident("auto"),
+      newIdentDefs(ident("a"), ident(leftType.name)),
+      newIdentDefs(ident("b"), ident(rightType.name))
+    ],
+    body=nnkObjConstr.newTree(ident(outType.name), nnkExprColonExpr.newTree(ident("data"), data)),
+    procType=nnkFuncDef,
+  )
+
+proc createVecMatMultiplicationOperator(matType: typedesc, vecType: typedesc): NimNode =
+  var data = nnkBracket.newTree()
+  for i in 0 ..< matType.rowCount:
+    data.add(newCall(
+      ident("sum"),
+      infix(
+        ident("v"),
+        "*",
+        newCall(newDotExpr(ident("m"), ident("row")), newLit(i))
+      )
+    ))
+
+  let resultVec = newCall(
+    nnkBracketExpr.newTree(ident(vecType.name), ident("T")),
+    data,
+  )
+  let name = postfix(nnkAccQuoted.newTree(ident("*")), "*")
+  let genericParams = nnkGenericParams.newTree(nnkIdentDefs.newTree(ident("T"), ident("SomeNumber"), newEmptyNode()))
+  let formalParams = nnkFormalParams.newTree(
+    ident("auto"),
+    newIdentDefs(ident("m"), nnkBracketExpr.newTree(ident(matType.name), ident("T"))),
+    newIdentDefs(ident("v"), nnkBracketExpr.newTree(ident(vecType.name), ident("T"))),
+  )
+
+  return nnkFuncDef.newTree(
+    name,
+    newEmptyNode(),
+    genericParams,
+    formalParams,
+    newEmptyNode(),
+    newEmptyNode(),
+    resultVec
+  )
+   
+
+proc createMatScalarOperator(matType: typedesc, op: string): NimNode =
+  result = newStmtList()
+
+  var data = nnkBracket.newTree()
+  for i in 0 ..< matType.rowCount * matType.columnCount:
+    data.add(infix(nnkBracketExpr.newTree(newDotExpr(ident("a"), ident("data")), newLit(i)), op, ident("b")))
+  result.add(newProc(
+    postfix(nnkAccQuoted.newTree(ident(op)), "*"),
+    params=[
+      ident("auto"),
+      newIdentDefs(ident("a"), ident(matType.name)),
+      newIdentDefs(ident("b"), ident("SomeNumber")),
+    ],
+    body=nnkObjConstr.newTree(ident(matType.name), nnkExprColonExpr.newTree(ident("data"), data)),
+    procType=nnkFuncDef,
+  ))
+  result.add(newProc(
+    postfix(nnkAccQuoted.newTree(ident(op)), "*"),
+    params=[
+      ident("auto"),
+      newIdentDefs(ident("b"), ident("SomeNumber")),
+      newIdentDefs(ident("a"), ident(matType.name)),
+    ],
+    body=nnkObjConstr.newTree(ident(matType.name), nnkExprColonExpr.newTree(ident("data"), data)),
+    procType=nnkFuncDef,
+  ))
+  if op == "-":
+    var data2 = nnkBracket.newTree()
+    for i in 0 ..< matType.rowCount * matType.columnCount:
+      data2.add(prefix(nnkBracketExpr.newTree(newDotExpr(ident("a"), ident("data")), newLit(i)), op))
+    result.add(newProc(
+      postfix(nnkAccQuoted.newTree(ident(op)), "*"),
+      params=[
+        ident("auto"),
+        newIdentDefs(ident("a"), ident(matType.name)),
+      ],
+      body=nnkObjConstr.newTree(ident(matType.name), nnkExprColonExpr.newTree(ident("data"), data2)),
+      procType=nnkFuncDef,
+    ))
+
+macro createAllMultiplicationOperators() =
+  result = newStmtList()
+
+  for op in ["+", "-", "*", "/"]:
+    result.add(createMatScalarOperator(Mat22, op))
+    result.add(createMatScalarOperator(Mat23, op))
+    result.add(createMatScalarOperator(Mat32, op))
+    result.add(createMatScalarOperator(Mat33, op))
+    result.add(createMatScalarOperator(Mat34, op))
+    result.add(createMatScalarOperator(Mat43, op))
+    result.add(createMatScalarOperator(Mat44, op))
+
+  result.add(createMatMatMultiplicationOperator(Mat22, Mat22, Mat22))
+  result.add(createMatMatMultiplicationOperator(Mat22, Mat23, Mat23))
+  result.add(createMatMatMultiplicationOperator(Mat23, Mat32, Mat22))
+  result.add(createMatMatMultiplicationOperator(Mat23, Mat33, Mat23))
+  result.add(createMatMatMultiplicationOperator(Mat32, Mat22, Mat32))
+  result.add(createMatMatMultiplicationOperator(Mat32, Mat23, Mat33))
+  result.add(createMatMatMultiplicationOperator(Mat33, Mat32, Mat32))
+  result.add(createMatMatMultiplicationOperator(Mat33, Mat33, Mat33))
+  result.add(createMatMatMultiplicationOperator(Mat33, Mat34, Mat34))
+  result.add(createMatMatMultiplicationOperator(Mat43, Mat33, Mat43))
+  result.add(createMatMatMultiplicationOperator(Mat43, Mat34, Mat44))
+  result.add(createMatMatMultiplicationOperator(Mat44, Mat43, Mat43))
+  result.add(createMatMatMultiplicationOperator(Mat44, Mat44, Mat44))
+
+  result.add(createVecMatMultiplicationOperator(Mat22, Vec2))
+  result.add(createVecMatMultiplicationOperator(Mat33, Vec3))
+  result.add(createVecMatMultiplicationOperator(Mat44, Vec4))
+
+createAllMultiplicationOperators()
+
+
+func transposed*[T](m: Mat22[T]): Mat22[T] = Mat22[T](data: [
+  m[0, 0], m[1, 0],
+  m[0, 1], m[1, 1],
+])
+func transposed*[T](m: Mat23[T]): Mat32[T] = Mat32[T](data: [
+  m[0, 0], m[1, 0],
+  m[0, 1], m[1, 1],
+  m[0, 2], m[1, 2],
+])
+func transposed*[T](m: Mat32[T]): Mat23[T] = Mat23[T](data: [
+  m[0, 0], m[1, 0], m[2, 0],
+  m[0, 1], m[1, 1], m[2, 1],
+])
+func transposed*[T](m: Mat33[T]): Mat33[T] = Mat33[T](data: [
+  m[0, 0], m[1, 0], m[2, 0],
+  m[0, 1], m[1, 1], m[2, 1],
+  m[0, 2], m[1, 2], m[2, 2],
+])
+func transposed*[T](m: Mat43[T]): Mat34[T] = Mat34[T](data: [
+  m[0, 0], m[1, 0], m[2, 0], m[3, 0],
+  m[0, 1], m[1, 1], m[2, 1], m[3, 1],
+  m[0, 2], m[1, 2], m[2, 2], m[3, 2],
+])
+func transposed*[T](m: Mat34[T]): Mat43[T] = Mat43[T](data: [
+  m[0, 0], m[1, 0], m[2, 0],
+  m[0, 1], m[1, 1], m[2, 1],
+  m[0, 2], m[1, 2], m[2, 2],
+  m[0, 3], m[1, 3], m[2, 3],
+])
+func transposed*[T](m: Mat44[T]): Mat44[T] = Mat44[T](data: [
+  m[0, 0], m[1, 0], m[2, 0], m[3, 0],
+  m[0, 1], m[1, 1], m[2, 1], m[3, 1],
+  m[0, 2], m[1, 2], m[2, 2], m[3, 2],
+  m[0, 3], m[1, 3], m[2, 3], m[3, 3],
+])
+
+func translate2d*[T](x, y: T): Mat33[T] = Mat33[T](data: [
+  T(1), T(0), x,
+  T(0), T(1), y,
+  T(0), T(0), T(1),
+])
+func scale2d*[T](sx, sy: T): Mat33[T] = Mat33[T](data: [
+  sx, T(0), T(0),
+  T(0), sy, T(0),
+  T(0), T(0), T(1),
+])
+func rotate2d*[T](angle: T): Mat33[T] = Mat33[T](data: [
+  cos(angle), -sin(angle), T(0),
+  sin(angle), cos(angle), T(0),
+  T(0), T(0), T(1),
+])
+func translate3d*[T](x, y, z: T): Mat44[T] = Mat44[T](data: [
+  T(1), T(0), T(0), x,
+  T(0), T(1), T(0), y,
+  T(0), T(0), T(1), z,
+  T(0), T(0), T(0), T(1),
+])
+func scale3d*[T](sx, sy, sz: T): Mat44[T] = Mat44[T](data: [
+  sx, T(0), T(0), T(0),
+  T(0), sy, T(0), T(0),
+  T(0), T(0), sz, T(0),
+  T(0), T(0),  T(0), T(1),
+])
+func rotate3d*[T](angle: T, a: Vec3[T]): Mat44[T] =
+  let
+    cosa = cos(angle)
+    sina = sin(angle)
+    x = a[0]
+    y = a[1]
+    z = a[2]
+  Mat44[T](data: [
+    x * x * (1 - cosa) + cosa,     y * x * (1 - cosa) - z * sina, z * x * (1 - cosa) + y * sina, T(0),
+    x * y * (1 - cosa) + z * sina, y * y * (1 - cosa) + cosa,     z * y * (1 - cosa) - x * sina, T(0),
+    x * z * (1 - cosa) - y * sina, y * z * (1 - cosa) + x * sina, z * z * (1 - cosa) + cosa,     T(0),
+    T(0),                          T(0),                          T(0),                          T(1),
+  ])
+
+
+# call e.g. Mat32[int]().randomized() to get a random matrix
+template makeRandomInit(mattype: typedesc) =
+    proc randomized*[T: SomeInteger](m: mattype[T]): mattype[T] =
+      for i in 0 ..< result.data.len:
+        result.data[i] = rand(low(typeof(m.data[0])) .. high(typeof(m.data[0])))
+    proc randomized*[T: SomeFloat](m: mattype[T]): mattype[T] =
+      for i in 0 ..< result.data.len:
+        result.data[i] = rand(1.0)
+
+makeRandomInit(Mat22)
+makeRandomInit(Mat23)
+makeRandomInit(Mat32)
+makeRandomInit(Mat33)
+makeRandomInit(Mat34)
+makeRandomInit(Mat43)
+makeRandomInit(Mat44)
+
+func perspective*[T: SomeFloat](fovy, aspect, zNear, zFar: T): Mat44[T] =
+  let tanHalfFovy = tan(fovy / T(2))
+  return Mat44[T](data:[
+    T(1) / (aspect * tanHalfFovy), T(0),               T(0),                     T(0),
+    T(0),                          T(1) / tanHalfFovy, T(0),                     T(0),
+    T(0),                          T(0),               T(zFar / (zFar - zNear)), T(-(zFar * zNear) / (zFar - zNear)),
+    T(0),                          T(0),               T(1),                     T(1),
+  ])
+
+func ortho*[T: SomeFloat](left, right, bottom, top, zNear, zFar: T): Mat44[T] =
+  Mat44[T](data:[
+    T(2) / (right - left), T(0),                  T(0),                  -(right + left) / (right - left),
+    T(0),                  T(2) / (top - bottom), T(0),                  -(top + bottom) / (top - bottom),
+    T(0),                  T(0),                  T(1) / (zFar - zNear), -zNear / (zFar - zNear),
+    T(0),                  T(0),                  T(1),                  T(1),
+  ])

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/math/vector.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,230 @@
+import std/random
+import std/math
+import std/strutils
+import std/macros
+import std/typetraits
+import std/tables
+
+export math
+
+
+type
+  Vec2*[T: SomeNumber] = array[2, T]
+  Vec3*[T: SomeNumber] = array[3, T]
+  Vec4*[T: SomeNumber] = array[4, T]
+  Vec* = Vec2|Vec3|Vec4
+
+converter toVec2*[T: SomeNumber](orig: Vec3[T]|Vec4[T]): Vec2[T] =
+  Vec2[T]([orig[0], orig[1]])
+converter toVec3*[T: SomeNumber](orig: Vec4[T]): Vec3[T] =
+  Vec2[T]([orig[0], orig[1], orig[2]])
+
+# define some often used constants
+func ConstOne2[T: SomeNumber](): auto {.compiletime.} = Vec2[T]([T(1), T(1)])
+func ConstOne3[T: SomeNumber](): auto {.compiletime.} = Vec3[T]([T(1), T(1), T(1)])
+func ConstOne4[T: SomeNumber](): auto {.compiletime.} = Vec4[T]([T(1), T(1), T(1), T(1)])
+func ConstX[T: SomeNumber](): auto {.compiletime.} = Vec3[T]([T(1), T(0), T(0)])
+func ConstY[T: SomeNumber](): auto {.compiletime.} = Vec3[T]([T(0), T(1), T(0)])
+func ConstZ[T: SomeNumber](): auto {.compiletime.} = Vec3[T]([T(0), T(0), T(1)])
+func ConstR[T: SomeNumber](): auto {.compiletime.} = Vec3[T]([T(1), T(0), T(0)])
+func ConstG[T: SomeNumber](): auto {.compiletime.} = Vec3[T]([T(0), T(1), T(0)])
+func ConstB[T: SomeNumber](): auto {.compiletime.} = Vec3[T]([T(0), T(0), T(1)])
+
+# generates constants: Xf, Xf32, Xf64, Xi, Xi8, Xi16, Xi32, Xi64
+# Also for Y, Z, R, G, B and One
+# not sure if this is necessary or even a good idea...
+macro generateAllConsts() =
+  result = newStmtList()
+  for component in ["X", "Y", "Z", "R", "G", "B", "One2", "One3", "One4"]:
+    for theType in ["int", "int8", "int16", "int32", "int64", "float", "float32", "float64"]:
+      var typename = theType[0 .. 0]
+      if theType[^2].isDigit:
+        typename = typename & theType[^2]
+      if theType[^1].isDigit:
+        typename = typename & theType[^1]
+      result.add(
+        newConstStmt(
+          postfix(ident(component & typename), "*"),
+          newCall(nnkBracketExpr.newTree(ident("Const" & component), ident(theType)))
+        )
+      )
+
+generateAllConsts()
+
+const X* = ConstX[float]()
+const Y* = ConstY[float]()
+const Z* = ConstZ[float]()
+const One2* = ConstOne2[float]()
+const One3* = ConstOne3[float]()
+const One4* = ConstOne4[float]()
+
+func newVec2*[T](x, y: T): auto = Vec2([x, y])
+func newVec3*[T](x, y, z: T): auto = Vec3([x, y, z])
+func newVec4*[T](x, y, z, w: T): auto = Vec4([x, y, z, w])
+
+func to*[T](v: Vec2): auto = Vec2([T(v[0]), T(v[1])])
+func to*[T](v: Vec3): auto = Vec3([T(v[0]), T(v[1]), T(v[2])])
+func to*[T](v: Vec4): auto = Vec4([T(v[0]), T(v[1]), T(v[2]), T(v[3])])
+
+func toString[T](value: T): string =
+  var items: seq[string]
+  for item in value:
+    items.add($item)
+  $T & "(" & join(items, "  ") & ")"
+
+func `$`*(v: Vec2[SomeNumber]): string = toString[Vec2[SomeNumber]](v)
+func `$`*(v: Vec3[SomeNumber]): string = toString[Vec3[SomeNumber]](v)
+func `$`*(v: Vec4[SomeNumber]): string = toString[Vec4[SomeNumber]](v)
+
+func length*(vec: Vec2[SomeFloat]): auto = sqrt(vec[0] * vec[0] + vec[1] * vec[1])
+func length*(vec: Vec2[SomeInteger]): auto = sqrt(float(vec[0] * vec[0] + vec[1] * vec[1]))
+func length*(vec: Vec3[SomeFloat]): auto = sqrt(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2])
+func length*(vec: Vec3[SomeInteger]): auto = sqrt(float(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]))
+func length*(vec: Vec4[SomeFloat]): auto = sqrt(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2] + vec[3] * vec[3])
+func length*(vec: Vec4[SomeInteger]): auto = sqrt(float(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2] + vec[3] * vec[3]))
+
+func normalized*[T](vec: Vec2[T]): auto =
+  let l = vec.length
+  when T is SomeFloat:
+    Vec2[T]([vec[0] / l, vec[1] / l])
+  else:
+    Vec2[float]([float(vec[0]) / l, float(vec[1]) / l])
+func normalized*[T](vec: Vec3[T]): auto =
+  let l = vec.length
+  when T is SomeFloat:
+    Vec3[T]([vec[0] / l, vec[1] / l, vec[2] / l])
+  else:
+    Vec3[float]([float(vec[0]) / l, float(vec[1]) / l, float(vec[2]) / l])
+func normalized*[T](vec: Vec4[T]): auto =
+  let l = vec.length
+  when T is SomeFloat:
+    Vec4[T]([vec[0] / l, vec[1] / l, vec[2] / l, vec[3] / l])
+  else:
+    Vec4[float]([float(vec[0]) / l, float(vec[1]) / l, float(vec[2]) / l, float(vec[3]) / l])
+
+# scalar operations
+func `+`*(a: Vec2, b: SomeNumber): auto = Vec2([a[0] + b, a[1] + b])
+func `+`*(a: Vec3, b: SomeNumber): auto = Vec3([a[0] + b, a[1] + b, a[2] + b])
+func `+`*(a: Vec4, b: SomeNumber): auto = Vec4([a[0] + b, a[1] + b, a[2] + b, a[3] + b])
+func `-`*(a: Vec2, b: SomeNumber): auto = Vec2([a[0] - b, a[1] - b])
+func `-`*(a: Vec3, b: SomeNumber): auto = Vec3([a[0] - b, a[1] - b, a[2] - b])
+func `-`*(a: Vec4, b: SomeNumber): auto = Vec4([a[0] - b, a[1] - b, a[2] - b, a[3] - b])
+func `*`*(a: Vec2, b: SomeNumber): auto = Vec2([a[0] * b, a[1] * b])
+func `*`*(a: Vec3, b: SomeNumber): auto = Vec3([a[0] * b, a[1] * b, a[2] * b])
+func `*`*(a: Vec4, b: SomeNumber): auto = Vec4([a[0] * b, a[1] * b, a[2] * b, a[3] * b])
+func `/`*[T: SomeInteger](a: Vec2[T], b: SomeInteger): auto = Vec2([a[0] div b, a[1] div b])
+func `/`*[T: SomeFloat](a: Vec2[T], b: SomeFloat): auto = Vec2([a[0] / b, a[1] / b])
+func `/`*[T: SomeInteger](a: Vec3[T], b: SomeInteger): auto = Vec3([a[0] div b, a[1] div b, a[2] div b])
+func `/`*[T: SomeFloat](a: Vec3[T], b: SomeFloat): auto = Vec3([a[0] / b, a[1] / b, a[2] / b])
+func `/`*[T: SomeInteger](a: Vec4[T], b: SomeInteger): auto = Vec4([a[0] div b, a[1] div b, a[2] div b, a[3] div b])
+func `/`*[T: SomeFloat](a: Vec4[T], b: SomeFloat): auto = Vec4([a[0] / b, a[1] / b, a[2] / b, a[3] / b])
+
+func `+`*(a: SomeNumber, b: Vec2): auto = Vec2([a + b[0], a + b[1]])
+func `+`*(a: SomeNumber, b: Vec3): auto = Vec3([a + b[0], a + b[1], a + b[2]])
+func `+`*(a: SomeNumber, b: Vec4): auto = Vec4([a + b[0], a + b[1], a + b[2], a + b[3]])
+func `-`*(a: SomeNumber, b: Vec2): auto = Vec2([a - b[0], a - b[1]])
+func `-`*(a: SomeNumber, b: Vec3): auto = Vec3([a - b[0], a - b[1], a - b[2]])
+func `-`*(a: SomeNumber, b: Vec4): auto = Vec4([a - b[0], a - b[1], a - b[2], a - b[3]])
+func `*`*(a: SomeNumber, b: Vec2): auto = Vec2([a * b[0], a * b[1]])
+func `*`*(a: SomeNumber, b: Vec3): auto = Vec3([a * b[0], a * b[1], a * b[2]])
+func `*`*(a: SomeNumber, b: Vec4): auto = Vec4([a * b[0], a * b[1], a * b[2], a * b[3]])
+func `/`*[T: SomeInteger](a: SomeInteger, b: Vec2[T]): auto = Vec2([a div b[0], a div b[1]])
+func `/`*[T: SomeFloat](a: SomeFloat, b: Vec2[T]): auto = Vec2([a / b[0], a / b[1]])
+func `/`*[T: SomeInteger](a: SomeInteger, b: Vec3[T]): auto = Vec3([a div b[0], a div b[1], a div b[2]])
+func `/`*[T: SomeFloat](a: SomeFloat, b: Vec3[T]): auto = Vec3([a / b[0], a / b[1], a / b[2]])
+func `/`*[T: SomeInteger](a: SomeInteger, b: Vec4[T]): auto = Vec4([a div b[0], a div b[1], a div b[2], a div b[3]])
+func `/`*[T: SomeFloat](a: SomeFloat, b: Vec4[T]): auto = Vec4([a / b[0], a / b[1], a / b[2], a / b[3]])
+
+# compontent-wise operations
+func `+`*(a, b: Vec2): auto = Vec2([a[0] + b[0], a[1] + b[1]])
+func `+`*(a, b: Vec3): auto = Vec3([a[0] + b[0], a[1] + b[1], a[2] + b[2]])
+func `+`*(a, b: Vec4): auto = Vec4([a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3]])
+func `-`*(a: Vec2): auto = Vec2([-a[0], -a[1]])
+func `-`*(a: Vec3): auto = Vec3([-a[0], -a[1], -a[2]])
+func `-`*(a: Vec4): auto = Vec4([-a[0], -a[1], -a[2], -a[3]])
+func `-`*(a, b: Vec2): auto = Vec2([a[0] - b[0], a[1] - b[1]])
+func `-`*(a, b: Vec3): auto = Vec3([a[0] - b[0], a[1] - b[1], a[2] - b[2]])
+func `-`*(a, b: Vec4): auto = Vec4([a[0] - b[0], a[1] - b[1], a[2] - b[2], a[3] - b[3]])
+func `*`*(a, b: Vec2): auto = Vec2([a[0] * b[0], a[1] * b[1]])
+func `*`*(a, b: Vec3): auto = Vec3([a[0] * b[0], a[1] * b[1], a[2] * b[2]])
+func `*`*(a, b: Vec4): auto = Vec4([a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3]])
+func `/`*[T: SomeInteger](a, b: Vec2[T]): auto = Vec2([a[0] div b[0], a[1] div b[1]])
+func `/`*[T: SomeFloat](a, b: Vec2[T]): auto = Vec2([a[0] / b[0], a[1] / b[1]])
+func `/`*[T: SomeInteger](a, b: Vec3[T]): auto = Vec3([a[0] div b[0], a[1] div b[1], a[2] div b[2]])
+func `/`*[T: SomeFloat](a, b: Vec3[T]): auto = Vec3([a[0] / b[0], a[1] / b[1], a[2] / b[2]])
+func `/`*[T: SomeInteger](a, b: Vec4[T]): auto = Vec4([a[0] div b[0], a[1] div b[1], a[2] div b[2], a[3] div b[3]])
+func `/`*[T: SomeFloat](a, b: Vec4[T]): auto = Vec4([a[0] / b[0], a[1] / b[1], a[2] / b[2], a[3] / b[3]])
+
+# special operations
+func dot*(a, b: Vec2): auto = a[0] * b[0] + a[1] * b[1]
+func dot*(a, b: Vec3): auto = a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+func dot*(a, b: Vec4): auto = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]
+func cross*(a, b: Vec3): auto = Vec3([
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0],
+])
+
+
+# macro to allow creation of new vectors by specifying vector components as attributes
+# e.g. myVec.xxy will return a new Vec3 that contains the components x, x an y of the original vector
+# (instead of x, y, z for a simple copy)
+proc vectorAttributeAccessor(accessor: string): NimNode =
+  const ACCESSOR_INDICES = {
+    'x': 0,
+    'y': 1,
+    'z': 2,
+    'w': 3,
+    'r': 0,
+    'g': 1,
+    'b': 2,
+    'a': 3,
+  }.toTable
+  var ret: NimNode
+  let accessorvalue = accessor
+
+  if accessorvalue.len == 0:
+    raise newException(Exception, "empty attribute")
+  elif accessorvalue.len == 1:
+    ret = nnkBracket.newTree(ident("value"), newLit(ACCESSOR_INDICES[accessorvalue[0]]))
+  if accessorvalue.len > 1:
+    var attrs = nnkBracket.newTree()
+    for attrname in accessorvalue:
+      attrs.add(nnkBracketExpr.newTree(ident("value"), newLit(ACCESSOR_INDICES[attrname])))
+    ret = nnkCall.newTree(ident("Vec" & $accessorvalue.len), attrs)
+
+  newProc(
+    name=nnkPostfix.newTree(ident("*"), ident(accessor)),
+    params=[ident("auto"), nnkIdentDefs.newTree(ident("value"), ident("Vec"), newEmptyNode())],
+    body=newStmtList(ret),
+    procType = nnkFuncDef,
+  )
+
+macro createVectorAttribAccessorFuncs() =
+  const COORD_ATTRS = ["x", "y", "z", "w"]
+  const COLOR_ATTRS = ["r", "g", "b", "a"]
+  result = nnkStmtList.newTree()
+  for attlist in [COORD_ATTRS, COLOR_ATTRS]:
+    for i in attlist:
+      result.add(vectorAttributeAccessor(i))
+      for j in attlist:
+        result.add(vectorAttributeAccessor(i & j))
+        for k in attlist:
+          result.add(vectorAttributeAccessor(i & j & k))
+          for l in attlist:
+            result.add(vectorAttributeAccessor(i & j & k & l))
+
+createVectorAttribAccessorFuncs()
+
+# call e.g. Vec2[int]().randomized() to get a random matrix
+template makeRandomInit(mattype: typedesc) =
+    proc randomized*[T: SomeInteger](m: mattype[T]): mattype[T] =
+      for i in 0 ..< result.len:
+        result[i] = rand(low(typeof(m[0])) .. high(typeof(m[0])))
+    proc randomized*[T: SomeFloat](m: mattype[T]): mattype[T] =
+      for i in 0 ..< result.len:
+        result[i] = rand(1.0)
+
+makeRandomInit(Vec2)
+makeRandomInit(Vec3)
+makeRandomInit(Vec4)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/mesh.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,111 @@
+import std/typetraits
+
+import ./vulkan
+import ./thing
+import ./buffer
+import ./vertex
+import ./math/vector
+
+type
+  Mesh*[T] = object of Part
+    vertexData*: T
+  IndexedMesh*[T: object, U: uint16|uint32] = object of Part
+    vertexData*: T
+    indices*: seq[array[3, U]]
+
+func createUberMesh*[T](meshes: openArray[Mesh[T]]): Mesh[T] =
+  for mesh in meshes:
+    for srcname, srcvalue in mesh.vertexData.fieldPairs:
+      when typeof(srcvalue) is VertexAttribute:
+        for dstname, dstvalue in result.vertexData.fieldPairs:
+          when srcname == dstname:
+            dstvalue.data.add srcvalue.data
+
+func createUberMesh*[T: object, U: uint16|uint32](meshes: openArray[IndexedMesh[T, U]]): IndexedMesh[T, U] =
+  var indexoffset = U(0)
+  for mesh in meshes:
+    for srcname, srcvalue in mesh.vertexData.fieldPairs:
+      when typeof(srcvalue) is VertexAttribute:
+        for dstname, dstvalue in result.vertexData.fieldPairs:
+          when srcname == dstname:
+            dstvalue.data.add srcvalue.data
+      var indexdata: seq[array[3, U]]
+      for i in mesh.indices:
+        indexdata.add [i[0] + indexoffset, i[1] + indexoffset, i[2] + indexoffset]
+      result.indices.add indexdata
+    indexoffset += U(mesh.vertexData.VertexCount)
+
+func getVkIndexType[T: object, U: uint16|uint32](m: IndexedMesh[T, U]): VkIndexType =
+  when U is uint16: VK_INDEX_TYPE_UINT16
+  elif U is uint32: VK_INDEX_TYPE_UINT32
+      
+proc createVertexBuffers*[M: Mesh|IndexedMesh](
+  mesh: var M,
+  device: VkDevice,
+  physicalDevice: VkPhysicalDevice,
+  commandPool: VkCommandPool,
+  queue: VkQueue,
+  useDeviceLocalBuffer: bool = true # decides if data is transfered to the fast device-local memory or not
+): (seq[Buffer], uint32) =
+  result[1] = mesh.vertexData.VertexCount
+  for name, value in mesh.vertexData.fieldPairs:
+    when typeof(value) is VertexAttribute:
+      assert value.data.len > 0
+      var flags = if useDeviceLocalBuffer: {TransferSrc} else: {VertexBuffer}
+      var stagingBuffer = device.InitBuffer(physicalDevice, value.datasize, flags, {VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_MEMORY_PROPERTY_HOST_COHERENT_BIT})
+      var d: pointer
+      stagingBuffer.withMapping(d):
+        copyMem(d, addr(value.data[0]), value.datasize)
+
+      if useDeviceLocalBuffer:
+        var finalBuffer = device.InitBuffer(physicalDevice, value.datasize, {TransferDst, VertexBuffer}, {VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT})
+        copyBuffer(commandPool, queue, stagingBuffer, finalBuffer, value.datasize)
+        stagingBuffer.trash()
+        result[0].add(finalBuffer)
+      else:
+        result[0].add(stagingBuffer)
+
+proc createIndexBuffer*(
+  mesh: var IndexedMesh,
+  device: VkDevice,
+  physicalDevice: VkPhysicalDevice,
+  commandPool: VkCommandPool,
+  queue: VkQueue,
+  useDeviceLocalBuffer: bool = true # decides if data is transfered to the fast device-local memory or not
+): Buffer =
+  let bufferSize = uint64(mesh.indices.len * sizeof(get(genericParams(typeof(mesh.indices)), 0)))
+  let flags = if useDeviceLocalBuffer: {TransferSrc} else: {IndexBuffer}
+
+  var stagingBuffer = device.InitBuffer(physicalDevice, bufferSize, flags, {VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_MEMORY_PROPERTY_HOST_COHERENT_BIT})
+  var d: pointer
+  stagingBuffer.withMapping(d):
+    copyMem(d, addr(mesh.indices[0]), bufferSize)
+
+  if useDeviceLocalBuffer:
+    var finalBuffer = device.InitBuffer(physicalDevice, bufferSize, {TransferDst, IndexBuffer}, {VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT})
+    copyBuffer(commandPool, queue, stagingBuffer, finalBuffer, bufferSize)
+    stagingBuffer.trash()
+    return finalBuffer
+  else:
+    return stagingBuffer
+
+proc createIndexedVertexBuffers*(
+  mesh: var IndexedMesh,
+  device: VkDevice,
+  physicalDevice: VkPhysicalDevice,
+  commandPool: VkCommandPool,
+  queue: VkQueue,
+  useDeviceLocalBuffer: bool = true # decides if data is transfered to the fast device-local memory or not
+): (seq[Buffer], Buffer, uint32, VkIndexType) =
+  result[0] = createVertexBuffers(mesh, device, physicalDevice, commandPool, queue, useDeviceLocalBuffer)[0]
+  result[1] = createIndexBuffer(mesh, device, physicalDevice, commandPool, queue, useDeviceLocalBuffer)
+  result[2] = uint32(mesh.indices.len * mesh.indices[0].len)
+
+  result[3] = getVkIndexType(mesh)
+
+func squareData*[T:SomeFloat](): auto = PositionAttribute[Vec2[T]](
+  data: @[Vec2[T]([T(0), T(0)]), Vec2[T]([T(0), T(1)]), Vec2[T]([T(1), T(1)]), Vec2[T]([T(1), T(0)])]
+)
+func squareIndices*[T:uint16|uint32](): auto = seq[array[3, T]](
+  @[[T(0), T(1), T(3)], [T(2), T(1), T(3)]]
+)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/platform/linux/symkey_map.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,27 @@
+import std/tables
+export tables
+
+import x11/x
+
+
+import ../../events
+
+# got values (keycodes) from xev
+const KeyTypeMap* = {
+  9: Escape, 67: F1, 68: F2, 69: F3, 70: F4, 71: F5, 72: F6, 73: F7, 74: F8, 75: F9, 76: F10, 95: F11, 96: F12,
+  49: NumberRowExtra1, 10: `1`, 11: `2`, 12: `3`, 13: `4`, 14: `5`, 15: `6`, 16: `7`, 17: `8`, 18: `9`, 19: `0`, 20: NumberRowExtra2, 21: NumberRowExtra3,
+  24: Q, 25: W, 26: E, 27: R, 28: T, 29: Y, 30: U, 31: I, 32: O, 33: P, 38: A, 39: S, 40: D, 41: Key.F, 42: G, 43: H, 44: J, 45: K, 46: L, 52: Z, 53: X, 54: C, 55: V, 56: B, 57: N, 58: M,
+
+  23: Tab, 66: CapsLock, 50: ShiftL, 62: ShiftR, 37: CtrlL, 105: CtrlR, 133: SuperL, #[ SuperR, ]# 64: AltL, #[ AltR, ]# 65: Space, 36: Enter, 22: Backspace,
+    34: LetterRow1Extra1, 35: LetterRow1Extra2, 51: LetterRow1Extra3,
+    47: LetterRow2Extra1, 48: LetterRow2Extra2,
+    59: LetterRow3Extra1, 60: LetterRow3Extra2, 61: LetterRow3Extra3,
+    111: Up, 116: Down, 113: Left, 114: Right,
+    112: PageUp, 117: PageDown, 110: Home, 115: End, 118: Insert, 119: Delete,
+}.toTable
+
+const MouseButtonTypeMap* = {
+  Button1: MouseButton.Mouse1,
+  Button2: MouseButton.Mouse2,
+  Button3: MouseButton.Mouse3,
+}.toTable

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/platform/linux/vulkan.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,13 @@
+# included in vulkan_helpers
+const REQUIRED_PLATFORM_EXTENSIONS = @["VK_KHR_xlib_surface".cstring]
+
+proc load_platform_extensions() =
+  loadVK_KHR_xlib_surface()
+
+proc createVulkanSurface*(instance: VkInstance, window: NativeWindow): VkSurfaceKHR =
+  var surfaceCreateInfo = VkXlibSurfaceCreateInfoKHR(
+    sType: VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
+    dpy: window.display,
+    window: window.window,
+  )
+  checkVkResult vkCreateXlibSurfaceKHR(instance, addr(surfaceCreateInfo), nil, addr(result))

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/platform/linux/xlib.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,94 @@
+import
+  x11/xlib,
+  x11/xutil,
+  x11/keysym,
+  x11/xinput,
+  x11/xinput2
+import x11/x
+
+import ../../events
+
+import ./symkey_map
+
+export keysym
+
+var deleteMessage*: Atom
+
+type
+  NativeWindow* = object
+    display*: PDisplay
+    window*: Window
+    emptyCursor: Cursor
+
+template checkXlibResult*(call: untyped) =
+  let value = call
+  if value == 0:
+    raise newException(Exception, "Xlib error: " & astToStr(call) & " returned " & $value)
+
+proc createWindow*(title: string): NativeWindow =
+  checkXlibResult XInitThreads()
+  let display = XOpenDisplay(nil)
+  if display == nil:
+    quit "Failed to open display"
+
+  let
+    screen = XDefaultScreen(display)
+    rootWindow = XRootWindow(display, screen)
+    foregroundColor = XBlackPixel(display, screen)
+    backgroundColor = XWhitePixel(display, screen)
+
+  let window = XCreateSimpleWindow(display, rootWindow, -1, -1, 800, 600, 0, foregroundColor, backgroundColor)
+  checkXlibResult XSetStandardProperties(display, window, title, "window", 0, nil, 0, nil)
+  checkXlibResult XSelectInput(display, window, PointerMotionMask or ButtonPressMask or ButtonReleaseMask or KeyPressMask or KeyReleaseMask or ExposureMask)
+  checkXlibResult XMapWindow(display, window)
+
+  deleteMessage = XInternAtom(display, "WM_DELETE_WINDOW", XBool(false))
+  checkXlibResult XSetWMProtocols(display, window, addr(deleteMessage), 1)
+
+  # quite a lot of work to hide the cursor...
+  var data = "\0".cstring
+  var pixmap = XCreateBitmapFromData(display, window, data, 1, 1)
+  var color: XColor
+  var empty_cursor = XCreatePixmapCursor(display, pixmap, pixmap, addr(color), addr(color), 0, 0)
+  checkXlibResult XFreePixmap(display, pixmap)
+  checkXlibResult XDefineCursor(display, window, empty_cursor)
+
+  return NativeWindow(display: display, window: window, emptyCursor: empty_cursor)
+
+proc trash*(window: NativeWindow) =
+  checkXlibResult window.display.XFreeCursor(window.emptyCursor)
+  checkXlibResult window.display.XDestroyWindow(window.window)
+  discard window.display.XCloseDisplay() # always returns 0
+
+proc size*(window: NativeWindow): (int, int) =
+  var attribs: XWindowAttributes
+  checkXlibResult XGetWindowAttributes(window.display, window.window, addr(attribs))
+  return (int(attribs.width), int(attribs.height))
+
+proc pendingEvents*(window: NativeWindow): seq[Event] =
+  var event: XEvent
+  while window.display.XPending() > 0:
+    discard window.display.XNextEvent(addr(event))
+    case event.theType
+    of ClientMessage:
+      if cast[Atom](event.xclient.data.l[0]) == deleteMessage:
+        result.add(Event(eventType: Quit))
+    of KeyPress:
+      let xkey = int(cast[PXKeyEvent](addr(event)).keycode)
+      result.add Event(eventType: KeyPressed, key: KeyTypeMap.getOrDefault(xkey, Key.UNKNOWN))
+    of KeyRelease:
+      let xkey = int(cast[PXKeyEvent](addr(event)).keycode)
+      result.add Event(eventType: KeyReleased, key: KeyTypeMap.getOrDefault(xkey, Key.UNKNOWN))
+    of ButtonPress:
+      let button = int(cast[PXButtonEvent](addr(event)).button)
+      result.add Event(eventType: MousePressed, button: MouseButtonTypeMap.getOrDefault(button, MouseButton.UNKNOWN))
+    of ButtonRelease:
+      let button = int(cast[PXButtonEvent](addr(event)).button)
+      result.add Event(eventType: MouseReleased, button: MouseButtonTypeMap.getOrDefault(button, MouseButton.UNKNOWN))
+    of MotionNotify:
+      let motion = cast[PXMotionEvent](addr(event))
+      result.add Event(eventType: MouseMoved, x: motion.x, y: motion.y)
+    of ConfigureNotify:
+      result.add Event(eventType: ResizedWindow)
+    else:
+      discard

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/platform/windows/virtualkey_map.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,18 @@
+import std/tables
+export tables
+
+import winim/core
+
+import ../../events
+
+const KeyTypeMap* = {
+  VK_ESCAPE: Key.Escape, VK_F1: F1, VK_F2: F2, VK_F3: F3, VK_F4: F4, VK_F5: F5, VK_F6: F6, VK_F7: F7, VK_F8: F8, VK_F9: F9, VK_F10: F10, VK_F11: F11, VK_F12: F12,
+  VK_OEM_3: NumberRowExtra1, int('0'): `0`, int('1'): `1`, int('2'): `2`, int('3'): `3`, int('4'): `4`, int('5'): `5`, int('6'): `6`, int('7'): `7`, int('8'): `8`, int('9'): `9`, VK_OEM_MINUS: NumberRowExtra2, VK_OEM_PLUS: NumberRowExtra3,
+  int('A'): A, int('B'): B, int('C'): C, int('D'): D, int('E'): E, int('F'): F, int('G'): G, int('H'): H, int('I'): I, int('J'): J, int('K'): K, int('L'): L, int('M'): M, int('N'): N, int('O'): O, int('P'): P, int('Q'): Q, int('R'): R, int('S'): S, int('T'): T, int('U'): U, int('V'): V, int('W'): W, int('X'): X, int('Y'): Y, int('Z'): Z,
+  VK_TAB: Tab, VK_CAPITAL: CapsLock, VK_LSHIFT: ShiftL, VK_SHIFT: ShiftL, VK_RSHIFT: ShiftR, VK_LCONTROL: CtrlL, VK_CONTROL: CtrlL, VK_RCONTROL: CtrlR, VK_LWIN: SuperL, VK_RWIN: SuperR, VK_LMENU: AltL, VK_RMENU: AltR, VK_SPACE: Space, VK_RETURN: Enter, VK_BACK: Backspace,
+  VK_OEM_4: LetterRow1Extra1, VK_OEM_6: LetterRow1Extra2, VK_OEM_5: LetterRow1Extra3,
+  VK_OEM_1: LetterRow2Extra1, VK_OEM_7: LetterRow2Extra2,
+  VK_OEM_COMMA: LetterRow3Extra1, VK_OEM_PERIOD: LetterRow3Extra2, VK_OEM_2: LetterRow3Extra3,
+    VK_UP: Up, VK_DOWN: Down, VK_LEFT: Left, VK_RIGHT: Right,
+    VK_PRIOR: PageUp, VK_NEXT: PageDown, VK_HOME: Home, VK_END: End, VK_INSERT: Insert, VK_DELETE: Key.Delete,
+}.toTable

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/platform/windows/vulkan.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,13 @@
+# included in vulkan_helpers
+const REQUIRED_PLATFORM_EXTENSIONS* = @["VK_KHR_win32_surface".cstring]
+
+proc load_platform_extensions() =
+  loadVK_KHR_win32_surface()
+
+proc createVulkanSurface*(instance: VkInstance, window: NativeWindow): VkSurfaceKHR =
+  var surfaceCreateInfo = VkWin32SurfaceCreateInfoKHR(
+    sType: VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
+    hinstance: window.hinstance,
+    hwnd: window.hwnd,
+  )
+  checkVkResult vkCreateWin32SurfaceKHR(instance, addr(surfaceCreateInfo), nil, addr(result))

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/platform/windows/win32.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,104 @@
+import winim
+
+import ./virtualkey_map
+import ../../events
+
+type
+  NativeWindow* = object
+    hinstance*: HINSTANCE
+    hwnd*: HWND
+
+# sorry, have to use module-global variable to capture windows events
+var currentEvents: seq[Event]
+
+template checkWin32Result*(call: untyped) =
+  let value = call
+  if value != 0:
+    raise newException(Exception, "Win32 error: " & astToStr(call) & " returned " & $value)
+
+
+proc MapLeftRightKeys(key: INT, lparam: LPARAM): INT =
+  case key
+  of VK_SHIFT:
+    MapVirtualKey(UINT((lParam and 0x00ff0000) shr 16), MAPVK_VSC_TO_VK_EX)
+  of VK_CONTROL:
+    if (lParam and 0x01000000) == 0: VK_LCONTROL else: VK_RCONTROL
+  of VK_MENU:
+    if (lParam and 0x01000000) == 0: VK_LMENU else: VK_RMENU
+  else:
+    key
+
+proc WindowHandler(hwnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.stdcall.} =
+  case uMsg
+  of WM_DESTROY:
+    currentEvents.add(Event(eventType: events.EventType.Quit))
+  of WM_KEYDOWN, WM_SYSKEYDOWN:
+    let key = MapLeftRightKeys(INT(wParam), lParam)
+    currentEvents.add(Event(eventType: KeyPressed, key: KeyTypeMap.getOrDefault(key, Key.UNKNOWN)))
+  of WM_KEYUP, WM_SYSKEYUP:
+    let key = MapLeftRightKeys(INT(wParam), lParam)
+    currentEvents.add(Event(eventType: KeyReleased, key: KeyTypeMap.getOrDefault(key, Key.UNKNOWN)))
+  of WM_LBUTTONDOWN:
+    currentEvents.add(Event(eventType: MousePressed, button: MouseButton.Mouse1))
+  of WM_LBUTTONUP:
+    currentEvents.add(Event(eventType: MouseReleased, button: MouseButton.Mouse1))
+  of WM_MBUTTONDOWN:
+    currentEvents.add(Event(eventType: MousePressed, button: MouseButton.Mouse2))
+  of WM_MBUTTONUP:
+    currentEvents.add(Event(eventType: MouseReleased, button: MouseButton.Mouse2))
+  of WM_RBUTTONDOWN:
+    currentEvents.add(Event(eventType: MousePressed, button: MouseButton.Mouse3))
+  of WM_RBUTTONUP:
+    currentEvents.add(Event(eventType: MouseReleased, button: MouseButton.Mouse3))
+  of WM_MOUSEMOVE:
+    currentEvents.add(Event(eventType: events.MouseMoved, x: GET_X_LPARAM(lParam), y: GET_Y_LPARAM(lParam)))
+  else:
+    return DefWindowProc(hwnd, uMsg, wParam, lParam)
+
+
+proc createWindow*(title: string): NativeWindow =
+  result.hInstance = HINSTANCE(GetModuleHandle(nil))
+  var
+    windowClassName = T"EngineWindowClass"
+    windowName = T(title)
+    windowClass = WNDCLASSEX(
+      cbSize: UINT(WNDCLASSEX.sizeof),
+      lpfnWndProc: WindowHandler,
+      hInstance: result.hInstance,
+      lpszClassName: windowClassName,
+    )
+  
+  if(RegisterClassEx(addr(windowClass)) == 0):
+    raise newException(Exception, "Unable to register window class")
+
+  result.hwnd = CreateWindowEx(
+      DWORD(0),
+      windowClassName,
+      windowName,
+      DWORD(WS_OVERLAPPEDWINDOW),
+      CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+      HMENU(0),
+      HINSTANCE(0),
+      result.hInstance,
+      nil
+    )
+
+  discard ShowWindow(result.hwnd, SW_SHOW)
+  discard ShowCursor(false)
+
+proc trash*(window: NativeWindow) =
+  discard
+
+proc size*(window: NativeWindow): (int, int) =
+  var rect: RECT
+  checkWin32Result GetWindowRect(window.hwnd, addr(rect))
+  (int(rect.right - rect.left), int(rect.bottom - rect.top))
+
+proc pendingEvents*(window: NativeWindow): seq[Event] =
+  # empty queue
+  currentEvents = newSeq[Event]()
+  var msg: MSG
+  # fill queue
+  while PeekMessage(addr(msg), window.hwnd, 0, 0, PM_REMOVE):
+    DispatchMessage(addr(msg))
+  return currentEvents

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/shader.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,144 @@
+import std/os
+import std/hashes
+import std/strformat
+import std/strutils
+import std/tables
+import std/compilesettings
+
+import ./vulkan_helpers
+import ./glsl_helpers
+import ./vulkan
+import ./vertex
+import ./descriptor
+import ./math/vector
+
+type
+  AllowedUniformType = SomeNumber|Vec
+  UniformSlot *[T:AllowedUniformType] = object
+  ShaderProgram*[VertexType, Uniforms] = object
+    entryPoint*: string
+    programType*: VkShaderStageFlagBits
+    shader*: VkPipelineShaderStageCreateInfo
+    uniforms*: Uniforms
+
+func stage2string(stage: VkShaderStageFlagBits): string {.compileTime.} =
+  case stage
+  of VK_SHADER_STAGE_VERTEX_BIT: "vert"
+  of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: "tesc"
+  of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: "tese"
+  of VK_SHADER_STAGE_GEOMETRY_BIT: "geom"
+  of VK_SHADER_STAGE_FRAGMENT_BIT: "frag"
+  of VK_SHADER_STAGE_ALL_GRAPHICS: ""
+  of VK_SHADER_STAGE_COMPUTE_BIT: "comp"
+  of VK_SHADER_STAGE_ALL: ""
+
+proc compileGLSLToSPIRV(stage: static VkShaderStageFlagBits, shaderSource: static string, entrypoint: string): seq[uint32] {.compileTime.} =
+  const
+    stagename = stage2string(stage)
+    shaderHash = hash(shaderSource)
+    # cross compilation for windows workaround, sorry computer
+    shaderout = getTempDir().replace("\\", "/") & "/" & fmt"shader_{shaderHash}.{stagename}"
+    projectPath = querySetting(projectPath)
+
+  let (output, exitCode_glsl) = gorgeEx(command=fmt"{projectPath}/glslangValidator --entry-point {entrypoint} -V --stdin -S {stagename} -o {shaderout}", input=shaderSource)
+  if exitCode_glsl != 0:
+    raise newException(Exception, output)
+  if output == "": # this happens when the nim was invoked with "check" instead of "compile/c", as it prevents the gorgeEx command to really run. However, there is hope, see https://github.com/nim-lang/RFCs/issues/430
+    return result
+  let shaderbinary = staticRead shaderout
+
+  let (output_rm, exitCode_rm) = gorgeEx(command=fmt"rm {shaderout}")
+  if exitCode_rm != 0:
+    raise newException(Exception, output_rm)
+
+  var i = 0
+  while i < shaderbinary.len:
+    result.add(
+      (uint32(shaderbinary[i + 0]) shl  0) or
+      (uint32(shaderbinary[i + 1]) shl  8) or
+      (uint32(shaderbinary[i + 2]) shl 16) or
+      (uint32(shaderbinary[i + 3]) shl 24)
+    )
+    i += 4
+
+proc initShaderProgram*[VertexType, Uniforms](device: VkDevice, programType: static VkShaderStageFlagBits, shader: static string, entryPoint: static string="main"): ShaderProgram[VertexType, Uniforms] =
+  result.entryPoint = entryPoint
+  result.programType = programType
+
+  const constcode = compileGLSLToSPIRV(programType, shader, entryPoint)
+  var code = constcode
+  var createInfo = VkShaderModuleCreateInfo(
+    sType: VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
+    codeSize: uint(code.len * sizeof(uint32)),
+    pCode: if code.len > 0: addr(code[0]) else: nil,
+  )
+  var shaderModule: VkShaderModule
+  checkVkResult vkCreateShaderModule(device, addr(createInfo), nil, addr(shaderModule))
+
+  result.shader = VkPipelineShaderStageCreateInfo(
+    sType: VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+    stage: programType,
+    module: shaderModule,
+    pName: cstring(result.entryPoint), # entry point for shader
+  )
+
+func generateVertexShaderCode*[VertexType, Uniforms](
+  shaderBody: static string = "",
+  entryPoint: static string = "main",
+  glslVersion: static string = "450"
+): string {.compileTime.} =
+  var lines: seq[string]
+  lines.add "#version " & glslVersion
+  lines.add "layout(row_major) uniform;"
+  lines.add generateGLSLUniformDeclarations[Uniforms]()
+  lines.add generateGLSLVertexDeclarations[VertexType]()
+  lines.add "layout(location = 0) out vec3 fragColor;"
+  lines.add "void " & entryPoint & "() {"
+
+  var hasPosition = 0
+  var hasColor = 0
+  for name, value in VertexType().fieldPairs:
+    when typeof(value) is PositionAttribute:
+      let glsltype = getGLSLType[getAttributeType(value)]()
+      lines.add &"    {glsltype} in_position = " & name & ";"
+      if getAttributeType(value) is Vec2:
+        lines.add "    vec4 out_position = vec4(in_position, 0.0, 1.0);"
+      elif getAttributeType(value) is Vec3:
+        lines.add "    vec4 out_position = vec4(in_position, 1.0);"
+      elif getAttributeType(value) is Vec4:
+        lines.add "    vec4 out_position = in_position;"
+      hasPosition += 1
+    when typeof(value) is ColorAttribute:
+      let glsltype = getGLSLType[getAttributeType(value)]()
+      lines.add &"    {glsltype} in_color = " & name & ";"
+      lines.add &"    {glsltype} out_color = in_color;";
+      hasColor += 1
+
+  lines.add shaderBody
+  lines.add "    gl_Position = out_position;"
+  lines.add "    fragColor = out_color;"
+  lines.add "}"
+  if hasPosition != 1:
+    raise newException(Exception, fmt"VertexType needs to have exactly one attribute of type PositionAttribute (has {hasPosition})")
+  if hasColor != 1:
+    raise newException(Exception, fmt"VertexType needs to have exactly one attribute of type ColorAttribute (has {hasColor})")
+  return lines.join("\n")
+
+func generateFragmentShaderCode*[VertexType](
+  shaderBody: static string = "",
+  entryPoint: static string = "main",
+  glslVersion: static string = "450"
+): string {.compileTime.} =
+  var lines: seq[string]
+  lines.add "#version " & glslVersion
+  lines.add "layout(row_major) uniform;"
+  lines.add "layout(location = 0) in vec3 fragColor;"
+  lines.add "layout(location = 0) out vec4 outColor;"
+  lines.add "void " & entryPoint & "() {"
+  lines.add "    vec3 in_color = fragColor;"
+  lines.add "    vec3 out_color = in_color;"
+  lines.add shaderBody
+  lines.add "    outColor = vec4(out_color, 1.0);"
+  lines.add "}"
+
+  return lines.join("\n")

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/thing.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,30 @@
+{.experimental: "codeReordering".}
+
+type
+  Part* = object of RootObj
+    thing: ref Thing
+
+  Thing* = object of RootObj
+    parent*: ref Thing
+    children*: seq[ref Thing]
+    parts*: seq[ref Part]
+
+method update*(thing: ref Thing, dt: float32) {.base.} = discard
+
+iterator partsOfType*[T: ref Part](root: ref Thing): T =
+  var queue = @[root]
+  while queue.len > 0:
+    let thing = queue.pop
+    for part in thing.parts:
+      if part of T:
+        yield T(part)
+    for child in thing.children:
+      queue.insert(child, 0)
+
+iterator allEntities*(root: ref Thing): ref Thing =
+  var queue = @[root]
+  while queue.len > 0:
+    let next = queue.pop
+    for child in next.children:
+      queue.add child
+    yield next

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/vertex.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,144 @@
+import std/macros
+import std/strutils
+import std/strformat
+import std/typetraits
+
+import ./math/vector
+import ./math/matrix
+import ./vulkan
+import ./glsl_helpers
+
+type
+  VertexAttributeType = SomeNumber|Vec
+  AttributePurpose* = enum
+    Unknown, Position Color
+  GenericAttribute*[T:VertexAttributeType] = object
+    data*: seq[T]
+  PositionAttribute*[T:Vec] = object
+    data*: seq[T]
+  ColorAttribute*[T:Vec] = object
+    data*: seq[T]
+  InstanceAttribute*[T:Vec] = object
+    data*: seq[T]
+  VertexAttribute* = GenericAttribute|PositionAttribute|ColorAttribute|InstanceAttribute
+
+template getAttributeType*(v: VertexAttribute): auto = get(genericParams(typeof(v)), 0)
+
+func datasize*(attribute: VertexAttribute): uint64 =
+  uint64(sizeof(getAttributeType(attribute))) * uint64(attribute.data.len)
+
+# from https://registry.khronos.org/vulkan/specs/1.3-extensions/html/chap15.html
+func nLocationSlots[T: VertexAttributeType](): int =
+  when (T is Mat44[float64]):
+    8
+  elif (T is Mat44[float32]):
+    4
+  elif (T is Vec3[float64] or T is Vec3[uint64] or T is Vec4[float64] or T is Vec4[float64]):
+    2
+  else:
+    1
+
+# numbers
+func getVkFormat[T: VertexAttributeType](): VkFormat =
+  when T is uint8:         VK_FORMAT_R8_UINT
+  elif T is int8:          VK_FORMAT_R8_SINT
+  elif T is uint16:        VK_FORMAT_R16_UINT
+  elif T is int16:         VK_FORMAT_R16_SINT
+  elif T is uint32:        VK_FORMAT_R32_UINT
+  elif T is int32:         VK_FORMAT_R32_SINT
+  elif T is uint64:        VK_FORMAT_R64_UINT
+  elif T is int64:         VK_FORMAT_R64_SINT
+  elif T is float32:       VK_FORMAT_R32_SFLOAT
+  elif T is float64:       VK_FORMAT_R64_SFLOAT
+  elif T is Vec2[uint8]:   VK_FORMAT_R8G8_UINT
+  elif T is Vec2[int8]:    VK_FORMAT_R8G8_SINT
+  elif T is Vec2[uint16]:  VK_FORMAT_R16G16_UINT
+  elif T is Vec2[int16]:   VK_FORMAT_R16G16_SINT
+  elif T is Vec2[uint32]:  VK_FORMAT_R32G32_UINT
+  elif T is Vec2[int32]:   VK_FORMAT_R32G32_SINT
+  elif T is Vec2[uint64]:  VK_FORMAT_R64G64_UINT
+  elif T is Vec2[int64]:   VK_FORMAT_R64G64_SINT
+  elif T is Vec2[float32]: VK_FORMAT_R32G32_SFLOAT
+  elif T is Vec2[float64]: VK_FORMAT_R64G64_SFLOAT
+  elif T is Vec3[uint8]:   VK_FORMAT_R8G8B8_UINT
+  elif T is Vec3[int8]:    VK_FORMAT_R8G8B8_SINT
+  elif T is Vec3[uint16]:  VK_FORMAT_R16G16B16_UINT
+  elif T is Vec3[int16]:   VK_FORMAT_R16G16B16_SINT
+  elif T is Vec3[uint32]:  VK_FORMAT_R32G32B32_UINT
+  elif T is Vec3[int32]:   VK_FORMAT_R32G32B32_SINT
+  elif T is Vec3[uint64]:  VK_FORMAT_R64G64B64_UINT
+  elif T is Vec3[int64]:   VK_FORMAT_R64G64B64_SINT
+  elif T is Vec3[float32]: VK_FORMAT_R32G32B32_SFLOAT
+  elif T is Vec3[float64]: VK_FORMAT_R64G64B64_SFLOAT
+  elif T is Vec4[uint8]:   VK_FORMAT_R8G8B8A8_UINT
+  elif T is Vec4[int8]:    VK_FORMAT_R8G8B8A8_SINT
+  elif T is Vec4[uint16]:  VK_FORMAT_R16G16B16A16_UINT
+  elif T is Vec4[int16]:   VK_FORMAT_R16G16B16A16_SINT
+  elif T is Vec4[uint32]:  VK_FORMAT_R32G32B32A32_UINT
+  elif T is Vec4[int32]:   VK_FORMAT_R32G32B32A32_SINT
+  elif T is Vec4[uint64]:  VK_FORMAT_R64G64B64A64_UINT
+  elif T is Vec4[int64]:   VK_FORMAT_R64G64B64A64_SINT
+  elif T is Vec4[float32]: VK_FORMAT_R32G32B32A32_SFLOAT
+  elif T is Vec4[float64]: VK_FORMAT_R64G64B64A64_SFLOAT
+
+
+
+func VertexCount*[T](t: T): uint32 =
+  for name, value in t.fieldPairs:
+    when typeof(value) is VertexAttribute and not (typeof(value) is InstanceAttribute):
+      if result == 0:
+        result = uint32(value.data.len)
+      else:
+        assert result == uint32(value.data.len)
+
+func generateGLSLVertexDeclarations*[T](): string =
+  var stmtList: seq[string]
+  var i = 0
+  for name, value in T().fieldPairs:
+    when typeof(value) is VertexAttribute:
+      let glsltype = getGLSLType[getAttributeType(value)]()
+      let n = name
+      stmtList.add(&"layout(location = {i}) in {glsltype} {n};")
+      i += nLocationSlots[getAttributeType(value)]()
+
+  return stmtList.join("\n")
+
+func generateInputVertexBinding*[T](bindingoffset: int = 0, locationoffset: int = 0): seq[VkVertexInputBindingDescription] =
+  # packed attribute data, not interleaved (aks "struct of arrays")
+  var binding = bindingoffset
+  for name, value in T().fieldPairs:
+    when typeof(value) is InstanceAttribute:
+      result.add(
+        VkVertexInputBindingDescription(
+          binding: uint32(binding),
+          stride: uint32(sizeof(getAttributeType(value))),
+          inputRate: VK_VERTEX_INPUT_RATE_INSTANCE,
+        )
+      )
+      binding += 1
+    elif typeof(value) is VertexAttribute:
+      result.add(
+        VkVertexInputBindingDescription(
+          binding: uint32(binding),
+          stride: uint32(sizeof(getAttributeType(value))),
+          inputRate: VK_VERTEX_INPUT_RATE_VERTEX,
+        )
+      )
+      binding += 1
+
+func generateInputAttributeBinding*[T](bindingoffset: int = 0, locationoffset: int = 0): seq[VkVertexInputAttributeDescription] =
+  # packed attribute data, not interleaved (aks "struct of arrays")
+  var location = 0
+  var binding = bindingoffset
+  for name, value in T().fieldPairs:
+    when typeof(value) is VertexAttribute:
+      result.add(
+        VkVertexInputAttributeDescription(
+          binding: uint32(binding),
+          location: uint32(location),
+          format: getVkFormat[getAttributeType(value)](),
+          offset: 0,
+        )
+      )
+      location += nLocationSlots[getAttributeType(value)]()
+      binding += 1

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/semicongine/vulkan.nim	Wed Jan 18 13:52:48 2023 +0700
@@ -0,0 +1,10849 @@
+# Written by Leonardo Mariscal <leo@ldmd.mx>, 2019
+
+## Vulkan Bindings
+## ====
+## WARNING: This is a generated file. Do not edit
+## Any edits will be overwritten by the generator.
+
+when defined(linux):
+  import x11/x
+  import x11/xlib
+  const vkDLL = "libvulkan.so.1"
+else:
+  type
+    Display* = ptr object
+    VisualID* = ptr object
+    Window* = ptr object
+
+when defined(windows):
+  const vkDLL = "vulkan-1.dll"
+  import winim
+else:
+  type
+    HINSTANCE* = ptr object
+    HWND* = ptr object
+    HMONITOR* = ptr object
+    HANDLE* = ptr object
+    SECURITY_ATTRIBUTES* = ptr object
+    DWORD* = ptr object
+    LPCWSTR* = ptr object
+
+var vkGetProc: proc(procName: cstring): pointer {.cdecl.}
+
+import dynlib
+
+let vkHandleDLL = loadLib(vkDLL)
+if isNil(vkHandleDLL):
+  quit("could not load: " & vkDLL)
+
+vkGetProc = proc(procName: cstring): pointer {.cdecl.} =
+  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
+  VkBool32* = distinct uint32
+
+# 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* = VkBool32(1)
+  VK_FALSE* = VkBool32(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: sizeof(cint).} = 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,
+  VkAttachmentLoadOp* {.size: sizeof(cint).} = enum
+    VK_ATTACHMENT_LOAD_OP_LOAD = 0
+    VK_ATTACHMENT_LOAD_OP_CLEAR = 1
+    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2
+  VkAttachmentStoreOp* {.size: sizeof(cint).} = enum
+    VK_ATTACHMENT_STORE_OP_STORE = 0
+    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1
+  VkImageType* {.size: sizeof(cint).} = enum
+    VK_IMAGE_TYPE_1D = 0
+    VK_IMAGE_TYPE_2D = 1
+    VK_IMAGE_TYPE_3D = 2
+  VkImageTiling* {.size: sizeof(cint).} = enum
+    VK_IMAGE_TILING_OPTIMAL = 0
+    VK_IMAGE_TILING_LINEAR = 1
+  VkImageViewType* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0
+    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1
+  VkComponentSwizzle* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_QUERY_TYPE_OCCLUSION = 0
+    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1
+    VK_QUERY_TYPE_TIMESTAMP = 2
+  VkBorderColor* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_PIPELINE_BIND_POINT_GRAPHICS = 0
+    VK_PIPELINE_BIND_POINT_COMPUTE = 1
+  VkPipelineCacheHeaderVersion* {.size: sizeof(cint).} = enum
+    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1
+  VkPrimitiveTopology* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_SHARING_MODE_EXCLUSIVE = 0
+    VK_SHARING_MODE_CONCURRENT = 1
+  VkIndexType* {.size: sizeof(cint).} = enum
+    VK_INDEX_TYPE_UINT16 = 0
+    VK_INDEX_TYPE_UINT32 = 1
+  VkFilter* {.size: sizeof(cint).} = enum
+    VK_FILTER_NEAREST = 0
+    VK_FILTER_LINEAR = 1
+  VkSamplerMipmapMode* {.size: sizeof(cint).} = enum
+    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0
+    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1
+  VkSamplerAddressMode* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_POLYGON_MODE_FILL = 0
+    VK_POLYGON_MODE_LINE = 1
+    VK_POLYGON_MODE_POINT = 2
+  VkCullModeFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0
+    VK_FRONT_FACE_CLOCKWISE = 1
+  VkBlendFactor* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0
+  VkSystemAllocationScope* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_VERTEX_INPUT_RATE_VERTEX = 0
+    VK_VERTEX_INPUT_RATE_INSTANCE = 1
+  VkFormat* {.size: sizeof(cint).} = 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
+  VkStructureType* {.size: sizeof(cint).} = 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 # added by sam
+    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001 # added by sam
+    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000 # added by sam
+    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000 # added by sam
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004 # added by sam
+  VkSubpassContents* {.size: sizeof(cint).} = enum
+    VK_SUBPASS_CONTENTS_INLINE = 0
+    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1
+  VkResult* {.size: sizeof(cint).} = enum
+    VK_ERROR_OUT_OF_DATE_KHR = -1000001004 # added by sam
+    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, # added by sam
+  VkDynamicState* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0
+  VkObjectType* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_QUEUE_GRAPHICS_BIT = 1
+    VK_QUEUE_COMPUTE_BIT = 2
+    VK_QUEUE_TRANSFER_BIT = 4
+    VK_QUEUE_SPARSE_BINDING_BIT = 8
+  VkMemoryPropertyFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1
+  VkAccessFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 1
+    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 2
+    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 4
+    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 8
+    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 16
+    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 32
+    VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 64
+    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 128
+    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 256
+  VkBufferCreateFlagBits* {.size: sizeof(cint).} = enum
+    VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1
+    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2
+    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 4
+  VkShaderStageFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1
+    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2
+    VK_PIPELINE_CREATE_DERIVATIVE_BIT = 4
+  VkColorComponentFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_FENCE_CREATE_SIGNALED_BIT = 1
+  VkFormatFeatureFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_QUERY_CONTROL_PRECISE_BIT = 1
+  VkQueryResultFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1
+  VkPipelineStageFlagBits* {.size: sizeof(cint).} = enum
+    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 1
+    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 2
+    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 4
+    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 8
+    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 16
+    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 32
+    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 64
+    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 128
+    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 256
+    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 512
+    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 1024
+    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 2048
+    VK_PIPELINE_STAGE_TRANSFER_BIT = 4096
+    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 8192
+    VK_PIPELINE_STAGE_HOST_BIT = 16384
+    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 32768
+    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 65536
+  VkCommandPoolCreateFlagBits* {.size: sizeof(cint).} = enum
+    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1
+    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2
+  VkCommandPoolResetFlagBits* {.size: sizeof(cint).} = enum
+    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1
+  VkCommandBufferResetFlagBits* {.size: sizeof(cint).} = enum
+    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1
+  VkSampleCountFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1
+  VkStencilFaceFlagBits* {.size: sizeof(cint).} = enum
+    VK_STENCIL_FACE_FRONT_BIT = 1
+    VK_STENCIL_FACE_BACK_BIT = 2
+    VK_STENCIL_FACE_FRONT_AND_BACK = 3
+  VkDescriptorPoolCreateFlagBits* {.size: sizeof(cint).} = enum
+    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1
+  VkDependencyFlagBits* {.size: sizeof(cint).} = enum
+    VK_DEPENDENCY_BY_REGION_BIT = 1
+  VkSemaphoreType* {.size: sizeof(cint).} = enum
+    VK_SEMAPHORE_TYPE_BINARY = 0
+    VK_SEMAPHORE_TYPE_TIMELINE = 1
+  VkSemaphoreWaitFlagBits* {.size: sizeof(cint).} = enum
+    VK_SEMAPHORE_WAIT_ANY_BIT = 1
+  VkPresentModeKHR* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0
+  VkDisplayPlaneAlphaFlagBitsKHR* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 1
+  VkTimeDomainEXT* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_RASTERIZATION_ORDER_STRICT_AMD = 0
+    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1
+  VkExternalMemoryHandleTypeFlagBitsNV* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_VALIDATION_CHECK_ALL_EXT = 0
+    VK_VALIDATION_CHECK_SHADERS_EXT = 1
+  VkValidationFeatureEnableEXT* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 1
+  VkIndirectCommandsTokenTypeNV* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1
+    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2
+  VkSemaphoreImportFlagBits* {.size: sizeof(cint).} = enum
+    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1
+  VkExternalFenceHandleTypeFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1
+    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2
+  VkFenceImportFlagBits* {.size: sizeof(cint).} = enum
+    VK_FENCE_IMPORT_TEMPORARY_BIT = 1
+  VkSurfaceCounterFlagBitsEXT* {.size: sizeof(cint).} = enum
+    VK_SURFACE_COUNTER_VBLANK_EXT = 1
+  VkDisplayPowerStateEXT* {.size: sizeof(cint).} = enum
+    VK_DISPLAY_POWER_STATE_OFF_EXT = 0
+    VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1
+    VK_DISPLAY_POWER_STATE_ON_EXT = 2
+  VkDeviceEventTypeEXT* {.size: sizeof(cint).} = enum
+    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0
+  VkDisplayEventTypeEXT* {.size: sizeof(cint).} = enum
+    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0
+  VkPeerMemoryFeatureFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1
+  VkDeviceGroupPresentModeFlagBitsKHR* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0
+    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1
+  VkPointClippingBehavior* {.size: sizeof(cint).} = enum
+    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0
+    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1
+  VkSamplerReductionMode* {.size: sizeof(cint).} = enum
+    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0
+    VK_SAMPLER_REDUCTION_MODE_MIN = 1
+    VK_SAMPLER_REDUCTION_MODE_MAX = 2
+  VkTessellationDomainOrigin* {.size: sizeof(cint).} = enum
+    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0
+    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1
+  VkSamplerYcbcrModelConversion* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0
+    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1
+  VkChromaLocation* {.size: sizeof(cint).} = enum
+    VK_CHROMA_LOCATION_COSITED_EVEN = 0
+    VK_CHROMA_LOCATION_MIDPOINT = 1
+  VkBlendOverlapEXT* {.size: sizeof(cint).} = enum
+    VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0
+    VK_BLEND_OVERLAP_DISJOINT_EXT = 1
+    VK_BLEND_OVERLAP_CONJOINT_EXT = 2
+  VkCoverageModulationModeNV* {.size: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0
+    VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1
+  VkValidationCacheHeaderVersionEXT* {.size: sizeof(cint).} = enum
+    VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1
+  VkShaderInfoTypeAMD* {.size: sizeof(cint).} = enum
+    VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0
+    VK_SHADER_INFO_TYPE_BINARY_AMD = 1
+    VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2
+  VkQueueGlobalPriorityEXT* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0
+    VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1
+    VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2
+  VkDescriptorBindingFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 1
+  VkResolveModeFlagBits* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_GEOMETRY_OPAQUE_BIT_KHR = 1
+    VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 2
+  VkBuildAccelerationStructureFlagBitsKHR* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0
+    VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1
+  VkGeometryTypeKHR* {.size: sizeof(cint).} = enum
+    VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0
+    VK_GEOMETRY_TYPE_AABBS_KHR = 1
+  VkAccelerationStructureMemoryRequirementsTypeKHR* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0
+    VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1
+    VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2
+  VkScopeNV* {.size: sizeof(cint).} = enum
+    VK_SCOPE_DEVICE_NV = 1
+    VK_SCOPE_WORKGROUP_NV = 2
+    VK_SCOPE_SUBGROUP_NV = 3
+    VK_SCOPE_QUEUE_FAMILY_NV = 5
+  VkComponentTypeNV* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = enum
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 1
+    VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 2
+  VkPerformanceConfigurationTypeINTEL* {.size: sizeof(cint).} = enum
+    VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0
+  VkQueryPoolSamplingModeINTEL* {.size: sizeof(cint).} = enum
+    VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0
+  VkPerformanceOverrideTypeINTEL* {.size: sizeof(cint).} = enum
+    VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0
+    VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1
+  VkPerformanceParameterTypeINTEL* {.size: sizeof(cint).} = enum
+    VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0
+    VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1
+  VkPerformanceValueTypeINTEL* {.size: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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: sizeof(cint).} = 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
+  RROutput* = ptr object
+  wl_display* = ptr object
+  wl_surface* = 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)
+
+type
+  VkSampleMask* = 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
+    `type`*: 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
+    renderPass*: 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
+    renderPass*: 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
+    renderPass*: 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
+    depthStencil*: 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
+    renderPass*: 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
+    `type`*: 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
+    `type`*: 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
+    `type`*: VkRayTracingShaderGroupTypeKHR
+    generalShader*: uint32
+    closestHitShader*: uint32
+    anyHitShader*: uint32
+    intersectionShader*: uint32
+
+  VkRayTracingShaderGroupCreateInfoKHR* = object
+    sType*: VkStructureType
+    pNext*: pointer
+    `type`*: 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
+    `type`*: 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
+    `type`*: VkAccelerationStructureMemoryRequirementsTypeKHR
+    buildType*: VkAccelerationStructureBuildTypeKHR
+    accelerationStructure*: VkAccelerationStructureKHR
+
+  VkAccelerationStructureMemoryRequirementsInfoNV* = object
+    sType*: VkStructureType
+    pNext*: pointer
+    `type`*: 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
+    `type`*: 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
+    `type`*: VkPerformanceOverrideTypeINTEL
+    enable*: VkBool32
+    parameter*: uint64
+
+  VkPerformanceConfigurationAcquireInfoINTEL* = object
+    sType*: VkStructureType
+    pNext*: pointer
+    `type`*: 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
+    `type`*: 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
+    `type`*: 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, enabledLayerCount: uint32, ppEnabledLayerNames: cstringArray, enabledExtensionCount: uint32, ppEnabledExtensionNames: cstringArray): 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 newVkMappedMemoryRange*(sType: VkStructureType = VkStructureTypeMappedMemoryRange, pNext: pointer = nil, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize): VkMappedMemoryRange =
+  result.sType = sType
+  result.pNext = pNext
+  result.memory = memory
+  result.offset = offset
+  result.size = size
+
+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
+
+proc newVkImageCreateInfo*(sType: VkStructureType = VkStructureTypeImageCreateInfo, pNext: pointer = nil, flags: VkImageCreateFlags = 0.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): VkImageCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.imageType = imageType
+  result.format = format
+  result.extent = extent
+  result.mipLevels = mipLevels
+  result.arrayLayers = arrayLayers
+  result.samples = samples
+  result.tiling = tiling
+  result.usage = usage
+  result.sharingMode = sharingMode
+  result.queueFamilyIndexCount = queueFamilyIndexCount
+  result.pQueueFamilyIndices = pQueueFamilyIndices
+  result.initialLayout = initialLayout
+
+proc newVkSubresourceLayout*(offset: VkDeviceSize, size: VkDeviceSize, rowPitch: VkDeviceSize, arrayPitch: VkDeviceSize, depthPitch: VkDeviceSize): VkSubresourceLayout =
+  result.offset = offset
+  result.size = size
+  result.rowPitch = rowPitch
+  result.arrayPitch = arrayPitch
+  result.depthPitch = depthPitch
+
+proc newVkImageViewCreateInfo*(sType: VkStructureType = VkStructureTypeImageViewCreateInfo, pNext: pointer = nil, flags: VkImageViewCreateFlags = 0.VkImageViewCreateFlags, image: VkImage, viewType: VkImageViewType, format: VkFormat, components: VkComponentMapping, subresourceRange: VkImageSubresourceRange): VkImageViewCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.image = image
+  result.viewType = viewType
+  result.format = format
+  result.components = components
+  result.subresourceRange = subresourceRange
+
+proc newVkBufferCopy*(srcOffset: VkDeviceSize, dstOffset: VkDeviceSize, size: VkDeviceSize): VkBufferCopy =
+  result.srcOffset = srcOffset
+  result.dstOffset = dstOffset
+  result.size = size
+
+proc newVkSparseMemoryBind*(resourceOffset: VkDeviceSize, size: VkDeviceSize, memory: VkDeviceMemory, memoryOffset: VkDeviceSize, flags: VkSparseMemoryBindFlags = 0.VkSparseMemoryBindFlags): VkSparseMemoryBind =
+  result.resourceOffset = resourceOffset
+  result.size = size
+  result.memory = memory
+  result.memoryOffset = memoryOffset
+  result.flags = flags
+
+proc newVkSparseImageMemoryBind*(subresource: VkImageSubresource, offset: VkOffset3D, extent: VkExtent3D, memory: VkDeviceMemory, memoryOffset: VkDeviceSize, flags: VkSparseMemoryBindFlags = 0.VkSparseMemoryBindFlags): VkSparseImageMemoryBind =
+  result.subresource = subresource
+  result.offset = offset
+  result.extent = extent
+  result.memory = memory
+  result.memoryOffset = memoryOffset
+  result.flags = flags
+
+proc newVkSparseBufferMemoryBindInfo*(buffer: VkBuffer, bindCount: uint32, pBinds: ptr VkSparseMemoryBind): VkSparseBufferMemoryBindInfo =
+  result.buffer = buffer
+  result.bindCount = bindCount
+  result.pBinds = pBinds
+
+proc newVkSparseImageOpaqueMemoryBindInfo*(image: VkImage, bindCount: uint32, pBinds: ptr VkSparseMemoryBind): VkSparseImageOpaqueMemoryBindInfo =
+  result.image = image
+  result.bindCount = bindCount
+  result.pBinds = pBinds
+
+proc newVkSparseImageMemoryBindInfo*(image: VkImage, bindCount: uint32, pBinds: ptr VkSparseImageMemoryBind): VkSparseImageMemoryBindInfo =
+  result.image = image
+  result.bindCount = bindCount
+  result.pBinds = pBinds
+
+proc newVkBindSparseInfo*(sType: VkStructureType = VkStructureTypeBindSparseInfo, pNext: pointer = nil, 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): VkBindSparseInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.waitSemaphoreCount = waitSemaphoreCount
+  result.pWaitSemaphores = pWaitSemaphores
+  result.bufferBindCount = bufferBindCount
+  result.pBufferBinds = pBufferBinds
+  result.imageOpaqueBindCount = imageOpaqueBindCount
+  result.pImageOpaqueBinds = pImageOpaqueBinds
+  result.imageBindCount = imageBindCount
+  result.pImageBinds = pImageBinds
+  result.signalSemaphoreCount = signalSemaphoreCount
+  result.pSignalSemaphores = pSignalSemaphores
+
+proc newVkImageCopy*(srcSubresource: VkImageSubresourceLayers, srcOffset: VkOffset3D, dstSubresource: VkImageSubresourceLayers, dstOffset: VkOffset3D, extent: VkExtent3D): VkImageCopy =
+  result.srcSubresource = srcSubresource
+  result.srcOffset = srcOffset
+  result.dstSubresource = dstSubresource
+  result.dstOffset = dstOffset
+  result.extent = extent
+
+proc newVkImageBlit*(srcSubresource: VkImageSubresourceLayers, srcOffsets: array[2, VkOffset3D], dstSubresource: VkImageSubresourceLayers, dstOffsets: array[2, VkOffset3D]): VkImageBlit =
+  result.srcSubresource = srcSubresource
+  result.srcOffsets = srcOffsets
+  result.dstSubresource = dstSubresource
+  result.dstOffsets = dstOffsets
+
+proc newVkBufferImageCopy*(bufferOffset: VkDeviceSize, bufferRowLength: uint32, bufferImageHeight: uint32, imageSubresource: VkImageSubresourceLayers, imageOffset: VkOffset3D, imageExtent: VkExtent3D): VkBufferImageCopy =
+  result.bufferOffset = bufferOffset
+  result.bufferRowLength = bufferRowLength
+  result.bufferImageHeight = bufferImageHeight
+  result.imageSubresource = imageSubresource
+  result.imageOffset = imageOffset
+  result.imageExtent = imageExtent
+
+proc newVkImageResolve*(srcSubresource: VkImageSubresourceLayers, srcOffset: VkOffset3D, dstSubresource: VkImageSubresourceLayers, dstOffset: VkOffset3D, extent: VkExtent3D): VkImageResolve =
+  result.srcSubresource = srcSubresource
+  result.srcOffset = srcOffset
+  result.dstSubresource = dstSubresource
+  result.dstOffset = dstOffset
+  result.extent = extent
+
+proc newVkShaderModuleCreateInfo*(sType: VkStructureType = VkStructureTypeShaderModuleCreateInfo, pNext: pointer = nil, flags: VkShaderModuleCreateFlags = 0.VkShaderModuleCreateFlags, codeSize: uint, pCode: ptr uint32): VkShaderModuleCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.codeSize = codeSize
+  result.pCode = pCode
+
+proc newVkDescriptorSetLayoutBinding*(binding: uint32, descriptorType: VkDescriptorType, descriptorCount: uint32, stageFlags: VkShaderStageFlags, pImmutableSamplers: ptr VkSampler): VkDescriptorSetLayoutBinding =
+  result.binding = binding
+  result.descriptorType = descriptorType
+  result.descriptorCount = descriptorCount
+  result.stageFlags = stageFlags
+  result.pImmutableSamplers = pImmutableSamplers
+
+proc newVkDescriptorSetLayoutCreateInfo*(sType: VkStructureType = VkStructureTypeDescriptorSetLayoutCreateInfo, pNext: pointer = nil, flags: VkDescriptorSetLayoutCreateFlags = 0.VkDescriptorSetLayoutCreateFlags, bindingCount: uint32, pBindings: ptr VkDescriptorSetLayoutBinding): VkDescriptorSetLayoutCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.bindingCount = bindingCount
+  result.pBindings = pBindings
+
+proc newVkDescriptorPoolSize*(`type`: VkDescriptorType, descriptorCount: uint32): VkDescriptorPoolSize =
+  result.`type` = `type`
+  result.descriptorCount = descriptorCount
+
+proc newVkDescriptorPoolCreateInfo*(sType: VkStructureType = VkStructureTypeDescriptorPoolCreateInfo, pNext: pointer = nil, flags: VkDescriptorPoolCreateFlags = 0.VkDescriptorPoolCreateFlags, maxSets: uint32, poolSizeCount: uint32, pPoolSizes: ptr VkDescriptorPoolSize): VkDescriptorPoolCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.maxSets = maxSets
+  result.poolSizeCount = poolSizeCount
+  result.pPoolSizes = pPoolSizes
+
+proc newVkDescriptorSetAllocateInfo*(sType: VkStructureType = VkStructureTypeDescriptorSetAllocateInfo, pNext: pointer = nil, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32, pSetLayouts: ptr VkDescriptorSetLayout): VkDescriptorSetAllocateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.descriptorPool = descriptorPool
+  result.descriptorSetCount = descriptorSetCount
+  result.pSetLayouts = pSetLayouts
+
+proc newVkSpecializationMapEntry*(constantID: uint32, offset: uint32, size: uint): VkSpecializationMapEntry =
+  result.constantID = constantID
+  result.offset = offset
+  result.size = size
+
+proc newVkSpecializationInfo*(mapEntryCount: uint32, pMapEntries: ptr VkSpecializationMapEntry, dataSize: uint, pData: pointer = nil): VkSpecializationInfo =
+  result.mapEntryCount = mapEntryCount
+  result.pMapEntries = pMapEntries
+  result.dataSize = dataSize
+  result.pData = pData
+
+proc newVkPipelineShaderStageCreateInfo*(sType: VkStructureType = VkStructureTypePipelineShaderStageCreateInfo, pNext: pointer = nil, flags: VkPipelineShaderStageCreateFlags = 0.VkPipelineShaderStageCreateFlags, stage: VkShaderStageFlagBits, module: VkShaderModule, pName: cstring, pSpecializationInfo: ptr VkSpecializationInfo): VkPipelineShaderStageCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.stage = stage
+  result.module = module
+  result.pName = pName
+  result.pSpecializationInfo = pSpecializationInfo
+
+proc newVkComputePipelineCreateInfo*(sType: VkStructureType = VkStructureTypeComputePipelineCreateInfo, pNext: pointer = nil, flags: VkPipelineCreateFlags = 0.VkPipelineCreateFlags, stage: VkPipelineShaderStageCreateInfo, layout: VkPipelineLayout, basePipelineHandle: VkPipeline, basePipelineIndex: int32): VkComputePipelineCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.stage = stage
+  result.layout = layout
+  result.basePipelineHandle = basePipelineHandle
+  result.basePipelineIndex = basePipelineIndex
+
+proc newVkVertexInputBindingDescription*(binding: uint32, stride: uint32, inputRate: VkVertexInputRate): VkVertexInputBindingDescription =
+  result.binding = binding
+  result.stride = stride
+  result.inputRate = inputRate
+
+proc newVkVertexInputAttributeDescription*(location: uint32, binding: uint32, format: VkFormat, offset: uint32): VkVertexInputAttributeDescription =
+  result.location = location
+  result.binding = binding
+  result.format = format
+  result.offset = offset
+
+proc newVkPipelineVertexInputStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineVertexInputStateCreateInfo, pNext: pointer = nil, flags: VkPipelineVertexInputStateCreateFlags = 0.VkPipelineVertexInputStateCreateFlags, vertexBindingDescriptionCount: uint32, pVertexBindingDescriptions: ptr VkVertexInputBindingDescription, vertexAttributeDescriptionCount: uint32, pVertexAttributeDescriptions: ptr VkVertexInputAttributeDescription): VkPipelineVertexInputStateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.vertexBindingDescriptionCount = vertexBindingDescriptionCount
+  result.pVertexBindingDescriptions = pVertexBindingDescriptions
+  result.vertexAttributeDescriptionCount = vertexAttributeDescriptionCount
+  result.pVertexAttributeDescriptions = pVertexAttributeDescriptions
+
+proc newVkPipelineInputAssemblyStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineInputAssemblyStateCreateInfo, pNext: pointer = nil, flags: VkPipelineInputAssemblyStateCreateFlags = 0.VkPipelineInputAssemblyStateCreateFlags, topology: VkPrimitiveTopology, primitiveRestartEnable: VkBool32): VkPipelineInputAssemblyStateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.topology = topology
+  result.primitiveRestartEnable = primitiveRestartEnable
+
+proc newVkPipelineTessellationStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineTessellationStateCreateInfo, pNext: pointer = nil, flags: VkPipelineTessellationStateCreateFlags = 0.VkPipelineTessellationStateCreateFlags, patchControlPoints: uint32): VkPipelineTessellationStateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.patchControlPoints = patchControlPoints
+
+proc newVkPipelineViewportStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineViewportStateCreateInfo, pNext: pointer = nil, flags: VkPipelineViewportStateCreateFlags = 0.VkPipelineViewportStateCreateFlags, viewportCount: uint32, pViewports: ptr VkViewport, scissorCount: uint32, pScissors: ptr VkRect2D): VkPipelineViewportStateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.viewportCount = viewportCount
+  result.pViewports = pViewports
+  result.scissorCount = scissorCount
+  result.pScissors = pScissors
+
+proc newVkPipelineRasterizationStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineRasterizationStateCreateInfo, pNext: pointer = nil, flags: VkPipelineRasterizationStateCreateFlags = 0.VkPipelineRasterizationStateCreateFlags, depthClampEnable: VkBool32, rasterizerDiscardEnable: VkBool32, polygonMode: VkPolygonMode, cullMode: VkCullModeFlags, frontFace: VkFrontFace, depthBiasEnable: VkBool32, depthBiasConstantFactor: float32, depthBiasClamp: float32, depthBiasSlopeFactor: float32, lineWidth: float32): VkPipelineRasterizationStateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.depthClampEnable = depthClampEnable
+  result.rasterizerDiscardEnable = rasterizerDiscardEnable
+  result.polygonMode = polygonMode
+  result.cullMode = cullMode
+  result.frontFace = frontFace
+  result.depthBiasEnable = depthBiasEnable
+  result.depthBiasConstantFactor = depthBiasConstantFactor
+  result.depthBiasClamp = depthBiasClamp
+  result.depthBiasSlopeFactor = depthBiasSlopeFactor
+  result.lineWidth = lineWidth
+
+proc newVkPipelineMultisampleStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineMultisampleStateCreateInfo, pNext: pointer = nil, flags: VkPipelineMultisampleStateCreateFlags = 0.VkPipelineMultisampleStateCreateFlags, rasterizationSamples: VkSampleCountFlagBits, sampleShadingEnable: VkBool32, minSampleShading: float32, pSampleMask: ptr VkSampleMask, alphaToCoverageEnable: VkBool32, alphaToOneEnable: VkBool32): VkPipelineMultisampleStateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.rasterizationSamples = rasterizationSamples
+  result.sampleShadingEnable = sampleShadingEnable
+  result.minSampleShading = minSampleShading
+  result.pSampleMask = pSampleMask
+  result.alphaToCoverageEnable = alphaToCoverageEnable
+  result.alphaToOneEnable = alphaToOneEnable
+
+proc newVkPipelineColorBlendAttachmentState*(blendEnable: VkBool32, srcColorBlendFactor: VkBlendFactor, dstColorBlendFactor: VkBlendFactor, colorBlendOp: VkBlendOp, srcAlphaBlendFactor: VkBlendFactor, dstAlphaBlendFactor: VkBlendFactor, alphaBlendOp: VkBlendOp, colorWriteMask: VkColorComponentFlags): VkPipelineColorBlendAttachmentState =
+  result.blendEnable = blendEnable
+  result.srcColorBlendFactor = srcColorBlendFactor
+  result.dstColorBlendFactor = dstColorBlendFactor
+  result.colorBlendOp = colorBlendOp
+  result.srcAlphaBlendFactor = srcAlphaBlendFactor
+  result.dstAlphaBlendFactor = dstAlphaBlendFactor
+  result.alphaBlendOp = alphaBlendOp
+  result.colorWriteMask = colorWriteMask
+
+proc newVkPipelineColorBlendStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineColorBlendStateCreateInfo, pNext: pointer = nil, flags: VkPipelineColorBlendStateCreateFlags = 0.VkPipelineColorBlendStateCreateFlags, logicOpEnable: VkBool32, logicOp: VkLogicOp, attachmentCount: uint32, pAttachments: ptr VkPipelineColorBlendAttachmentState, blendConstants: array[4, float32]): VkPipelineColorBlendStateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.logicOpEnable = logicOpEnable
+  result.logicOp = logicOp
+  result.attachmentCount = attachmentCount
+  result.pAttachments = pAttachments
+  result.blendConstants = blendConstants
+
+proc newVkPipelineDynamicStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineDynamicStateCreateInfo, pNext: pointer = nil, flags: VkPipelineDynamicStateCreateFlags = 0.VkPipelineDynamicStateCreateFlags, dynamicStateCount: uint32, pDynamicStates: ptr VkDynamicState): VkPipelineDynamicStateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.dynamicStateCount = dynamicStateCount
+  result.pDynamicStates = pDynamicStates
+
+proc newVkStencilOpState*(failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp, compareMask: uint32, writeMask: uint32, reference: uint32): VkStencilOpState =
+  result.failOp = failOp
+  result.passOp = passOp
+  result.depthFailOp = depthFailOp
+  result.compareOp = compareOp
+  result.compareMask = compareMask
+  result.writeMask = writeMask
+  result.reference = reference
+
+proc newVkPipelineDepthStencilStateCreateInfo*(sType: VkStructureType = VkStructureTypePipelineDepthStencilStateCreateInfo, pNext: pointer = nil, flags: VkPipelineDepthStencilStateCreateFlags = 0.VkPipelineDepthStencilStateCreateFlags, depthTestEnable: VkBool32, depthWriteEnable: VkBool32, depthCompareOp: VkCompareOp, depthBoundsTestEnable: VkBool32, stencilTestEnable: VkBool32, front: VkStencilOpState, back: VkStencilOpState, minDepthBounds: float32, maxDepthBounds: float32): VkPipelineDepthStencilStateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.depthTestEnable = depthTestEnable
+  result.depthWriteEnable = depthWriteEnable
+  result.depthCompareOp = depthCompareOp
+  result.depthBoundsTestEnable = depthBoundsTestEnable
+  result.stencilTestEnable = stencilTestEnable
+  result.front = front
+  result.back = back
+  result.minDepthBounds = minDepthBounds
+  result.maxDepthBounds = maxDepthBounds
+
+proc newVkGraphicsPipelineCreateInfo*(sType: VkStructureType = VkStructureTypeGraphicsPipelineCreateInfo, pNext: pointer = nil, flags: VkPipelineCreateFlags = 0.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, renderPass: VkRenderPass, subpass: uint32, basePipelineHandle: VkPipeline, basePipelineIndex: int32): VkGraphicsPipelineCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.stageCount = stageCount
+  result.pStages = pStages
+  result.pVertexInputState = pVertexInputState
+  result.pInputAssemblyState = pInputAssemblyState
+  result.pTessellationState = pTessellationState
+  result.pViewportState = pViewportState
+  result.pRasterizationState = pRasterizationState
+  result.pMultisampleState = pMultisampleState
+  result.pDepthStencilState = pDepthStencilState
+  result.pColorBlendState = pColorBlendState
+  result.pDynamicState = pDynamicState
+  result.layout = layout
+  result.renderPass = renderPass
+  result.subpass = subpass
+  result.basePipelineHandle = basePipelineHandle
+  result.basePipelineIndex = basePipelineIndex
+
+proc newVkPipelineCacheCreateInfo*(sType: VkStructureType = VkStructureTypePipelineCacheCreateInfo, pNext: pointer = nil, flags: VkPipelineCacheCreateFlags = 0.VkPipelineCacheCreateFlags, initialDataSize: uint, pInitialData: pointer = nil): VkPipelineCacheCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.initialDataSize = initialDataSize
+  result.pInitialData = pInitialData
+
+proc newVkPushConstantRange*(stageFlags: VkShaderStageFlags, offset: uint32, size: uint32): VkPushConstantRange =
+  result.stageFlags = stageFlags
+  result.offset = offset
+  result.size = size
+
+proc newVkPipelineLayoutCreateInfo*(sType: VkStructureType = VkStructureTypePipelineLayoutCreateInfo, pNext: pointer = nil, flags: VkPipelineLayoutCreateFlags = 0.VkPipelineLayoutCreateFlags, setLayoutCount: uint32, pSetLayouts: ptr VkDescriptorSetLayout, pushConstantRangeCount: uint32, pPushConstantRanges: ptr VkPushConstantRange): VkPipelineLayoutCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.setLayoutCount = setLayoutCount
+  result.pSetLayouts = pSetLayouts
+  result.pushConstantRangeCount = pushConstantRangeCount
+  result.pPushConstantRanges = pPushConstantRanges
+
+proc newVkSamplerCreateInfo*(sType: VkStructureType = VkStructureTypeSamplerCreateInfo, pNext: pointer = nil, flags: VkSamplerCreateFlags = 0.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): VkSamplerCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.magFilter = magFilter
+  result.minFilter = minFilter
+  result.mipmapMode = mipmapMode
+  result.addressModeU = addressModeU
+  result.addressModeV = addressModeV
+  result.addressModeW = addressModeW
+  result.mipLodBias = mipLodBias
+  result.anisotropyEnable = anisotropyEnable
+  result.maxAnisotropy = maxAnisotropy
+  result.compareEnable = compareEnable
+  result.compareOp = compareOp
+  result.minLod = minLod
+  result.maxLod = maxLod
+  result.borderColor = borderColor
+  result.unnormalizedCoordinates = unnormalizedCoordinates
+
+proc newVkCommandPoolCreateInfo*(sType: VkStructureType = VkStructureTypeCommandPoolCreateInfo, pNext: pointer = nil, flags: VkCommandPoolCreateFlags = 0.VkCommandPoolCreateFlags, queueFamilyIndex: uint32): VkCommandPoolCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.queueFamilyIndex = queueFamilyIndex
+
+proc newVkCommandBufferAllocateInfo*(sType: VkStructureType = VkStructureTypeCommandBufferAllocateInfo, pNext: pointer = nil, commandPool: VkCommandPool, level: VkCommandBufferLevel, commandBufferCount: uint32): VkCommandBufferAllocateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.commandPool = commandPool
+  result.level = level
+  result.commandBufferCount = commandBufferCount
+
+proc newVkCommandBufferInheritanceInfo*(sType: VkStructureType = VkStructureTypeCommandBufferInheritanceInfo, pNext: pointer = nil, renderPass: VkRenderPass, subpass: uint32, framebuffer: VkFramebuffer, occlusionQueryEnable: VkBool32, queryFlags: VkQueryControlFlags, pipelineStatistics: VkQueryPipelineStatisticFlags): VkCommandBufferInheritanceInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.renderPass = renderPass
+  result.subpass = subpass
+  result.framebuffer = framebuffer
+  result.occlusionQueryEnable = occlusionQueryEnable
+  result.queryFlags = queryFlags
+  result.pipelineStatistics = pipelineStatistics
+
+proc newVkCommandBufferBeginInfo*(sType: VkStructureType = VkStructureTypeCommandBufferBeginInfo, pNext: pointer = nil, flags: VkCommandBufferUsageFlags = 0.VkCommandBufferUsageFlags, pInheritanceInfo: ptr VkCommandBufferInheritanceInfo): VkCommandBufferBeginInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.pInheritanceInfo = pInheritanceInfo
+
+proc newVkRenderPassBeginInfo*(sType: VkStructureType = VkStructureTypeRenderPassBeginInfo, pNext: pointer = nil, renderPass: VkRenderPass, framebuffer: VkFramebuffer, renderArea: VkRect2D, clearValueCount: uint32, pClearValues: ptr VkClearValue): VkRenderPassBeginInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.renderPass = renderPass
+  result.framebuffer = framebuffer
+  result.renderArea = renderArea
+  result.clearValueCount = clearValueCount
+  result.pClearValues = pClearValues
+
+proc newVkClearDepthStencilValue*(depth: float32, stencil: uint32): VkClearDepthStencilValue =
+  result.depth = depth
+  result.stencil = stencil
+
+proc newVkClearAttachment*(aspectMask: VkImageAspectFlags, colorAttachment: uint32, clearValue: VkClearValue): VkClearAttachment =
+  result.aspectMask = aspectMask
+  result.colorAttachment = colorAttachment
+  result.clearValue = clearValue
+
+proc newVkAttachmentDescription*(flags: VkAttachmentDescriptionFlags = 0.VkAttachmentDescriptionFlags, format: VkFormat, samples: VkSampleCountFlagBits, loadOp: VkAttachmentLoadOp, storeOp: VkAttachmentStoreOp, stencilLoadOp: VkAttachmentLoadOp, stencilStoreOp: VkAttachmentStoreOp, initialLayout: VkImageLayout, finalLayout: VkImageLayout): VkAttachmentDescription =
+  result.flags = flags
+  result.format = format
+  result.samples = samples
+  result.loadOp = loadOp
+  result.storeOp = storeOp
+  result.stencilLoadOp = stencilLoadOp
+  result.stencilStoreOp = stencilStoreOp
+  result.initialLayout = initialLayout
+  result.finalLayout = finalLayout
+
+proc newVkAttachmentReference*(attachment: uint32, layout: VkImageLayout): VkAttachmentReference =
+  result.attachment = attachment
+  result.layout = layout
+
+proc newVkSubpassDescription*(flags: VkSubpassDescriptionFlags = 0.VkSubpassDescriptionFlags, pipelineBindPoint: VkPipelineBindPoint, inputAttachmentCount: uint32, pInputAttachments: ptr VkAttachmentReference, colorAttachmentCount: uint32, pColorAttachments: ptr VkAttachmentReference, pResolveAttachments: ptr VkAttachmentReference, pDepthStencilAttachment: ptr VkAttachmentReference, preserveAttachmentCount: uint32, pPreserveAttachments: ptr uint32): VkSubpassDescription =
+  result.flags = flags
+  result.pipelineBindPoint = pipelineBindPoint
+  result.inputAttachmentCount = inputAttachmentCount
+  result.pInputAttachments = pInputAttachments
+  result.colorAttachmentCount = colorAttachmentCount
+  result.pColorAttachments = pColorAttachments
+  result.pResolveAttachments = pResolveAttachments
+  result.pDepthStencilAttachment = pDepthStencilAttachment
+  result.preserveAttachmentCount = preserveAttachmentCount
+  result.pPreserveAttachments = pPreserveAttachments
+
+proc newVkSubpassDependency*(srcSubpass: uint32, dstSubpass: uint32, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, srcAccessMask: VkAccessFlags, dstAccessMask: VkAccessFlags, dependencyFlags: VkDependencyFlags): VkSubpassDependency =
+  result.srcSubpass = srcSubpass
+  result.dstSubpass = dstSubpass
+  result.srcStageMask = srcStageMask
+  result.dstStageMask = dstStageMask
+  result.srcAccessMask = srcAccessMask
+  result.dstAccessMask = dstAccessMask
+  result.dependencyFlags = dependencyFlags
+
+proc newVkRenderPassCreateInfo*(sType: VkStructureType = VkStructureTypeRenderPassCreateInfo, pNext: pointer = nil, flags: VkRenderPassCreateFlags = 0.VkRenderPassCreateFlags, attachmentCount: uint32, pAttachments: ptr VkAttachmentDescription, subpassCount: uint32, pSubpasses: ptr VkSubpassDescription, dependencyCount: uint32, pDependencies: ptr VkSubpassDependency): VkRenderPassCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.attachmentCount = attachmentCount
+  result.pAttachments = pAttachments
+  result.subpassCount = subpassCount
+  result.pSubpasses = pSubpasses
+  result.dependencyCount = dependencyCount
+  result.pDependencies = pDependencies
+
+proc newVkEventCreateInfo*(sType: VkStructureType = VkStructureTypeEventCreateInfo, pNext: pointer = nil, flags: VkEventCreateFlags = 0.VkEventCreateFlags): VkEventCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+
+proc newVkFenceCreateInfo*(sType: VkStructureType = VkStructureTypeFenceCreateInfo, pNext: pointer = nil, flags: VkFenceCreateFlags = 0.VkFenceCreateFlags): VkFenceCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+
+proc newVkPhysicalDeviceFeatures*(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): VkPhysicalDeviceFeatures =
+  result.robustBufferAccess = robustBufferAccess
+  result.fullDrawIndexUint32 = fullDrawIndexUint32
+  result.imageCubeArray = imageCubeArray
+  result.independentBlend = independentBlend
+  result.geometryShader = geometryShader
+  result.tessellationShader = tessellationShader
+  result.sampleRateShading = sampleRateShading
+  result.dualSrcBlend = dualSrcBlend
+  result.logicOp = logicOp
+  result.multiDrawIndirect = multiDrawIndirect
+  result.drawIndirectFirstInstance = drawIndirectFirstInstance
+  result.depthClamp = depthClamp
+  result.depthBiasClamp = depthBiasClamp
+  result.fillModeNonSolid = fillModeNonSolid
+  result.depthBounds = depthBounds
+  result.wideLines = wideLines
+  result.largePoints = largePoints
+  result.alphaToOne = alphaToOne
+  result.multiViewport = multiViewport
+  result.samplerAnisotropy = samplerAnisotropy
+  result.textureCompressionETC2 = textureCompressionETC2
+  result.textureCompressionASTC_LDR = textureCompressionASTC_LDR
+  result.textureCompressionBC = textureCompressionBC
+  result.occlusionQueryPrecise = occlusionQueryPrecise
+  result.pipelineStatisticsQuery = pipelineStatisticsQuery
+  result.vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics
+  result.fragmentStoresAndAtomics = fragmentStoresAndAtomics
+  result.shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize
+  result.shaderImageGatherExtended = shaderImageGatherExtended
+  result.shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats
+  result.shaderStorageImageMultisample = shaderStorageImageMultisample
+  result.shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat
+  result.shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat
+  result.shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing
+  result.shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing
+  result.shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing
+  result.shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing
+  result.shaderClipDistance = shaderClipDistance
+  result.shaderCullDistance = shaderCullDistance
+  result.shaderFloat64 = shaderFloat64
+  result.shaderInt64 = shaderInt64
+  result.shaderInt16 = shaderInt16
+  result.shaderResourceResidency = shaderResourceResidency
+  result.shaderResourceMinLod = shaderResourceMinLod
+  result.sparseBinding = sparseBinding
+  result.sparseResidencyBuffer = sparseResidencyBuffer
+  result.sparseResidencyImage2D = sparseResidencyImage2D
+  result.sparseResidencyImage3D = sparseResidencyImage3D
+  result.sparseResidency2Samples = sparseResidency2Samples
+  result.sparseResidency4Samples = sparseResidency4Samples
+  result.sparseResidency8Samples = sparseResidency8Samples
+  result.sparseResidency16Samples = sparseResidency16Samples
+  result.sparseResidencyAliased = sparseResidencyAliased
+  result.variableMultisampleRate = variableMultisampleRate
+  result.inheritedQueries = inheritedQueries
+
+proc newVkPhysicalDeviceSparseProperties*(residencyStandard2DBlockShape: VkBool32, residencyStandard2DMultisampleBlockShape: VkBool32, residencyStandard3DBlockShape: VkBool32, residencyAlignedMipSize: VkBool32, residencyNonResidentStrict: VkBool32): VkPhysicalDeviceSparseProperties =
+  result.residencyStandard2DBlockShape = residencyStandard2DBlockShape
+  result.residencyStandard2DMultisampleBlockShape = residencyStandard2DMultisampleBlockShape
+  result.residencyStandard3DBlockShape = residencyStandard3DBlockShape
+  result.residencyAlignedMipSize = residencyAlignedMipSize
+  result.residencyNonResidentStrict = residencyNonResidentStrict
+
+proc newVkPhysicalDeviceLimits*(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): VkPhysicalDeviceLimits =
+  result.maxImageDimension1D = maxImageDimension1D
+  result.maxImageDimension2D = maxImageDimension2D
+  result.maxImageDimension3D = maxImageDimension3D
+  result.maxImageDimensionCube = maxImageDimensionCube
+  result.maxImageArrayLayers = maxImageArrayLayers
+  result.maxTexelBufferElements = maxTexelBufferElements
+  result.maxUniformBufferRange = maxUniformBufferRange
+  result.maxStorageBufferRange = maxStorageBufferRange
+  result.maxPushConstantsSize = maxPushConstantsSize
+  result.maxMemoryAllocationCount = maxMemoryAllocationCount
+  result.maxSamplerAllocationCount = maxSamplerAllocationCount
+  result.bufferImageGranularity = bufferImageGranularity
+  result.sparseAddressSpaceSize = sparseAddressSpaceSize
+  result.maxBoundDescriptorSets = maxBoundDescriptorSets
+  result.maxPerStageDescriptorSamplers = maxPerStageDescriptorSamplers
+  result.maxPerStageDescriptorUniformBuffers = maxPerStageDescriptorUniformBuffers
+  result.maxPerStageDescriptorStorageBuffers = maxPerStageDescriptorStorageBuffers
+  result.maxPerStageDescriptorSampledImages = maxPerStageDescriptorSampledImages
+  result.maxPerStageDescriptorStorageImages = maxPerStageDescriptorStorageImages
+  result.maxPerStageDescriptorInputAttachments = maxPerStageDescriptorInputAttachments
+  result.maxPerStageResources = maxPerStageResources
+  result.maxDescriptorSetSamplers = maxDescriptorSetSamplers
+  result.maxDescriptorSetUniformBuffers = maxDescriptorSetUniformBuffers
+  result.maxDescriptorSetUniformBuffersDynamic = maxDescriptorSetUniformBuffersDynamic
+  result.maxDescriptorSetStorageBuffers = maxDescriptorSetStorageBuffers
+  result.maxDescriptorSetStorageBuffersDynamic = maxDescriptorSetStorageBuffersDynamic
+  result.maxDescriptorSetSampledImages = maxDescriptorSetSampledImages
+  result.maxDescriptorSetStorageImages = maxDescriptorSetStorageImages
+  result.maxDescriptorSetInputAttachments = maxDescriptorSetInputAttachments
+  result.maxVertexInputAttributes = maxVertexInputAttributes
+  result.maxVertexInputBindings = maxVertexInputBindings
+  result.maxVertexInputAttributeOffset = maxVertexInputAttributeOffset
+  result.maxVertexInputBindingStride = maxVertexInputBindingStride
+  result.maxVertexOutputComponents = maxVertexOutputComponents
+  result.maxTessellationGenerationLevel = maxTessellationGenerationLevel
+  result.maxTessellationPatchSize = maxTessellationPatchSize
+  result.maxTessellationControlPerVertexInputComponents = maxTessellationControlPerVertexInputComponents
+  result.maxTessellationControlPerVertexOutputComponents = maxTessellationControlPerVertexOutputComponents
+  result.maxTessellationControlPerPatchOutputComponents = maxTessellationControlPerPatchOutputComponents
+  result.maxTessellationControlTotalOutputComponents = maxTessellationControlTotalOutputComponents
+  result.maxTessellationEvaluationInputComponents = maxTessellationEvaluationInputComponents
+  result.maxTessellationEvaluationOutputComponents = maxTessellationEvaluationOutputComponents
+  result.maxGeometryShaderInvocations = maxGeometryShaderInvocations
+  result.maxGeometryInputComponents = maxGeometryInputComponents
+  result.maxGeometryOutputComponents = maxGeometryOutputComponents
+  result.maxGeometryOutputVertices = maxGeometryOutputVertices
+  result.maxGeometryTotalOutputComponents = maxGeometryTotalOutputComponents
+  result.maxFragmentInputComponents = maxFragmentInputComponents
+  result.maxFragmentOutputAttachments = maxFragmentOutputAttachments
+  result.maxFragmentDualSrcAttachments = maxFragmentDualSrcAttachments
+  result.maxFragmentCombinedOutputResources = maxFragmentCombinedOutputResources
+  result.maxComputeSharedMemorySize = maxComputeSharedMemorySize
+  result.maxComputeWorkGroupCount = maxComputeWorkGroupCount
+  result.maxComputeWorkGroupInvocations = maxComputeWorkGroupInvocations
+  result.maxComputeWorkGroupSize = maxComputeWorkGroupSize
+  result.subPixelPrecisionBits = subPixelPrecisionBits
+  result.subTexelPrecisionBits = subTexelPrecisionBits
+  result.mipmapPrecisionBits = mipmapPrecisionBits
+  result.maxDrawIndexedIndexValue = maxDrawIndexedIndexValue
+  result.maxDrawIndirectCount = maxDrawIndirectCount
+  result.maxSamplerLodBias = maxSamplerLodBias
+  result.maxSamplerAnisotropy = maxSamplerAnisotropy
+  result.maxViewports = maxViewports
+  result.maxViewportDimensions = maxViewportDimensions
+  result.viewportBoundsRange = viewportBoundsRange
+  result.viewportSubPixelBits = viewportSubPixelBits
+  result.minMemoryMapAlignment = minMemoryMapAlignment
+  result.minTexelBufferOffsetAlignment = minTexelBufferOffsetAlignment
+  result.minUniformBufferOffsetAlignment = minUniformBufferOffsetAlignment
+  result.minStorageBufferOffsetAlignment = minStorageBufferOffsetAlignment
+  result.minTexelOffset = minTexelOffset
+  result.maxTexelOffset = maxTexelOffset
+  result.minTexelGatherOffset = minTexelGatherOffset
+  result.maxTexelGatherOffset = maxTexelGatherOffset
+  result.minInterpolationOffset = minInterpolationOffset
+  result.maxInterpolationOffset = maxInterpolationOffset
+  result.subPixelInterpolationOffsetBits = subPixelInterpolationOffsetBits
+  result.maxFramebufferWidth = maxFramebufferWidth
+  result.maxFramebufferHeight = maxFramebufferHeight
+  result.maxFramebufferLayers = maxFramebufferLayers
+  result.framebufferColorSampleCounts = framebufferColorSampleCounts
+  result.framebufferDepthSampleCounts = framebufferDepthSampleCounts
+  result.framebufferStencilSampleCounts = framebufferStencilSampleCounts
+  result.framebufferNoAttachmentsSampleCounts = framebufferNoAttachmentsSampleCounts
+  result.maxColorAttachments = maxColorAttachments
+  result.sampledImageColorSampleCounts = sampledImageColorSampleCounts
+  result.sampledImageIntegerSampleCounts = sampledImageIntegerSampleCounts
+  result.sampledImageDepthSampleCounts = sampledImageDepthSampleCounts
+  result.sampledImageStencilSampleCounts = sampledImageStencilSampleCounts
+  result.storageImageSampleCounts = storageImageSampleCounts
+  result.maxSampleMaskWords = maxSampleMaskWords
+  result.timestampComputeAndGraphics = timestampComputeAndGraphics
+  result.timestampPeriod = timestampPeriod
+  result.maxClipDistances = maxClipDistances
+  result.maxCullDistances = maxCullDistances
+  result.maxCombinedClipAndCullDistances = maxCombinedClipAndCullDistances
+  result.discreteQueuePriorities = discreteQueuePriorities
+  result.pointSizeRange = pointSizeRange
+  result.lineWidthRange = lineWidthRange
+  result.pointSizeGranularity = pointSizeGranularity
+  result.lineWidthGranularity = lineWidthGranularity
+  result.strictLines = strictLines
+  result.standardSampleLocations = standardSampleLocations
+  result.optimalBufferCopyOffsetAlignment = optimalBufferCopyOffsetAlignment
+  result.optimalBufferCopyRowPitchAlignment = optimalBufferCopyRowPitchAlignment
+  result.nonCoherentAtomSize = nonCoherentAtomSize
+
+proc newVkSemaphoreCreateInfo*(sType: VkStructureType = VkStructureTypeSemaphoreCreateInfo, pNext: pointer = nil, flags: VkSemaphoreCreateFlags = 0.VkSemaphoreCreateFlags): VkSemaphoreCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+
+proc newVkQueryPoolCreateInfo*(sType: VkStructureType = VkStructureTypeQueryPoolCreateInfo, pNext: pointer = nil, flags: VkQueryPoolCreateFlags = 0.VkQueryPoolCreateFlags, queryType: VkQueryType, queryCount: uint32, pipelineStatistics: VkQueryPipelineStatisticFlags): VkQueryPoolCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.queryType = queryType
+  result.queryCount = queryCount
+  result.pipelineStatistics = pipelineStatistics
+
+proc newVkFramebufferCreateInfo*(sType: VkStructureType = VkStructureTypeFramebufferCreateInfo, pNext: pointer = nil, flags: VkFramebufferCreateFlags = 0.VkFramebufferCreateFlags, renderPass: VkRenderPass, attachmentCount: uint32, pAttachments: ptr VkImageView, width: uint32, height: uint32, layers: uint32): VkFramebufferCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.renderPass = renderPass
+  result.attachmentCount = attachmentCount
+  result.pAttachments = pAttachments
+  result.width = width
+  result.height = height
+  result.layers = layers
+
+proc newVkDrawIndirectCommand*(vertexCount: uint32, instanceCount: uint32, firstVertex: uint32, firstInstance: uint32): VkDrawIndirectCommand =
+  result.vertexCount = vertexCount
+  result.instanceCount = instanceCount
+  result.firstVertex = firstVertex
+  result.firstInstance = firstInstance
+
+proc newVkDrawIndexedIndirectCommand*(indexCount: uint32, instanceCount: uint32, firstIndex: uint32, vertexOffset: int32, firstInstance: uint32): VkDrawIndexedIndirectCommand =
+  result.indexCount = indexCount
+  result.instanceCount = instanceCount
+  result.firstIndex = firstIndex
+  result.vertexOffset = vertexOffset
+  result.firstInstance = firstInstance
+
+proc newVkDispatchIndirectCommand*(x: uint32, y: uint32, z: uint32): VkDispatchIndirectCommand =
+  result.x = x
+  result.y = y
+  result.z = z
+
+proc newVkSubmitInfo*(sType: VkStructureType = VkStructureTypeSubmitInfo, pNext: pointer = nil, waitSemaphoreCount: uint32, pWaitSemaphores: ptr VkSemaphore, pWaitDstStageMask: ptr VkPipelineStageFlags, commandBufferCount: uint32, pCommandBuffers: ptr VkCommandBuffer, signalSemaphoreCount: uint32, pSignalSemaphores: ptr VkSemaphore): VkSubmitInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.waitSemaphoreCount = waitSemaphoreCount
+  result.pWaitSemaphores = pWaitSemaphores
+  result.pWaitDstStageMask = pWaitDstStageMask
+  result.commandBufferCount = commandBufferCount
+  result.pCommandBuffers = pCommandBuffers
+  result.signalSemaphoreCount = signalSemaphoreCount
+  result.pSignalSemaphores = pSignalSemaphores
+
+proc newVkDisplayPropertiesKHR*(display: VkDisplayKHR, displayName: cstring, physicalDimensions: VkExtent2D, physicalResolution: VkExtent2D, supportedTransforms: VkSurfaceTransformFlagsKHR, planeReorderPossible: VkBool32, persistentContent: VkBool32): VkDisplayPropertiesKHR =
+  result.display = display
+  result.displayName = displayName
+  result.physicalDimensions = physicalDimensions
+  result.physicalResolution = physicalResolution
+  result.supportedTransforms = supportedTransforms
+  result.planeReorderPossible = planeReorderPossible
+  result.persistentContent = persistentContent
+
+proc newVkDisplayPlanePropertiesKHR*(currentDisplay: VkDisplayKHR, currentStackIndex: uint32): VkDisplayPlanePropertiesKHR =
+  result.currentDisplay = currentDisplay
+  result.currentStackIndex = currentStackIndex
+
+proc newVkDisplayModeParametersKHR*(visibleRegion: VkExtent2D, refreshRate: uint32): VkDisplayModeParametersKHR =
+  result.visibleRegion = visibleRegion
+  result.refreshRate = refreshRate
+
+proc newVkDisplayModePropertiesKHR*(displayMode: VkDisplayModeKHR, parameters: VkDisplayModeParametersKHR): VkDisplayModePropertiesKHR =
+  result.displayMode = displayMode
+  result.parameters = parameters
+
+proc newVkDisplayModeCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkDisplayModeCreateFlagsKHR = 0.VkDisplayModeCreateFlagsKHR, parameters: VkDisplayModeParametersKHR): VkDisplayModeCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.parameters = parameters
+
+proc newVkDisplayPlaneCapabilitiesKHR*(supportedAlpha: VkDisplayPlaneAlphaFlagsKHR, minSrcPosition: VkOffset2D, maxSrcPosition: VkOffset2D, minSrcExtent: VkExtent2D, maxSrcExtent: VkExtent2D, minDstPosition: VkOffset2D, maxDstPosition: VkOffset2D, minDstExtent: VkExtent2D, maxDstExtent: VkExtent2D): VkDisplayPlaneCapabilitiesKHR =
+  result.supportedAlpha = supportedAlpha
+  result.minSrcPosition = minSrcPosition
+  result.maxSrcPosition = maxSrcPosition
+  result.minSrcExtent = minSrcExtent
+  result.maxSrcExtent = maxSrcExtent
+  result.minDstPosition = minDstPosition
+  result.maxDstPosition = maxDstPosition
+  result.minDstExtent = minDstExtent
+  result.maxDstExtent = maxDstExtent
+
+proc newVkDisplaySurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkDisplaySurfaceCreateFlagsKHR = 0.VkDisplaySurfaceCreateFlagsKHR, displayMode: VkDisplayModeKHR, planeIndex: uint32, planeStackIndex: uint32, transform: VkSurfaceTransformFlagBitsKHR, globalAlpha: float32, alphaMode: VkDisplayPlaneAlphaFlagBitsKHR, imageExtent: VkExtent2D): VkDisplaySurfaceCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.displayMode = displayMode
+  result.planeIndex = planeIndex
+  result.planeStackIndex = planeStackIndex
+  result.transform = transform
+  result.globalAlpha = globalAlpha
+  result.alphaMode = alphaMode
+  result.imageExtent = imageExtent
+
+proc newVkDisplayPresentInfoKHR*(sType: VkStructureType, pNext: pointer = nil, srcRect: VkRect2D, dstRect: VkRect2D, persistent: VkBool32): VkDisplayPresentInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.srcRect = srcRect
+  result.dstRect = dstRect
+  result.persistent = persistent
+
+proc newVkSurfaceCapabilitiesKHR*(minImageCount: uint32, maxImageCount: uint32, currentExtent: VkExtent2D, minImageExtent: VkExtent2D, maxImageExtent: VkExtent2D, maxImageArrayLayers: uint32, supportedTransforms: VkSurfaceTransformFlagsKHR, currentTransform: VkSurfaceTransformFlagBitsKHR, supportedCompositeAlpha: VkCompositeAlphaFlagsKHR, supportedUsageFlags: VkImageUsageFlags): VkSurfaceCapabilitiesKHR =
+  result.minImageCount = minImageCount
+  result.maxImageCount = maxImageCount
+  result.currentExtent = currentExtent
+  result.minImageExtent = minImageExtent
+  result.maxImageExtent = maxImageExtent
+  result.maxImageArrayLayers = maxImageArrayLayers
+  result.supportedTransforms = supportedTransforms
+  result.currentTransform = currentTransform
+  result.supportedCompositeAlpha = supportedCompositeAlpha
+  result.supportedUsageFlags = supportedUsageFlags
+
+proc newVkAndroidSurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkAndroidSurfaceCreateFlagsKHR = 0.VkAndroidSurfaceCreateFlagsKHR, window: ptr ANativeWindow): VkAndroidSurfaceCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.window = window
+
+proc newVkViSurfaceCreateInfoNN*(sType: VkStructureType, pNext: pointer = nil, flags: VkViSurfaceCreateFlagsNN = 0.VkViSurfaceCreateFlagsNN, window: pointer = nil): VkViSurfaceCreateInfoNN =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.window = window
+
+proc newVkWaylandSurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkWaylandSurfaceCreateFlagsKHR = 0.VkWaylandSurfaceCreateFlagsKHR, display: ptr wl_display, surface: ptr wl_surface): VkWaylandSurfaceCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.display = display
+  result.surface = surface
+
+proc newVkWin32SurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkWin32SurfaceCreateFlagsKHR = 0.VkWin32SurfaceCreateFlagsKHR, hinstance: HINSTANCE, hwnd: HWND): VkWin32SurfaceCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.hinstance = hinstance
+  result.hwnd = hwnd
+
+proc newVkXlibSurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkXlibSurfaceCreateFlagsKHR = 0.VkXlibSurfaceCreateFlagsKHR, dpy: ptr Display, window: Window): VkXlibSurfaceCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.dpy = dpy
+  result.window = window
+
+proc newVkXcbSurfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkXcbSurfaceCreateFlagsKHR = 0.VkXcbSurfaceCreateFlagsKHR, connection: ptr xcb_connection_t, window: xcb_window_t): VkXcbSurfaceCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.connection = connection
+  result.window = window
+
+proc newVkDirectFBSurfaceCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkDirectFBSurfaceCreateFlagsEXT = 0.VkDirectFBSurfaceCreateFlagsEXT, dfb: ptr IDirectFB, surface: ptr IDirectFBSurface): VkDirectFBSurfaceCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.dfb = dfb
+  result.surface = surface
+
+proc newVkImagePipeSurfaceCreateInfoFUCHSIA*(sType: VkStructureType, pNext: pointer = nil, flags: VkImagePipeSurfaceCreateFlagsFUCHSIA = 0.VkImagePipeSurfaceCreateFlagsFUCHSIA, imagePipeHandle: zx_handle_t): VkImagePipeSurfaceCreateInfoFUCHSIA =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.imagePipeHandle = imagePipeHandle
+
+proc newVkStreamDescriptorSurfaceCreateInfoGGP*(sType: VkStructureType, pNext: pointer = nil, flags: VkStreamDescriptorSurfaceCreateFlagsGGP = 0.VkStreamDescriptorSurfaceCreateFlagsGGP, streamDescriptor: GgpStreamDescriptor): VkStreamDescriptorSurfaceCreateInfoGGP =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.streamDescriptor = streamDescriptor
+
+proc newVkSurfaceFormatKHR*(format: VkFormat, colorSpace: VkColorSpaceKHR): VkSurfaceFormatKHR =
+  result.format = format
+  result.colorSpace = colorSpace
+
+proc newVkSwapchainCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkSwapchainCreateFlagsKHR = 0.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): VkSwapchainCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.surface = surface
+  result.minImageCount = minImageCount
+  result.imageFormat = imageFormat
+  result.imageColorSpace = imageColorSpace
+  result.imageExtent = imageExtent
+  result.imageArrayLayers = imageArrayLayers
+  result.imageUsage = imageUsage
+  result.imageSharingMode = imageSharingMode
+  result.queueFamilyIndexCount = queueFamilyIndexCount
+  result.pQueueFamilyIndices = pQueueFamilyIndices
+  result.preTransform = preTransform
+  result.compositeAlpha = compositeAlpha
+  result.presentMode = presentMode
+  result.clipped = clipped
+  result.oldSwapchain = oldSwapchain
+
+proc newVkPresentInfoKHR*(sType: VkStructureType, pNext: pointer = nil, waitSemaphoreCount: uint32, pWaitSemaphores: ptr VkSemaphore, swapchainCount: uint32, pSwapchains: ptr VkSwapchainKHR, pImageIndices: ptr uint32, pResults: ptr VkResult): VkPresentInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.waitSemaphoreCount = waitSemaphoreCount
+  result.pWaitSemaphores = pWaitSemaphores
+  result.swapchainCount = swapchainCount
+  result.pSwapchains = pSwapchains
+  result.pImageIndices = pImageIndices
+  result.pResults = pResults
+
+proc newVkDebugReportCallbackCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkDebugReportFlagsEXT = 0.VkDebugReportFlagsEXT, pfnCallback: PFN_vkDebugReportCallbackEXT, pUserData: pointer = nil): VkDebugReportCallbackCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.pfnCallback = pfnCallback
+  result.pUserData = pUserData
+
+proc newVkValidationFlagsEXT*(sType: VkStructureType, pNext: pointer = nil, disabledValidationCheckCount: uint32, pDisabledValidationChecks: ptr VkValidationCheckEXT): VkValidationFlagsEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.disabledValidationCheckCount = disabledValidationCheckCount
+  result.pDisabledValidationChecks = pDisabledValidationChecks
+
+proc newVkValidationFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, enabledValidationFeatureCount: uint32, pEnabledValidationFeatures: ptr VkValidationFeatureEnableEXT, disabledValidationFeatureCount: uint32, pDisabledValidationFeatures: ptr VkValidationFeatureDisableEXT): VkValidationFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.enabledValidationFeatureCount = enabledValidationFeatureCount
+  result.pEnabledValidationFeatures = pEnabledValidationFeatures
+  result.disabledValidationFeatureCount = disabledValidationFeatureCount
+  result.pDisabledValidationFeatures = pDisabledValidationFeatures
+
+proc newVkPipelineRasterizationStateRasterizationOrderAMD*(sType: VkStructureType, pNext: pointer = nil, rasterizationOrder: VkRasterizationOrderAMD): VkPipelineRasterizationStateRasterizationOrderAMD =
+  result.sType = sType
+  result.pNext = pNext
+  result.rasterizationOrder = rasterizationOrder
+
+proc newVkDebugMarkerObjectNameInfoEXT*(sType: VkStructureType, pNext: pointer = nil, objectType: VkDebugReportObjectTypeEXT, `object`: uint64, pObjectName: cstring): VkDebugMarkerObjectNameInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.objectType = objectType
+  result.`object` = `object`
+  result.pObjectName = pObjectName
+
+proc newVkDebugMarkerObjectTagInfoEXT*(sType: VkStructureType, pNext: pointer = nil, objectType: VkDebugReportObjectTypeEXT, `object`: uint64, tagName: uint64, tagSize: uint, pTag: pointer = nil): VkDebugMarkerObjectTagInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.objectType = objectType
+  result.`object` = `object`
+  result.tagName = tagName
+  result.tagSize = tagSize
+  result.pTag = pTag
+
+proc newVkDebugMarkerMarkerInfoEXT*(sType: VkStructureType, pNext: pointer = nil, pMarkerName: cstring, color: array[4, float32]): VkDebugMarkerMarkerInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.pMarkerName = pMarkerName
+  result.color = color
+
+proc newVkDedicatedAllocationImageCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, dedicatedAllocation: VkBool32): VkDedicatedAllocationImageCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.dedicatedAllocation = dedicatedAllocation
+
+proc newVkDedicatedAllocationBufferCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, dedicatedAllocation: VkBool32): VkDedicatedAllocationBufferCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.dedicatedAllocation = dedicatedAllocation
+
+proc newVkDedicatedAllocationMemoryAllocateInfoNV*(sType: VkStructureType, pNext: pointer = nil, image: VkImage, buffer: VkBuffer): VkDedicatedAllocationMemoryAllocateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.image = image
+  result.buffer = buffer
+
+proc newVkExternalImageFormatPropertiesNV*(imageFormatProperties: VkImageFormatProperties, externalMemoryFeatures: VkExternalMemoryFeatureFlagsNV, exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlagsNV, compatibleHandleTypes: VkExternalMemoryHandleTypeFlagsNV): VkExternalImageFormatPropertiesNV =
+  result.imageFormatProperties = imageFormatProperties
+  result.externalMemoryFeatures = externalMemoryFeatures
+  result.exportFromImportedHandleTypes = exportFromImportedHandleTypes
+  result.compatibleHandleTypes = compatibleHandleTypes
+
+proc newVkExternalMemoryImageCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalMemoryHandleTypeFlagsNV): VkExternalMemoryImageCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleTypes = handleTypes
+
+proc newVkExportMemoryAllocateInfoNV*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalMemoryHandleTypeFlagsNV): VkExportMemoryAllocateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleTypes = handleTypes
+
+proc newVkImportMemoryWin32HandleInfoNV*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalMemoryHandleTypeFlagsNV, handle: HANDLE): VkImportMemoryWin32HandleInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleType = handleType
+  result.handle = handle
+
+proc newVkExportMemoryWin32HandleInfoNV*(sType: VkStructureType, pNext: pointer = nil, pAttributes: ptr SECURITY_ATTRIBUTES, dwAccess: DWORD): VkExportMemoryWin32HandleInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.pAttributes = pAttributes
+  result.dwAccess = dwAccess
+
+proc newVkWin32KeyedMutexAcquireReleaseInfoNV*(sType: VkStructureType, pNext: pointer = nil, acquireCount: uint32, pAcquireSyncs: ptr VkDeviceMemory, pAcquireKeys: ptr uint64, pAcquireTimeoutMilliseconds: ptr uint32, releaseCount: uint32, pReleaseSyncs: ptr VkDeviceMemory, pReleaseKeys: ptr uint64): VkWin32KeyedMutexAcquireReleaseInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.acquireCount = acquireCount
+  result.pAcquireSyncs = pAcquireSyncs
+  result.pAcquireKeys = pAcquireKeys
+  result.pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds
+  result.releaseCount = releaseCount
+  result.pReleaseSyncs = pReleaseSyncs
+  result.pReleaseKeys = pReleaseKeys
+
+proc newVkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, deviceGeneratedCommands: VkBool32): VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceGeneratedCommands = deviceGeneratedCommands
+
+proc newVkDevicePrivateDataCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, privateDataSlotRequestCount: uint32): VkDevicePrivateDataCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.privateDataSlotRequestCount = privateDataSlotRequestCount
+
+proc newVkPrivateDataSlotCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkPrivateDataSlotCreateFlagsEXT = 0.VkPrivateDataSlotCreateFlagsEXT): VkPrivateDataSlotCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+
+proc newVkPhysicalDevicePrivateDataFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, privateData: VkBool32): VkPhysicalDevicePrivateDataFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.privateData = privateData
+
+proc newVkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, maxGraphicsShaderGroupCount: uint32, maxIndirectSequenceCount: uint32, maxIndirectCommandsTokenCount: uint32, maxIndirectCommandsStreamCount: uint32, maxIndirectCommandsTokenOffset: uint32, maxIndirectCommandsStreamStride: uint32, minSequencesCountBufferOffsetAlignment: uint32, minSequencesIndexBufferOffsetAlignment: uint32, minIndirectCommandsBufferOffsetAlignment: uint32): VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxGraphicsShaderGroupCount = maxGraphicsShaderGroupCount
+  result.maxIndirectSequenceCount = maxIndirectSequenceCount
+  result.maxIndirectCommandsTokenCount = maxIndirectCommandsTokenCount
+  result.maxIndirectCommandsStreamCount = maxIndirectCommandsStreamCount
+  result.maxIndirectCommandsTokenOffset = maxIndirectCommandsTokenOffset
+  result.maxIndirectCommandsStreamStride = maxIndirectCommandsStreamStride
+  result.minSequencesCountBufferOffsetAlignment = minSequencesCountBufferOffsetAlignment
+  result.minSequencesIndexBufferOffsetAlignment = minSequencesIndexBufferOffsetAlignment
+  result.minIndirectCommandsBufferOffsetAlignment = minIndirectCommandsBufferOffsetAlignment
+
+proc newVkGraphicsShaderGroupCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, stageCount: uint32, pStages: ptr VkPipelineShaderStageCreateInfo, pVertexInputState: ptr VkPipelineVertexInputStateCreateInfo, pTessellationState: ptr VkPipelineTessellationStateCreateInfo): VkGraphicsShaderGroupCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.stageCount = stageCount
+  result.pStages = pStages
+  result.pVertexInputState = pVertexInputState
+  result.pTessellationState = pTessellationState
+
+proc newVkGraphicsPipelineShaderGroupsCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, groupCount: uint32, pGroups: ptr VkGraphicsShaderGroupCreateInfoNV, pipelineCount: uint32, pPipelines: ptr VkPipeline): VkGraphicsPipelineShaderGroupsCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.groupCount = groupCount
+  result.pGroups = pGroups
+  result.pipelineCount = pipelineCount
+  result.pPipelines = pPipelines
+
+proc newVkBindShaderGroupIndirectCommandNV*(groupIndex: uint32): VkBindShaderGroupIndirectCommandNV =
+  result.groupIndex = groupIndex
+
+proc newVkBindIndexBufferIndirectCommandNV*(bufferAddress: VkDeviceAddress, size: uint32, indexType: VkIndexType): VkBindIndexBufferIndirectCommandNV =
+  result.bufferAddress = bufferAddress
+  result.size = size
+  result.indexType = indexType
+
+proc newVkBindVertexBufferIndirectCommandNV*(bufferAddress: VkDeviceAddress, size: uint32, stride: uint32): VkBindVertexBufferIndirectCommandNV =
+  result.bufferAddress = bufferAddress
+  result.size = size
+  result.stride = stride
+
+proc newVkSetStateFlagsIndirectCommandNV*(data: uint32): VkSetStateFlagsIndirectCommandNV =
+  result.data = data
+
+proc newVkIndirectCommandsStreamNV*(buffer: VkBuffer, offset: VkDeviceSize): VkIndirectCommandsStreamNV =
+  result.buffer = buffer
+  result.offset = offset
+
+proc newVkIndirectCommandsLayoutTokenNV*(sType: VkStructureType, pNext: pointer = nil, 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): VkIndirectCommandsLayoutTokenNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.tokenType = tokenType
+  result.stream = stream
+  result.offset = offset
+  result.vertexBindingUnit = vertexBindingUnit
+  result.vertexDynamicStride = vertexDynamicStride
+  result.pushconstantPipelineLayout = pushconstantPipelineLayout
+  result.pushconstantShaderStageFlags = pushconstantShaderStageFlags
+  result.pushconstantOffset = pushconstantOffset
+  result.pushconstantSize = pushconstantSize
+  result.indirectStateFlags = indirectStateFlags
+  result.indexTypeCount = indexTypeCount
+  result.pIndexTypes = pIndexTypes
+  result.pIndexTypeValues = pIndexTypeValues
+
+proc newVkIndirectCommandsLayoutCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkIndirectCommandsLayoutUsageFlagsNV = 0.VkIndirectCommandsLayoutUsageFlagsNV, pipelineBindPoint: VkPipelineBindPoint, tokenCount: uint32, pTokens: ptr VkIndirectCommandsLayoutTokenNV, streamCount: uint32, pStreamStrides: ptr uint32): VkIndirectCommandsLayoutCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.pipelineBindPoint = pipelineBindPoint
+  result.tokenCount = tokenCount
+  result.pTokens = pTokens
+  result.streamCount = streamCount
+  result.pStreamStrides = pStreamStrides
+
+proc newVkGeneratedCommandsInfoNV*(sType: VkStructureType, pNext: pointer = nil, 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): VkGeneratedCommandsInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.pipelineBindPoint = pipelineBindPoint
+  result.pipeline = pipeline
+  result.indirectCommandsLayout = indirectCommandsLayout
+  result.streamCount = streamCount
+  result.pStreams = pStreams
+  result.sequencesCount = sequencesCount
+  result.preprocessBuffer = preprocessBuffer
+  result.preprocessOffset = preprocessOffset
+  result.preprocessSize = preprocessSize
+  result.sequencesCountBuffer = sequencesCountBuffer
+  result.sequencesCountOffset = sequencesCountOffset
+  result.sequencesIndexBuffer = sequencesIndexBuffer
+  result.sequencesIndexOffset = sequencesIndexOffset
+
+proc newVkGeneratedCommandsMemoryRequirementsInfoNV*(sType: VkStructureType, pNext: pointer = nil, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, indirectCommandsLayout: VkIndirectCommandsLayoutNV, maxSequencesCount: uint32): VkGeneratedCommandsMemoryRequirementsInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.pipelineBindPoint = pipelineBindPoint
+  result.pipeline = pipeline
+  result.indirectCommandsLayout = indirectCommandsLayout
+  result.maxSequencesCount = maxSequencesCount
+
+proc newVkPhysicalDeviceFeatures2*(sType: VkStructureType, pNext: pointer = nil, features: VkPhysicalDeviceFeatures): VkPhysicalDeviceFeatures2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.features = features
+
+proc newVkPhysicalDeviceProperties2*(sType: VkStructureType, pNext: pointer = nil, properties: VkPhysicalDeviceProperties): VkPhysicalDeviceProperties2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.properties = properties
+
+proc newVkFormatProperties2*(sType: VkStructureType, pNext: pointer = nil, formatProperties: VkFormatProperties): VkFormatProperties2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.formatProperties = formatProperties
+
+proc newVkImageFormatProperties2*(sType: VkStructureType, pNext: pointer = nil, imageFormatProperties: VkImageFormatProperties): VkImageFormatProperties2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.imageFormatProperties = imageFormatProperties
+
+proc newVkPhysicalDeviceImageFormatInfo2*(sType: VkStructureType, pNext: pointer = nil, format: VkFormat, `type`: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags = 0.VkImageCreateFlags): VkPhysicalDeviceImageFormatInfo2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.format = format
+  result.`type` = `type`
+  result.tiling = tiling
+  result.usage = usage
+  result.flags = flags
+
+proc newVkQueueFamilyProperties2*(sType: VkStructureType, pNext: pointer = nil, queueFamilyProperties: VkQueueFamilyProperties): VkQueueFamilyProperties2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.queueFamilyProperties = queueFamilyProperties
+
+proc newVkPhysicalDeviceMemoryProperties2*(sType: VkStructureType, pNext: pointer = nil, memoryProperties: VkPhysicalDeviceMemoryProperties): VkPhysicalDeviceMemoryProperties2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.memoryProperties = memoryProperties
+
+proc newVkSparseImageFormatProperties2*(sType: VkStructureType, pNext: pointer = nil, properties: VkSparseImageFormatProperties): VkSparseImageFormatProperties2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.properties = properties
+
+proc newVkPhysicalDeviceSparseImageFormatInfo2*(sType: VkStructureType, pNext: pointer = nil, format: VkFormat, `type`: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling): VkPhysicalDeviceSparseImageFormatInfo2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.format = format
+  result.`type` = `type`
+  result.samples = samples
+  result.usage = usage
+  result.tiling = tiling
+
+proc newVkPhysicalDevicePushDescriptorPropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, maxPushDescriptors: uint32): VkPhysicalDevicePushDescriptorPropertiesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxPushDescriptors = maxPushDescriptors
+
+proc newVkConformanceVersion*(major: uint8, minor: uint8, subminor: uint8, patch: uint8): VkConformanceVersion =
+  result.major = major
+  result.minor = minor
+  result.subminor = subminor
+  result.patch = patch
+
+proc newVkPhysicalDeviceDriverProperties*(sType: VkStructureType, pNext: pointer = nil, driverID: VkDriverId, driverName: array[VK_MAX_DRIVER_NAME_SIZE, char], driverInfo: array[VK_MAX_DRIVER_INFO_SIZE, char], conformanceVersion: VkConformanceVersion): VkPhysicalDeviceDriverProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.driverID = driverID
+  result.driverName = driverName
+  result.driverInfo = driverInfo
+  result.conformanceVersion = conformanceVersion
+
+proc newVkPresentRegionsKHR*(sType: VkStructureType, pNext: pointer = nil, swapchainCount: uint32, pRegions: ptr VkPresentRegionKHR): VkPresentRegionsKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.swapchainCount = swapchainCount
+  result.pRegions = pRegions
+
+proc newVkPresentRegionKHR*(rectangleCount: uint32, pRectangles: ptr VkRectLayerKHR): VkPresentRegionKHR =
+  result.rectangleCount = rectangleCount
+  result.pRectangles = pRectangles
+
+proc newVkRectLayerKHR*(offset: VkOffset2D, extent: VkExtent2D, layer: uint32): VkRectLayerKHR =
+  result.offset = offset
+  result.extent = extent
+  result.layer = layer
+
+proc newVkPhysicalDeviceVariablePointersFeatures*(sType: VkStructureType, pNext: pointer = nil, variablePointersStorageBuffer: VkBool32, variablePointers: VkBool32): VkPhysicalDeviceVariablePointersFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.variablePointersStorageBuffer = variablePointersStorageBuffer
+  result.variablePointers = variablePointers
+
+proc newVkExternalMemoryProperties*(externalMemoryFeatures: VkExternalMemoryFeatureFlags, exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlags, compatibleHandleTypes: VkExternalMemoryHandleTypeFlags): VkExternalMemoryProperties =
+  result.externalMemoryFeatures = externalMemoryFeatures
+  result.exportFromImportedHandleTypes = exportFromImportedHandleTypes
+  result.compatibleHandleTypes = compatibleHandleTypes
+
+proc newVkPhysicalDeviceExternalImageFormatInfo*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalMemoryHandleTypeFlagBits): VkPhysicalDeviceExternalImageFormatInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleType = handleType
+
+proc newVkExternalImageFormatProperties*(sType: VkStructureType, pNext: pointer = nil, externalMemoryProperties: VkExternalMemoryProperties): VkExternalImageFormatProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.externalMemoryProperties = externalMemoryProperties
+
+proc newVkPhysicalDeviceExternalBufferInfo*(sType: VkStructureType, pNext: pointer = nil, flags: VkBufferCreateFlags = 0.VkBufferCreateFlags, usage: VkBufferUsageFlags, handleType: VkExternalMemoryHandleTypeFlagBits): VkPhysicalDeviceExternalBufferInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.usage = usage
+  result.handleType = handleType
+
+proc newVkExternalBufferProperties*(sType: VkStructureType, pNext: pointer = nil, externalMemoryProperties: VkExternalMemoryProperties): VkExternalBufferProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.externalMemoryProperties = externalMemoryProperties
+
+proc newVkPhysicalDeviceIDProperties*(sType: VkStructureType, pNext: pointer = nil, deviceUUID: array[VK_UUID_SIZE, uint8], driverUUID: array[VK_UUID_SIZE, uint8], deviceLUID: array[VK_LUID_SIZE, uint8], deviceNodeMask: uint32, deviceLUIDValid: VkBool32): VkPhysicalDeviceIDProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceUUID = deviceUUID
+  result.driverUUID = driverUUID
+  result.deviceLUID = deviceLUID
+  result.deviceNodeMask = deviceNodeMask
+  result.deviceLUIDValid = deviceLUIDValid
+
+proc newVkExternalMemoryImageCreateInfo*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalMemoryHandleTypeFlags): VkExternalMemoryImageCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleTypes = handleTypes
+
+proc newVkExternalMemoryBufferCreateInfo*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalMemoryHandleTypeFlags): VkExternalMemoryBufferCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleTypes = handleTypes
+
+proc newVkExportMemoryAllocateInfo*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalMemoryHandleTypeFlags): VkExportMemoryAllocateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleTypes = handleTypes
+
+proc newVkImportMemoryWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalMemoryHandleTypeFlagBits, handle: HANDLE, name: LPCWSTR): VkImportMemoryWin32HandleInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleType = handleType
+  result.handle = handle
+  result.name = name
+
+proc newVkExportMemoryWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, pAttributes: ptr SECURITY_ATTRIBUTES, dwAccess: DWORD, name: LPCWSTR): VkExportMemoryWin32HandleInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.pAttributes = pAttributes
+  result.dwAccess = dwAccess
+  result.name = name
+
+proc newVkMemoryWin32HandlePropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, memoryTypeBits: uint32): VkMemoryWin32HandlePropertiesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.memoryTypeBits = memoryTypeBits
+
+proc newVkMemoryGetWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, memory: VkDeviceMemory, handleType: VkExternalMemoryHandleTypeFlagBits): VkMemoryGetWin32HandleInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.memory = memory
+  result.handleType = handleType
+
+proc newVkImportMemoryFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalMemoryHandleTypeFlagBits, fd: int): VkImportMemoryFdInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleType = handleType
+  result.fd = fd
+
+proc newVkMemoryFdPropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, memoryTypeBits: uint32): VkMemoryFdPropertiesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.memoryTypeBits = memoryTypeBits
+
+proc newVkMemoryGetFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, memory: VkDeviceMemory, handleType: VkExternalMemoryHandleTypeFlagBits): VkMemoryGetFdInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.memory = memory
+  result.handleType = handleType
+
+proc newVkWin32KeyedMutexAcquireReleaseInfoKHR*(sType: VkStructureType, pNext: pointer = nil, acquireCount: uint32, pAcquireSyncs: ptr VkDeviceMemory, pAcquireKeys: ptr uint64, pAcquireTimeouts: ptr uint32, releaseCount: uint32, pReleaseSyncs: ptr VkDeviceMemory, pReleaseKeys: ptr uint64): VkWin32KeyedMutexAcquireReleaseInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.acquireCount = acquireCount
+  result.pAcquireSyncs = pAcquireSyncs
+  result.pAcquireKeys = pAcquireKeys
+  result.pAcquireTimeouts = pAcquireTimeouts
+  result.releaseCount = releaseCount
+  result.pReleaseSyncs = pReleaseSyncs
+  result.pReleaseKeys = pReleaseKeys
+
+proc newVkPhysicalDeviceExternalSemaphoreInfo*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalSemaphoreHandleTypeFlagBits): VkPhysicalDeviceExternalSemaphoreInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleType = handleType
+
+proc newVkExternalSemaphoreProperties*(sType: VkStructureType, pNext: pointer = nil, exportFromImportedHandleTypes: VkExternalSemaphoreHandleTypeFlags, compatibleHandleTypes: VkExternalSemaphoreHandleTypeFlags, externalSemaphoreFeatures: VkExternalSemaphoreFeatureFlags): VkExternalSemaphoreProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.exportFromImportedHandleTypes = exportFromImportedHandleTypes
+  result.compatibleHandleTypes = compatibleHandleTypes
+  result.externalSemaphoreFeatures = externalSemaphoreFeatures
+
+proc newVkExportSemaphoreCreateInfo*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalSemaphoreHandleTypeFlags): VkExportSemaphoreCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleTypes = handleTypes
+
+proc newVkImportSemaphoreWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, semaphore: VkSemaphore, flags: VkSemaphoreImportFlags = 0.VkSemaphoreImportFlags, handleType: VkExternalSemaphoreHandleTypeFlagBits, handle: HANDLE, name: LPCWSTR): VkImportSemaphoreWin32HandleInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.semaphore = semaphore
+  result.flags = flags
+  result.handleType = handleType
+  result.handle = handle
+  result.name = name
+
+proc newVkExportSemaphoreWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, pAttributes: ptr SECURITY_ATTRIBUTES, dwAccess: DWORD, name: LPCWSTR): VkExportSemaphoreWin32HandleInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.pAttributes = pAttributes
+  result.dwAccess = dwAccess
+  result.name = name
+
+proc newVkD3D12FenceSubmitInfoKHR*(sType: VkStructureType, pNext: pointer = nil, waitSemaphoreValuesCount: uint32, pWaitSemaphoreValues: ptr uint64, signalSemaphoreValuesCount: uint32, pSignalSemaphoreValues: ptr uint64): VkD3D12FenceSubmitInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.waitSemaphoreValuesCount = waitSemaphoreValuesCount
+  result.pWaitSemaphoreValues = pWaitSemaphoreValues
+  result.signalSemaphoreValuesCount = signalSemaphoreValuesCount
+  result.pSignalSemaphoreValues = pSignalSemaphoreValues
+
+proc newVkSemaphoreGetWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, semaphore: VkSemaphore, handleType: VkExternalSemaphoreHandleTypeFlagBits): VkSemaphoreGetWin32HandleInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.semaphore = semaphore
+  result.handleType = handleType
+
+proc newVkImportSemaphoreFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, semaphore: VkSemaphore, flags: VkSemaphoreImportFlags = 0.VkSemaphoreImportFlags, handleType: VkExternalSemaphoreHandleTypeFlagBits, fd: int): VkImportSemaphoreFdInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.semaphore = semaphore
+  result.flags = flags
+  result.handleType = handleType
+  result.fd = fd
+
+proc newVkSemaphoreGetFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, semaphore: VkSemaphore, handleType: VkExternalSemaphoreHandleTypeFlagBits): VkSemaphoreGetFdInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.semaphore = semaphore
+  result.handleType = handleType
+
+proc newVkPhysicalDeviceExternalFenceInfo*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalFenceHandleTypeFlagBits): VkPhysicalDeviceExternalFenceInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleType = handleType
+
+proc newVkExternalFenceProperties*(sType: VkStructureType, pNext: pointer = nil, exportFromImportedHandleTypes: VkExternalFenceHandleTypeFlags, compatibleHandleTypes: VkExternalFenceHandleTypeFlags, externalFenceFeatures: VkExternalFenceFeatureFlags): VkExternalFenceProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.exportFromImportedHandleTypes = exportFromImportedHandleTypes
+  result.compatibleHandleTypes = compatibleHandleTypes
+  result.externalFenceFeatures = externalFenceFeatures
+
+proc newVkExportFenceCreateInfo*(sType: VkStructureType, pNext: pointer = nil, handleTypes: VkExternalFenceHandleTypeFlags): VkExportFenceCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleTypes = handleTypes
+
+proc newVkImportFenceWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, fence: VkFence, flags: VkFenceImportFlags = 0.VkFenceImportFlags, handleType: VkExternalFenceHandleTypeFlagBits, handle: HANDLE, name: LPCWSTR): VkImportFenceWin32HandleInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.fence = fence
+  result.flags = flags
+  result.handleType = handleType
+  result.handle = handle
+  result.name = name
+
+proc newVkExportFenceWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, pAttributes: ptr SECURITY_ATTRIBUTES, dwAccess: DWORD, name: LPCWSTR): VkExportFenceWin32HandleInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.pAttributes = pAttributes
+  result.dwAccess = dwAccess
+  result.name = name
+
+proc newVkFenceGetWin32HandleInfoKHR*(sType: VkStructureType, pNext: pointer = nil, fence: VkFence, handleType: VkExternalFenceHandleTypeFlagBits): VkFenceGetWin32HandleInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.fence = fence
+  result.handleType = handleType
+
+proc newVkImportFenceFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, fence: VkFence, flags: VkFenceImportFlags = 0.VkFenceImportFlags, handleType: VkExternalFenceHandleTypeFlagBits, fd: int): VkImportFenceFdInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.fence = fence
+  result.flags = flags
+  result.handleType = handleType
+  result.fd = fd
+
+proc newVkFenceGetFdInfoKHR*(sType: VkStructureType, pNext: pointer = nil, fence: VkFence, handleType: VkExternalFenceHandleTypeFlagBits): VkFenceGetFdInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.fence = fence
+  result.handleType = handleType
+
+proc newVkPhysicalDeviceMultiviewFeatures*(sType: VkStructureType, pNext: pointer = nil, multiview: VkBool32, multiviewGeometryShader: VkBool32, multiviewTessellationShader: VkBool32): VkPhysicalDeviceMultiviewFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.multiview = multiview
+  result.multiviewGeometryShader = multiviewGeometryShader
+  result.multiviewTessellationShader = multiviewTessellationShader
+
+proc newVkPhysicalDeviceMultiviewProperties*(sType: VkStructureType, pNext: pointer = nil, maxMultiviewViewCount: uint32, maxMultiviewInstanceIndex: uint32): VkPhysicalDeviceMultiviewProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxMultiviewViewCount = maxMultiviewViewCount
+  result.maxMultiviewInstanceIndex = maxMultiviewInstanceIndex
+
+proc newVkRenderPassMultiviewCreateInfo*(sType: VkStructureType, pNext: pointer = nil, subpassCount: uint32, pViewMasks: ptr uint32, dependencyCount: uint32, pViewOffsets: ptr int32, correlationMaskCount: uint32, pCorrelationMasks: ptr uint32): VkRenderPassMultiviewCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.subpassCount = subpassCount
+  result.pViewMasks = pViewMasks
+  result.dependencyCount = dependencyCount
+  result.pViewOffsets = pViewOffsets
+  result.correlationMaskCount = correlationMaskCount
+  result.pCorrelationMasks = pCorrelationMasks
+
+proc newVkSurfaceCapabilities2EXT*(sType: VkStructureType, pNext: pointer = nil, minImageCount: uint32, maxImageCount: uint32, currentExtent: VkExtent2D, minImageExtent: VkExtent2D, maxImageExtent: VkExtent2D, maxImageArrayLayers: uint32, supportedTransforms: VkSurfaceTransformFlagsKHR, currentTransform: VkSurfaceTransformFlagBitsKHR, supportedCompositeAlpha: VkCompositeAlphaFlagsKHR, supportedUsageFlags: VkImageUsageFlags, supportedSurfaceCounters: VkSurfaceCounterFlagsEXT): VkSurfaceCapabilities2EXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.minImageCount = minImageCount
+  result.maxImageCount = maxImageCount
+  result.currentExtent = currentExtent
+  result.minImageExtent = minImageExtent
+  result.maxImageExtent = maxImageExtent
+  result.maxImageArrayLayers = maxImageArrayLayers
+  result.supportedTransforms = supportedTransforms
+  result.currentTransform = currentTransform
+  result.supportedCompositeAlpha = supportedCompositeAlpha
+  result.supportedUsageFlags = supportedUsageFlags
+  result.supportedSurfaceCounters = supportedSurfaceCounters
+
+proc newVkDisplayPowerInfoEXT*(sType: VkStructureType, pNext: pointer = nil, powerState: VkDisplayPowerStateEXT): VkDisplayPowerInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.powerState = powerState
+
+proc newVkDeviceEventInfoEXT*(sType: VkStructureType, pNext: pointer = nil, deviceEvent: VkDeviceEventTypeEXT): VkDeviceEventInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceEvent = deviceEvent
+
+proc newVkDisplayEventInfoEXT*(sType: VkStructureType, pNext: pointer = nil, displayEvent: VkDisplayEventTypeEXT): VkDisplayEventInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.displayEvent = displayEvent
+
+proc newVkSwapchainCounterCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, surfaceCounters: VkSurfaceCounterFlagsEXT): VkSwapchainCounterCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.surfaceCounters = surfaceCounters
+
+proc newVkPhysicalDeviceGroupProperties*(sType: VkStructureType, pNext: pointer = nil, physicalDeviceCount: uint32, physicalDevices: array[VK_MAX_DEVICE_GROUP_SIZE, VkPhysicalDevice], subsetAllocation: VkBool32): VkPhysicalDeviceGroupProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.physicalDeviceCount = physicalDeviceCount
+  result.physicalDevices = physicalDevices
+  result.subsetAllocation = subsetAllocation
+
+proc newVkMemoryAllocateFlagsInfo*(sType: VkStructureType, pNext: pointer = nil, flags: VkMemoryAllocateFlags = 0.VkMemoryAllocateFlags, deviceMask: uint32): VkMemoryAllocateFlagsInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.deviceMask = deviceMask
+
+proc newVkBindBufferMemoryInfo*(sType: VkStructureType, pNext: pointer = nil, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkBindBufferMemoryInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.buffer = buffer
+  result.memory = memory
+  result.memoryOffset = memoryOffset
+
+proc newVkBindBufferMemoryDeviceGroupInfo*(sType: VkStructureType, pNext: pointer = nil, deviceIndexCount: uint32, pDeviceIndices: ptr uint32): VkBindBufferMemoryDeviceGroupInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceIndexCount = deviceIndexCount
+  result.pDeviceIndices = pDeviceIndices
+
+proc newVkBindImageMemoryInfo*(sType: VkStructureType, pNext: pointer = nil, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize): VkBindImageMemoryInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.image = image
+  result.memory = memory
+  result.memoryOffset = memoryOffset
+
+proc newVkBindImageMemoryDeviceGroupInfo*(sType: VkStructureType, pNext: pointer = nil, deviceIndexCount: uint32, pDeviceIndices: ptr uint32, splitInstanceBindRegionCount: uint32, pSplitInstanceBindRegions: ptr VkRect2D): VkBindImageMemoryDeviceGroupInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceIndexCount = deviceIndexCount
+  result.pDeviceIndices = pDeviceIndices
+  result.splitInstanceBindRegionCount = splitInstanceBindRegionCount
+  result.pSplitInstanceBindRegions = pSplitInstanceBindRegions
+
+proc newVkDeviceGroupRenderPassBeginInfo*(sType: VkStructureType, pNext: pointer = nil, deviceMask: uint32, deviceRenderAreaCount: uint32, pDeviceRenderAreas: ptr VkRect2D): VkDeviceGroupRenderPassBeginInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceMask = deviceMask
+  result.deviceRenderAreaCount = deviceRenderAreaCount
+  result.pDeviceRenderAreas = pDeviceRenderAreas
+
+proc newVkDeviceGroupCommandBufferBeginInfo*(sType: VkStructureType, pNext: pointer = nil, deviceMask: uint32): VkDeviceGroupCommandBufferBeginInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceMask = deviceMask
+
+proc newVkDeviceGroupSubmitInfo*(sType: VkStructureType, pNext: pointer = nil, waitSemaphoreCount: uint32, pWaitSemaphoreDeviceIndices: ptr uint32, commandBufferCount: uint32, pCommandBufferDeviceMasks: ptr uint32, signalSemaphoreCount: uint32, pSignalSemaphoreDeviceIndices: ptr uint32): VkDeviceGroupSubmitInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.waitSemaphoreCount = waitSemaphoreCount
+  result.pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices
+  result.commandBufferCount = commandBufferCount
+  result.pCommandBufferDeviceMasks = pCommandBufferDeviceMasks
+  result.signalSemaphoreCount = signalSemaphoreCount
+  result.pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices
+
+proc newVkDeviceGroupBindSparseInfo*(sType: VkStructureType, pNext: pointer = nil, resourceDeviceIndex: uint32, memoryDeviceIndex: uint32): VkDeviceGroupBindSparseInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.resourceDeviceIndex = resourceDeviceIndex
+  result.memoryDeviceIndex = memoryDeviceIndex
+
+proc newVkDeviceGroupPresentCapabilitiesKHR*(sType: VkStructureType, pNext: pointer = nil, presentMask: array[VK_MAX_DEVICE_GROUP_SIZE, uint32], modes: VkDeviceGroupPresentModeFlagsKHR): VkDeviceGroupPresentCapabilitiesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.presentMask = presentMask
+  result.modes = modes
+
+proc newVkImageSwapchainCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, swapchain: VkSwapchainKHR): VkImageSwapchainCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.swapchain = swapchain
+
+proc newVkBindImageMemorySwapchainInfoKHR*(sType: VkStructureType, pNext: pointer = nil, swapchain: VkSwapchainKHR, imageIndex: uint32): VkBindImageMemorySwapchainInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.swapchain = swapchain
+  result.imageIndex = imageIndex
+
+proc newVkAcquireNextImageInfoKHR*(sType: VkStructureType, pNext: pointer = nil, swapchain: VkSwapchainKHR, timeout: uint64, semaphore: VkSemaphore, fence: VkFence, deviceMask: uint32): VkAcquireNextImageInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.swapchain = swapchain
+  result.timeout = timeout
+  result.semaphore = semaphore
+  result.fence = fence
+  result.deviceMask = deviceMask
+
+proc newVkDeviceGroupPresentInfoKHR*(sType: VkStructureType, pNext: pointer = nil, swapchainCount: uint32, pDeviceMasks: ptr uint32, mode: VkDeviceGroupPresentModeFlagBitsKHR): VkDeviceGroupPresentInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.swapchainCount = swapchainCount
+  result.pDeviceMasks = pDeviceMasks
+  result.mode = mode
+
+proc newVkDeviceGroupDeviceCreateInfo*(sType: VkStructureType, pNext: pointer = nil, physicalDeviceCount: uint32, pPhysicalDevices: ptr VkPhysicalDevice): VkDeviceGroupDeviceCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.physicalDeviceCount = physicalDeviceCount
+  result.pPhysicalDevices = pPhysicalDevices
+
+proc newVkDeviceGroupSwapchainCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, modes: VkDeviceGroupPresentModeFlagsKHR): VkDeviceGroupSwapchainCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.modes = modes
+
+proc newVkDescriptorUpdateTemplateEntry*(dstBinding: uint32, dstArrayElement: uint32, descriptorCount: uint32, descriptorType: VkDescriptorType, offset: uint, stride: uint): VkDescriptorUpdateTemplateEntry =
+  result.dstBinding = dstBinding
+  result.dstArrayElement = dstArrayElement
+  result.descriptorCount = descriptorCount
+  result.descriptorType = descriptorType
+  result.offset = offset
+  result.stride = stride
+
+proc newVkDescriptorUpdateTemplateCreateInfo*(sType: VkStructureType, pNext: pointer = nil, flags: VkDescriptorUpdateTemplateCreateFlags = 0.VkDescriptorUpdateTemplateCreateFlags, descriptorUpdateEntryCount: uint32, pDescriptorUpdateEntries: ptr VkDescriptorUpdateTemplateEntry, templateType: VkDescriptorUpdateTemplateType, descriptorSetLayout: VkDescriptorSetLayout, pipelineBindPoint: VkPipelineBindPoint, pipelineLayout: VkPipelineLayout, set: uint32): VkDescriptorUpdateTemplateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.descriptorUpdateEntryCount = descriptorUpdateEntryCount
+  result.pDescriptorUpdateEntries = pDescriptorUpdateEntries
+  result.templateType = templateType
+  result.descriptorSetLayout = descriptorSetLayout
+  result.pipelineBindPoint = pipelineBindPoint
+  result.pipelineLayout = pipelineLayout
+  result.set = set
+
+proc newVkXYColorEXT*(x: float32, y: float32): VkXYColorEXT =
+  result.x = x
+  result.y = y
+
+proc newVkHdrMetadataEXT*(sType: VkStructureType, pNext: pointer = nil, displayPrimaryRed: VkXYColorEXT, displayPrimaryGreen: VkXYColorEXT, displayPrimaryBlue: VkXYColorEXT, whitePoint: VkXYColorEXT, maxLuminance: float32, minLuminance: float32, maxContentLightLevel: float32, maxFrameAverageLightLevel: float32): VkHdrMetadataEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.displayPrimaryRed = displayPrimaryRed
+  result.displayPrimaryGreen = displayPrimaryGreen
+  result.displayPrimaryBlue = displayPrimaryBlue
+  result.whitePoint = whitePoint
+  result.maxLuminance = maxLuminance
+  result.minLuminance = minLuminance
+  result.maxContentLightLevel = maxContentLightLevel
+  result.maxFrameAverageLightLevel = maxFrameAverageLightLevel
+
+proc newVkDisplayNativeHdrSurfaceCapabilitiesAMD*(sType: VkStructureType, pNext: pointer = nil, localDimmingSupport: VkBool32): VkDisplayNativeHdrSurfaceCapabilitiesAMD =
+  result.sType = sType
+  result.pNext = pNext
+  result.localDimmingSupport = localDimmingSupport
+
+proc newVkSwapchainDisplayNativeHdrCreateInfoAMD*(sType: VkStructureType, pNext: pointer = nil, localDimmingEnable: VkBool32): VkSwapchainDisplayNativeHdrCreateInfoAMD =
+  result.sType = sType
+  result.pNext = pNext
+  result.localDimmingEnable = localDimmingEnable
+
+proc newVkRefreshCycleDurationGOOGLE*(refreshDuration: uint64): VkRefreshCycleDurationGOOGLE =
+  result.refreshDuration = refreshDuration
+
+proc newVkPastPresentationTimingGOOGLE*(presentID: uint32, desiredPresentTime: uint64, actualPresentTime: uint64, earliestPresentTime: uint64, presentMargin: uint64): VkPastPresentationTimingGOOGLE =
+  result.presentID = presentID
+  result.desiredPresentTime = desiredPresentTime
+  result.actualPresentTime = actualPresentTime
+  result.earliestPresentTime = earliestPresentTime
+  result.presentMargin = presentMargin
+
+proc newVkPresentTimesInfoGOOGLE*(sType: VkStructureType, pNext: pointer = nil, swapchainCount: uint32, pTimes: ptr VkPresentTimeGOOGLE): VkPresentTimesInfoGOOGLE =
+  result.sType = sType
+  result.pNext = pNext
+  result.swapchainCount = swapchainCount
+  result.pTimes = pTimes
+
+proc newVkPresentTimeGOOGLE*(presentID: uint32, desiredPresentTime: uint64): VkPresentTimeGOOGLE =
+  result.presentID = presentID
+  result.desiredPresentTime = desiredPresentTime
+
+proc newVkIOSSurfaceCreateInfoMVK*(sType: VkStructureType, pNext: pointer = nil, flags: VkIOSSurfaceCreateFlagsMVK = 0.VkIOSSurfaceCreateFlagsMVK, pView: pointer = nil): VkIOSSurfaceCreateInfoMVK =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.pView = pView
+
+proc newVkMacOSSurfaceCreateInfoMVK*(sType: VkStructureType, pNext: pointer = nil, flags: VkMacOSSurfaceCreateFlagsMVK = 0.VkMacOSSurfaceCreateFlagsMVK, pView: pointer = nil): VkMacOSSurfaceCreateInfoMVK =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.pView = pView
+
+proc newVkMetalSurfaceCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkMetalSurfaceCreateFlagsEXT = 0.VkMetalSurfaceCreateFlagsEXT, pLayer: ptr CAMetalLayer): VkMetalSurfaceCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.pLayer = pLayer
+
+proc newVkViewportWScalingNV*(xcoeff: float32, ycoeff: float32): VkViewportWScalingNV =
+  result.xcoeff = xcoeff
+  result.ycoeff = ycoeff
+
+proc newVkPipelineViewportWScalingStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, viewportWScalingEnable: VkBool32, viewportCount: uint32, pViewportWScalings: ptr VkViewportWScalingNV): VkPipelineViewportWScalingStateCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.viewportWScalingEnable = viewportWScalingEnable
+  result.viewportCount = viewportCount
+  result.pViewportWScalings = pViewportWScalings
+
+proc newVkViewportSwizzleNV*(x: VkViewportCoordinateSwizzleNV, y: VkViewportCoordinateSwizzleNV, z: VkViewportCoordinateSwizzleNV, w: VkViewportCoordinateSwizzleNV): VkViewportSwizzleNV =
+  result.x = x
+  result.y = y
+  result.z = z
+  result.w = w
+
+proc newVkPipelineViewportSwizzleStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineViewportSwizzleStateCreateFlagsNV = 0.VkPipelineViewportSwizzleStateCreateFlagsNV, viewportCount: uint32, pViewportSwizzles: ptr VkViewportSwizzleNV): VkPipelineViewportSwizzleStateCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.viewportCount = viewportCount
+  result.pViewportSwizzles = pViewportSwizzles
+
+proc newVkPhysicalDeviceDiscardRectanglePropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxDiscardRectangles: uint32): VkPhysicalDeviceDiscardRectanglePropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxDiscardRectangles = maxDiscardRectangles
+
+proc newVkPipelineDiscardRectangleStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineDiscardRectangleStateCreateFlagsEXT = 0.VkPipelineDiscardRectangleStateCreateFlagsEXT, discardRectangleMode: VkDiscardRectangleModeEXT, discardRectangleCount: uint32, pDiscardRectangles: ptr VkRect2D): VkPipelineDiscardRectangleStateCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.discardRectangleMode = discardRectangleMode
+  result.discardRectangleCount = discardRectangleCount
+  result.pDiscardRectangles = pDiscardRectangles
+
+proc newVkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*(sType: VkStructureType, pNext: pointer = nil, perViewPositionAllComponents: VkBool32): VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX =
+  result.sType = sType
+  result.pNext = pNext
+  result.perViewPositionAllComponents = perViewPositionAllComponents
+
+proc newVkInputAttachmentAspectReference*(subpass: uint32, inputAttachmentIndex: uint32, aspectMask: VkImageAspectFlags): VkInputAttachmentAspectReference =
+  result.subpass = subpass
+  result.inputAttachmentIndex = inputAttachmentIndex
+  result.aspectMask = aspectMask
+
+proc newVkRenderPassInputAttachmentAspectCreateInfo*(sType: VkStructureType, pNext: pointer = nil, aspectReferenceCount: uint32, pAspectReferences: ptr VkInputAttachmentAspectReference): VkRenderPassInputAttachmentAspectCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.aspectReferenceCount = aspectReferenceCount
+  result.pAspectReferences = pAspectReferences
+
+proc newVkPhysicalDeviceSurfaceInfo2KHR*(sType: VkStructureType, pNext: pointer = nil, surface: VkSurfaceKHR): VkPhysicalDeviceSurfaceInfo2KHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.surface = surface
+
+proc newVkSurfaceCapabilities2KHR*(sType: VkStructureType, pNext: pointer = nil, surfaceCapabilities: VkSurfaceCapabilitiesKHR): VkSurfaceCapabilities2KHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.surfaceCapabilities = surfaceCapabilities
+
+proc newVkSurfaceFormat2KHR*(sType: VkStructureType, pNext: pointer = nil, surfaceFormat: VkSurfaceFormatKHR): VkSurfaceFormat2KHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.surfaceFormat = surfaceFormat
+
+proc newVkDisplayProperties2KHR*(sType: VkStructureType, pNext: pointer = nil, displayProperties: VkDisplayPropertiesKHR): VkDisplayProperties2KHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.displayProperties = displayProperties
+
+proc newVkDisplayPlaneProperties2KHR*(sType: VkStructureType, pNext: pointer = nil, displayPlaneProperties: VkDisplayPlanePropertiesKHR): VkDisplayPlaneProperties2KHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.displayPlaneProperties = displayPlaneProperties
+
+proc newVkDisplayModeProperties2KHR*(sType: VkStructureType, pNext: pointer = nil, displayModeProperties: VkDisplayModePropertiesKHR): VkDisplayModeProperties2KHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.displayModeProperties = displayModeProperties
+
+proc newVkDisplayPlaneInfo2KHR*(sType: VkStructureType, pNext: pointer = nil, mode: VkDisplayModeKHR, planeIndex: uint32): VkDisplayPlaneInfo2KHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.mode = mode
+  result.planeIndex = planeIndex
+
+proc newVkDisplayPlaneCapabilities2KHR*(sType: VkStructureType, pNext: pointer = nil, capabilities: VkDisplayPlaneCapabilitiesKHR): VkDisplayPlaneCapabilities2KHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.capabilities = capabilities
+
+proc newVkSharedPresentSurfaceCapabilitiesKHR*(sType: VkStructureType, pNext: pointer = nil, sharedPresentSupportedUsageFlags: VkImageUsageFlags): VkSharedPresentSurfaceCapabilitiesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.sharedPresentSupportedUsageFlags = sharedPresentSupportedUsageFlags
+
+proc newVkPhysicalDevice16BitStorageFeatures*(sType: VkStructureType, pNext: pointer = nil, storageBuffer16BitAccess: VkBool32, uniformAndStorageBuffer16BitAccess: VkBool32, storagePushConstant16: VkBool32, storageInputOutput16: VkBool32): VkPhysicalDevice16BitStorageFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.storageBuffer16BitAccess = storageBuffer16BitAccess
+  result.uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess
+  result.storagePushConstant16 = storagePushConstant16
+  result.storageInputOutput16 = storageInputOutput16
+
+proc newVkPhysicalDeviceSubgroupProperties*(sType: VkStructureType, pNext: pointer = nil, subgroupSize: uint32, supportedStages: VkShaderStageFlags, supportedOperations: VkSubgroupFeatureFlags, quadOperationsInAllStages: VkBool32): VkPhysicalDeviceSubgroupProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.subgroupSize = subgroupSize
+  result.supportedStages = supportedStages
+  result.supportedOperations = supportedOperations
+  result.quadOperationsInAllStages = quadOperationsInAllStages
+
+proc newVkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*(sType: VkStructureType, pNext: pointer = nil, shaderSubgroupExtendedTypes: VkBool32): VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes
+
+proc newVkBufferMemoryRequirementsInfo2*(sType: VkStructureType, pNext: pointer = nil, buffer: VkBuffer): VkBufferMemoryRequirementsInfo2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.buffer = buffer
+
+proc newVkImageMemoryRequirementsInfo2*(sType: VkStructureType, pNext: pointer = nil, image: VkImage): VkImageMemoryRequirementsInfo2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.image = image
+
+proc newVkImageSparseMemoryRequirementsInfo2*(sType: VkStructureType, pNext: pointer = nil, image: VkImage): VkImageSparseMemoryRequirementsInfo2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.image = image
+
+proc newVkMemoryRequirements2*(sType: VkStructureType, pNext: pointer = nil, memoryRequirements: VkMemoryRequirements): VkMemoryRequirements2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.memoryRequirements = memoryRequirements
+
+proc newVkSparseImageMemoryRequirements2*(sType: VkStructureType, pNext: pointer = nil, memoryRequirements: VkSparseImageMemoryRequirements): VkSparseImageMemoryRequirements2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.memoryRequirements = memoryRequirements
+
+proc newVkPhysicalDevicePointClippingProperties*(sType: VkStructureType, pNext: pointer = nil, pointClippingBehavior: VkPointClippingBehavior): VkPhysicalDevicePointClippingProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.pointClippingBehavior = pointClippingBehavior
+
+proc newVkMemoryDedicatedRequirements*(sType: VkStructureType, pNext: pointer = nil, prefersDedicatedAllocation: VkBool32, requiresDedicatedAllocation: VkBool32): VkMemoryDedicatedRequirements =
+  result.sType = sType
+  result.pNext = pNext
+  result.prefersDedicatedAllocation = prefersDedicatedAllocation
+  result.requiresDedicatedAllocation = requiresDedicatedAllocation
+
+proc newVkMemoryDedicatedAllocateInfo*(sType: VkStructureType, pNext: pointer = nil, image: VkImage, buffer: VkBuffer): VkMemoryDedicatedAllocateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.image = image
+  result.buffer = buffer
+
+proc newVkImageViewUsageCreateInfo*(sType: VkStructureType, pNext: pointer = nil, usage: VkImageUsageFlags): VkImageViewUsageCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.usage = usage
+
+proc newVkPipelineTessellationDomainOriginStateCreateInfo*(sType: VkStructureType, pNext: pointer = nil, domainOrigin: VkTessellationDomainOrigin): VkPipelineTessellationDomainOriginStateCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.domainOrigin = domainOrigin
+
+proc newVkSamplerYcbcrConversionInfo*(sType: VkStructureType, pNext: pointer = nil, conversion: VkSamplerYcbcrConversion): VkSamplerYcbcrConversionInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.conversion = conversion
+
+proc newVkSamplerYcbcrConversionCreateInfo*(sType: VkStructureType, pNext: pointer = nil, format: VkFormat, ycbcrModel: VkSamplerYcbcrModelConversion, ycbcrRange: VkSamplerYcbcrRange, components: VkComponentMapping, xChromaOffset: VkChromaLocation, yChromaOffset: VkChromaLocation, chromaFilter: VkFilter, forceExplicitReconstruction: VkBool32): VkSamplerYcbcrConversionCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.format = format
+  result.ycbcrModel = ycbcrModel
+  result.ycbcrRange = ycbcrRange
+  result.components = components
+  result.xChromaOffset = xChromaOffset
+  result.yChromaOffset = yChromaOffset
+  result.chromaFilter = chromaFilter
+  result.forceExplicitReconstruction = forceExplicitReconstruction
+
+proc newVkBindImagePlaneMemoryInfo*(sType: VkStructureType, pNext: pointer = nil, planeAspect: VkImageAspectFlagBits): VkBindImagePlaneMemoryInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.planeAspect = planeAspect
+
+proc newVkImagePlaneMemoryRequirementsInfo*(sType: VkStructureType, pNext: pointer = nil, planeAspect: VkImageAspectFlagBits): VkImagePlaneMemoryRequirementsInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.planeAspect = planeAspect
+
+proc newVkPhysicalDeviceSamplerYcbcrConversionFeatures*(sType: VkStructureType, pNext: pointer = nil, samplerYcbcrConversion: VkBool32): VkPhysicalDeviceSamplerYcbcrConversionFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.samplerYcbcrConversion = samplerYcbcrConversion
+
+proc newVkSamplerYcbcrConversionImageFormatProperties*(sType: VkStructureType, pNext: pointer = nil, combinedImageSamplerDescriptorCount: uint32): VkSamplerYcbcrConversionImageFormatProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.combinedImageSamplerDescriptorCount = combinedImageSamplerDescriptorCount
+
+proc newVkTextureLODGatherFormatPropertiesAMD*(sType: VkStructureType, pNext: pointer = nil, supportsTextureGatherLODBiasAMD: VkBool32): VkTextureLODGatherFormatPropertiesAMD =
+  result.sType = sType
+  result.pNext = pNext
+  result.supportsTextureGatherLODBiasAMD = supportsTextureGatherLODBiasAMD
+
+proc newVkConditionalRenderingBeginInfoEXT*(sType: VkStructureType, pNext: pointer = nil, buffer: VkBuffer, offset: VkDeviceSize, flags: VkConditionalRenderingFlagsEXT = 0.VkConditionalRenderingFlagsEXT): VkConditionalRenderingBeginInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.buffer = buffer
+  result.offset = offset
+  result.flags = flags
+
+proc newVkProtectedSubmitInfo*(sType: VkStructureType, pNext: pointer = nil, protectedSubmit: VkBool32): VkProtectedSubmitInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.protectedSubmit = protectedSubmit
+
+proc newVkPhysicalDeviceProtectedMemoryFeatures*(sType: VkStructureType, pNext: pointer = nil, protectedMemory: VkBool32): VkPhysicalDeviceProtectedMemoryFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.protectedMemory = protectedMemory
+
+proc newVkPhysicalDeviceProtectedMemoryProperties*(sType: VkStructureType, pNext: pointer = nil, protectedNoFault: VkBool32): VkPhysicalDeviceProtectedMemoryProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.protectedNoFault = protectedNoFault
+
+proc newVkDeviceQueueInfo2*(sType: VkStructureType, pNext: pointer = nil, flags: VkDeviceQueueCreateFlags = 0.VkDeviceQueueCreateFlags, queueFamilyIndex: uint32, queueIndex: uint32): VkDeviceQueueInfo2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.queueFamilyIndex = queueFamilyIndex
+  result.queueIndex = queueIndex
+
+proc newVkPipelineCoverageToColorStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineCoverageToColorStateCreateFlagsNV = 0.VkPipelineCoverageToColorStateCreateFlagsNV, coverageToColorEnable: VkBool32, coverageToColorLocation: uint32): VkPipelineCoverageToColorStateCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.coverageToColorEnable = coverageToColorEnable
+  result.coverageToColorLocation = coverageToColorLocation
+
+proc newVkPhysicalDeviceSamplerFilterMinmaxProperties*(sType: VkStructureType, pNext: pointer = nil, filterMinmaxSingleComponentFormats: VkBool32, filterMinmaxImageComponentMapping: VkBool32): VkPhysicalDeviceSamplerFilterMinmaxProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.filterMinmaxSingleComponentFormats = filterMinmaxSingleComponentFormats
+  result.filterMinmaxImageComponentMapping = filterMinmaxImageComponentMapping
+
+proc newVkSampleLocationEXT*(x: float32, y: float32): VkSampleLocationEXT =
+  result.x = x
+  result.y = y
+
+proc newVkSampleLocationsInfoEXT*(sType: VkStructureType, pNext: pointer = nil, sampleLocationsPerPixel: VkSampleCountFlagBits, sampleLocationGridSize: VkExtent2D, sampleLocationsCount: uint32, pSampleLocations: ptr VkSampleLocationEXT): VkSampleLocationsInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.sampleLocationsPerPixel = sampleLocationsPerPixel
+  result.sampleLocationGridSize = sampleLocationGridSize
+  result.sampleLocationsCount = sampleLocationsCount
+  result.pSampleLocations = pSampleLocations
+
+proc newVkAttachmentSampleLocationsEXT*(attachmentIndex: uint32, sampleLocationsInfo: VkSampleLocationsInfoEXT): VkAttachmentSampleLocationsEXT =
+  result.attachmentIndex = attachmentIndex
+  result.sampleLocationsInfo = sampleLocationsInfo
+
+proc newVkSubpassSampleLocationsEXT*(subpassIndex: uint32, sampleLocationsInfo: VkSampleLocationsInfoEXT): VkSubpassSampleLocationsEXT =
+  result.subpassIndex = subpassIndex
+  result.sampleLocationsInfo = sampleLocationsInfo
+
+proc newVkRenderPassSampleLocationsBeginInfoEXT*(sType: VkStructureType, pNext: pointer = nil, attachmentInitialSampleLocationsCount: uint32, pAttachmentInitialSampleLocations: ptr VkAttachmentSampleLocationsEXT, postSubpassSampleLocationsCount: uint32, pPostSubpassSampleLocations: ptr VkSubpassSampleLocationsEXT): VkRenderPassSampleLocationsBeginInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount
+  result.pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations
+  result.postSubpassSampleLocationsCount = postSubpassSampleLocationsCount
+  result.pPostSubpassSampleLocations = pPostSubpassSampleLocations
+
+proc newVkPipelineSampleLocationsStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, sampleLocationsEnable: VkBool32, sampleLocationsInfo: VkSampleLocationsInfoEXT): VkPipelineSampleLocationsStateCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.sampleLocationsEnable = sampleLocationsEnable
+  result.sampleLocationsInfo = sampleLocationsInfo
+
+proc newVkPhysicalDeviceSampleLocationsPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, sampleLocationSampleCounts: VkSampleCountFlags, maxSampleLocationGridSize: VkExtent2D, sampleLocationCoordinateRange: array[2, float32], sampleLocationSubPixelBits: uint32, variableSampleLocations: VkBool32): VkPhysicalDeviceSampleLocationsPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.sampleLocationSampleCounts = sampleLocationSampleCounts
+  result.maxSampleLocationGridSize = maxSampleLocationGridSize
+  result.sampleLocationCoordinateRange = sampleLocationCoordinateRange
+  result.sampleLocationSubPixelBits = sampleLocationSubPixelBits
+  result.variableSampleLocations = variableSampleLocations
+
+proc newVkMultisamplePropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxSampleLocationGridSize: VkExtent2D): VkMultisamplePropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxSampleLocationGridSize = maxSampleLocationGridSize
+
+proc newVkSamplerReductionModeCreateInfo*(sType: VkStructureType, pNext: pointer = nil, reductionMode: VkSamplerReductionMode): VkSamplerReductionModeCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.reductionMode = reductionMode
+
+proc newVkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, advancedBlendCoherentOperations: VkBool32): VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.advancedBlendCoherentOperations = advancedBlendCoherentOperations
+
+proc newVkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, advancedBlendMaxColorAttachments: uint32, advancedBlendIndependentBlend: VkBool32, advancedBlendNonPremultipliedSrcColor: VkBool32, advancedBlendNonPremultipliedDstColor: VkBool32, advancedBlendCorrelatedOverlap: VkBool32, advancedBlendAllOperations: VkBool32): VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.advancedBlendMaxColorAttachments = advancedBlendMaxColorAttachments
+  result.advancedBlendIndependentBlend = advancedBlendIndependentBlend
+  result.advancedBlendNonPremultipliedSrcColor = advancedBlendNonPremultipliedSrcColor
+  result.advancedBlendNonPremultipliedDstColor = advancedBlendNonPremultipliedDstColor
+  result.advancedBlendCorrelatedOverlap = advancedBlendCorrelatedOverlap
+  result.advancedBlendAllOperations = advancedBlendAllOperations
+
+proc newVkPipelineColorBlendAdvancedStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, srcPremultiplied: VkBool32, dstPremultiplied: VkBool32, blendOverlap: VkBlendOverlapEXT): VkPipelineColorBlendAdvancedStateCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.srcPremultiplied = srcPremultiplied
+  result.dstPremultiplied = dstPremultiplied
+  result.blendOverlap = blendOverlap
+
+proc newVkPhysicalDeviceInlineUniformBlockFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, inlineUniformBlock: VkBool32, descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32): VkPhysicalDeviceInlineUniformBlockFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.inlineUniformBlock = inlineUniformBlock
+  result.descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind
+
+proc newVkPhysicalDeviceInlineUniformBlockPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxInlineUniformBlockSize: uint32, maxPerStageDescriptorInlineUniformBlocks: uint32, maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: uint32, maxDescriptorSetInlineUniformBlocks: uint32, maxDescriptorSetUpdateAfterBindInlineUniformBlocks: uint32): VkPhysicalDeviceInlineUniformBlockPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxInlineUniformBlockSize = maxInlineUniformBlockSize
+  result.maxPerStageDescriptorInlineUniformBlocks = maxPerStageDescriptorInlineUniformBlocks
+  result.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks
+  result.maxDescriptorSetInlineUniformBlocks = maxDescriptorSetInlineUniformBlocks
+  result.maxDescriptorSetUpdateAfterBindInlineUniformBlocks = maxDescriptorSetUpdateAfterBindInlineUniformBlocks
+
+proc newVkWriteDescriptorSetInlineUniformBlockEXT*(sType: VkStructureType, pNext: pointer = nil, dataSize: uint32, pData: pointer = nil): VkWriteDescriptorSetInlineUniformBlockEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.dataSize = dataSize
+  result.pData = pData
+
+proc newVkDescriptorPoolInlineUniformBlockCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, maxInlineUniformBlockBindings: uint32): VkDescriptorPoolInlineUniformBlockCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxInlineUniformBlockBindings = maxInlineUniformBlockBindings
+
+proc newVkPipelineCoverageModulationStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineCoverageModulationStateCreateFlagsNV = 0.VkPipelineCoverageModulationStateCreateFlagsNV, coverageModulationMode: VkCoverageModulationModeNV, coverageModulationTableEnable: VkBool32, coverageModulationTableCount: uint32, pCoverageModulationTable: ptr float32): VkPipelineCoverageModulationStateCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.coverageModulationMode = coverageModulationMode
+  result.coverageModulationTableEnable = coverageModulationTableEnable
+  result.coverageModulationTableCount = coverageModulationTableCount
+  result.pCoverageModulationTable = pCoverageModulationTable
+
+proc newVkImageFormatListCreateInfo*(sType: VkStructureType, pNext: pointer = nil, viewFormatCount: uint32, pViewFormats: ptr VkFormat): VkImageFormatListCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.viewFormatCount = viewFormatCount
+  result.pViewFormats = pViewFormats
+
+proc newVkValidationCacheCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkValidationCacheCreateFlagsEXT = 0.VkValidationCacheCreateFlagsEXT, initialDataSize: uint, pInitialData: pointer = nil): VkValidationCacheCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.initialDataSize = initialDataSize
+  result.pInitialData = pInitialData
+
+proc newVkShaderModuleValidationCacheCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, validationCache: VkValidationCacheEXT): VkShaderModuleValidationCacheCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.validationCache = validationCache
+
+proc newVkPhysicalDeviceMaintenance3Properties*(sType: VkStructureType, pNext: pointer = nil, maxPerSetDescriptors: uint32, maxMemoryAllocationSize: VkDeviceSize): VkPhysicalDeviceMaintenance3Properties =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxPerSetDescriptors = maxPerSetDescriptors
+  result.maxMemoryAllocationSize = maxMemoryAllocationSize
+
+proc newVkDescriptorSetLayoutSupport*(sType: VkStructureType, pNext: pointer = nil, supported: VkBool32): VkDescriptorSetLayoutSupport =
+  result.sType = sType
+  result.pNext = pNext
+  result.supported = supported
+
+proc newVkPhysicalDeviceShaderDrawParametersFeatures*(sType: VkStructureType, pNext: pointer = nil, shaderDrawParameters: VkBool32): VkPhysicalDeviceShaderDrawParametersFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderDrawParameters = shaderDrawParameters
+
+proc newVkPhysicalDeviceShaderFloat16Int8Features*(sType: VkStructureType, pNext: pointer = nil, shaderFloat16: VkBool32, shaderInt8: VkBool32): VkPhysicalDeviceShaderFloat16Int8Features =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderFloat16 = shaderFloat16
+  result.shaderInt8 = shaderInt8
+
+proc newVkPhysicalDeviceFloatControlsProperties*(sType: VkStructureType, pNext: pointer = nil, 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): VkPhysicalDeviceFloatControlsProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.denormBehaviorIndependence = denormBehaviorIndependence
+  result.roundingModeIndependence = roundingModeIndependence
+  result.shaderSignedZeroInfNanPreserveFloat16 = shaderSignedZeroInfNanPreserveFloat16
+  result.shaderSignedZeroInfNanPreserveFloat32 = shaderSignedZeroInfNanPreserveFloat32
+  result.shaderSignedZeroInfNanPreserveFloat64 = shaderSignedZeroInfNanPreserveFloat64
+  result.shaderDenormPreserveFloat16 = shaderDenormPreserveFloat16
+  result.shaderDenormPreserveFloat32 = shaderDenormPreserveFloat32
+  result.shaderDenormPreserveFloat64 = shaderDenormPreserveFloat64
+  result.shaderDenormFlushToZeroFloat16 = shaderDenormFlushToZeroFloat16
+  result.shaderDenormFlushToZeroFloat32 = shaderDenormFlushToZeroFloat32
+  result.shaderDenormFlushToZeroFloat64 = shaderDenormFlushToZeroFloat64
+  result.shaderRoundingModeRTEFloat16 = shaderRoundingModeRTEFloat16
+  result.shaderRoundingModeRTEFloat32 = shaderRoundingModeRTEFloat32
+  result.shaderRoundingModeRTEFloat64 = shaderRoundingModeRTEFloat64
+  result.shaderRoundingModeRTZFloat16 = shaderRoundingModeRTZFloat16
+  result.shaderRoundingModeRTZFloat32 = shaderRoundingModeRTZFloat32
+  result.shaderRoundingModeRTZFloat64 = shaderRoundingModeRTZFloat64
+
+proc newVkPhysicalDeviceHostQueryResetFeatures*(sType: VkStructureType, pNext: pointer = nil, hostQueryReset: VkBool32): VkPhysicalDeviceHostQueryResetFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.hostQueryReset = hostQueryReset
+
+proc newVkNativeBufferUsage2ANDROID*(consumer: uint64, producer: uint64): VkNativeBufferUsage2ANDROID =
+  result.consumer = consumer
+  result.producer = producer
+
+proc newVkNativeBufferANDROID*(sType: VkStructureType, pNext: pointer = nil, handle: pointer = nil, stride: int, format: int, usage: int, usage2: VkNativeBufferUsage2ANDROID): VkNativeBufferANDROID =
+  result.sType = sType
+  result.pNext = pNext
+  result.handle = handle
+  result.stride = stride
+  result.format = format
+  result.usage = usage
+  result.usage2 = usage2
+
+proc newVkSwapchainImageCreateInfoANDROID*(sType: VkStructureType, pNext: pointer = nil, usage: VkSwapchainImageUsageFlagsANDROID): VkSwapchainImageCreateInfoANDROID =
+  result.sType = sType
+  result.pNext = pNext
+  result.usage = usage
+
+proc newVkPhysicalDevicePresentationPropertiesANDROID*(sType: VkStructureType, pNext: pointer = nil, sharedImage: VkBool32): VkPhysicalDevicePresentationPropertiesANDROID =
+  result.sType = sType
+  result.pNext = pNext
+  result.sharedImage = sharedImage
+
+proc newVkShaderResourceUsageAMD*(numUsedVgprs: uint32, numUsedSgprs: uint32, ldsSizePerLocalWorkGroup: uint32, ldsUsageSizeInBytes: uint, scratchMemUsageInBytes: uint): VkShaderResourceUsageAMD =
+  result.numUsedVgprs = numUsedVgprs
+  result.numUsedSgprs = numUsedSgprs
+  result.ldsSizePerLocalWorkGroup = ldsSizePerLocalWorkGroup
+  result.ldsUsageSizeInBytes = ldsUsageSizeInBytes
+  result.scratchMemUsageInBytes = scratchMemUsageInBytes
+
+proc newVkShaderStatisticsInfoAMD*(shaderStageMask: VkShaderStageFlags, resourceUsage: VkShaderResourceUsageAMD, numPhysicalVgprs: uint32, numPhysicalSgprs: uint32, numAvailableVgprs: uint32, numAvailableSgprs: uint32, computeWorkGroupSize: array[3, uint32]): VkShaderStatisticsInfoAMD =
+  result.shaderStageMask = shaderStageMask
+  result.resourceUsage = resourceUsage
+  result.numPhysicalVgprs = numPhysicalVgprs
+  result.numPhysicalSgprs = numPhysicalSgprs
+  result.numAvailableVgprs = numAvailableVgprs
+  result.numAvailableSgprs = numAvailableSgprs
+  result.computeWorkGroupSize = computeWorkGroupSize
+
+proc newVkDeviceQueueGlobalPriorityCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, globalPriority: VkQueueGlobalPriorityEXT): VkDeviceQueueGlobalPriorityCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.globalPriority = globalPriority
+
+proc newVkDebugUtilsObjectNameInfoEXT*(sType: VkStructureType, pNext: pointer = nil, objectType: VkObjectType, objectHandle: uint64, pObjectName: cstring): VkDebugUtilsObjectNameInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.objectType = objectType
+  result.objectHandle = objectHandle
+  result.pObjectName = pObjectName
+
+proc newVkDebugUtilsObjectTagInfoEXT*(sType: VkStructureType, pNext: pointer = nil, objectType: VkObjectType, objectHandle: uint64, tagName: uint64, tagSize: uint, pTag: pointer = nil): VkDebugUtilsObjectTagInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.objectType = objectType
+  result.objectHandle = objectHandle
+  result.tagName = tagName
+  result.tagSize = tagSize
+  result.pTag = pTag
+
+proc newVkDebugUtilsLabelEXT*(sType: VkStructureType, pNext: pointer = nil, pLabelName: cstring, color: array[4, float32]): VkDebugUtilsLabelEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.pLabelName = pLabelName
+  result.color = color
+
+proc newVkDebugUtilsMessengerCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkDebugUtilsMessengerCreateFlagsEXT = 0.VkDebugUtilsMessengerCreateFlagsEXT, messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT, messageType: VkDebugUtilsMessageTypeFlagsEXT, pfnUserCallback: PFN_vkDebugUtilsMessengerCallbackEXT, pUserData: pointer = nil): VkDebugUtilsMessengerCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.messageSeverity = messageSeverity
+  result.messageType = messageType
+  result.pfnUserCallback = pfnUserCallback
+  result.pUserData = pUserData
+
+proc newVkDebugUtilsMessengerCallbackDataEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkDebugUtilsMessengerCallbackDataFlagsEXT = 0.VkDebugUtilsMessengerCallbackDataFlagsEXT, pMessageIdName: cstring, messageIdNumber: int32, pMessage: cstring, queueLabelCount: uint32, pQueueLabels: ptr VkDebugUtilsLabelEXT, cmdBufLabelCount: uint32, pCmdBufLabels: ptr VkDebugUtilsLabelEXT, objectCount: uint32, pObjects: ptr VkDebugUtilsObjectNameInfoEXT): VkDebugUtilsMessengerCallbackDataEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.pMessageIdName = pMessageIdName
+  result.messageIdNumber = messageIdNumber
+  result.pMessage = pMessage
+  result.queueLabelCount = queueLabelCount
+  result.pQueueLabels = pQueueLabels
+  result.cmdBufLabelCount = cmdBufLabelCount
+  result.pCmdBufLabels = pCmdBufLabels
+  result.objectCount = objectCount
+  result.pObjects = pObjects
+
+proc newVkImportMemoryHostPointerInfoEXT*(sType: VkStructureType, pNext: pointer = nil, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: pointer = nil): VkImportMemoryHostPointerInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.handleType = handleType
+  result.pHostPointer = pHostPointer
+
+proc newVkMemoryHostPointerPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, memoryTypeBits: uint32): VkMemoryHostPointerPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.memoryTypeBits = memoryTypeBits
+
+proc newVkPhysicalDeviceExternalMemoryHostPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, minImportedHostPointerAlignment: VkDeviceSize): VkPhysicalDeviceExternalMemoryHostPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.minImportedHostPointerAlignment = minImportedHostPointerAlignment
+
+proc newVkPhysicalDeviceConservativeRasterizationPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, primitiveOverestimationSize: float32, maxExtraPrimitiveOverestimationSize: float32, extraPrimitiveOverestimationSizeGranularity: float32, primitiveUnderestimation: VkBool32, conservativePointAndLineRasterization: VkBool32, degenerateTrianglesRasterized: VkBool32, degenerateLinesRasterized: VkBool32, fullyCoveredFragmentShaderInputVariable: VkBool32, conservativeRasterizationPostDepthCoverage: VkBool32): VkPhysicalDeviceConservativeRasterizationPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.primitiveOverestimationSize = primitiveOverestimationSize
+  result.maxExtraPrimitiveOverestimationSize = maxExtraPrimitiveOverestimationSize
+  result.extraPrimitiveOverestimationSizeGranularity = extraPrimitiveOverestimationSizeGranularity
+  result.primitiveUnderestimation = primitiveUnderestimation
+  result.conservativePointAndLineRasterization = conservativePointAndLineRasterization
+  result.degenerateTrianglesRasterized = degenerateTrianglesRasterized
+  result.degenerateLinesRasterized = degenerateLinesRasterized
+  result.fullyCoveredFragmentShaderInputVariable = fullyCoveredFragmentShaderInputVariable
+  result.conservativeRasterizationPostDepthCoverage = conservativeRasterizationPostDepthCoverage
+
+proc newVkCalibratedTimestampInfoEXT*(sType: VkStructureType, pNext: pointer = nil, timeDomain: VkTimeDomainEXT): VkCalibratedTimestampInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.timeDomain = timeDomain
+
+proc newVkPhysicalDeviceShaderCorePropertiesAMD*(sType: VkStructureType, pNext: pointer = nil, 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): VkPhysicalDeviceShaderCorePropertiesAMD =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderEngineCount = shaderEngineCount
+  result.shaderArraysPerEngineCount = shaderArraysPerEngineCount
+  result.computeUnitsPerShaderArray = computeUnitsPerShaderArray
+  result.simdPerComputeUnit = simdPerComputeUnit
+  result.wavefrontsPerSimd = wavefrontsPerSimd
+  result.wavefrontSize = wavefrontSize
+  result.sgprsPerSimd = sgprsPerSimd
+  result.minSgprAllocation = minSgprAllocation
+  result.maxSgprAllocation = maxSgprAllocation
+  result.sgprAllocationGranularity = sgprAllocationGranularity
+  result.vgprsPerSimd = vgprsPerSimd
+  result.minVgprAllocation = minVgprAllocation
+  result.maxVgprAllocation = maxVgprAllocation
+  result.vgprAllocationGranularity = vgprAllocationGranularity
+
+proc newVkPhysicalDeviceShaderCoreProperties2AMD*(sType: VkStructureType, pNext: pointer = nil, shaderCoreFeatures: VkShaderCorePropertiesFlagsAMD, activeComputeUnitCount: uint32): VkPhysicalDeviceShaderCoreProperties2AMD =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderCoreFeatures = shaderCoreFeatures
+  result.activeComputeUnitCount = activeComputeUnitCount
+
+proc newVkPipelineRasterizationConservativeStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineRasterizationConservativeStateCreateFlagsEXT = 0.VkPipelineRasterizationConservativeStateCreateFlagsEXT, conservativeRasterizationMode: VkConservativeRasterizationModeEXT, extraPrimitiveOverestimationSize: float32): VkPipelineRasterizationConservativeStateCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.conservativeRasterizationMode = conservativeRasterizationMode
+  result.extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize
+
+proc newVkPhysicalDeviceDescriptorIndexingFeatures*(sType: VkStructureType, pNext: pointer = nil, 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): VkPhysicalDeviceDescriptorIndexingFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing
+  result.shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing
+  result.shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing
+  result.shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing
+  result.shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing
+  result.shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing
+  result.shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing
+  result.shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing
+  result.shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing
+  result.shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing
+  result.descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind
+  result.descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind
+  result.descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind
+  result.descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind
+  result.descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind
+  result.descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind
+  result.descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending
+  result.descriptorBindingPartiallyBound = descriptorBindingPartiallyBound
+  result.descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount
+  result.runtimeDescriptorArray = runtimeDescriptorArray
+
+proc newVkPhysicalDeviceDescriptorIndexingProperties*(sType: VkStructureType, pNext: pointer = nil, 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): VkPhysicalDeviceDescriptorIndexingProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxUpdateAfterBindDescriptorsInAllPools = maxUpdateAfterBindDescriptorsInAllPools
+  result.shaderUniformBufferArrayNonUniformIndexingNative = shaderUniformBufferArrayNonUniformIndexingNative
+  result.shaderSampledImageArrayNonUniformIndexingNative = shaderSampledImageArrayNonUniformIndexingNative
+  result.shaderStorageBufferArrayNonUniformIndexingNative = shaderStorageBufferArrayNonUniformIndexingNative
+  result.shaderStorageImageArrayNonUniformIndexingNative = shaderStorageImageArrayNonUniformIndexingNative
+  result.shaderInputAttachmentArrayNonUniformIndexingNative = shaderInputAttachmentArrayNonUniformIndexingNative
+  result.robustBufferAccessUpdateAfterBind = robustBufferAccessUpdateAfterBind
+  result.quadDivergentImplicitLod = quadDivergentImplicitLod
+  result.maxPerStageDescriptorUpdateAfterBindSamplers = maxPerStageDescriptorUpdateAfterBindSamplers
+  result.maxPerStageDescriptorUpdateAfterBindUniformBuffers = maxPerStageDescriptorUpdateAfterBindUniformBuffers
+  result.maxPerStageDescriptorUpdateAfterBindStorageBuffers = maxPerStageDescriptorUpdateAfterBindStorageBuffers
+  result.maxPerStageDescriptorUpdateAfterBindSampledImages = maxPerStageDescriptorUpdateAfterBindSampledImages
+  result.maxPerStageDescriptorUpdateAfterBindStorageImages = maxPerStageDescriptorUpdateAfterBindStorageImages
+  result.maxPerStageDescriptorUpdateAfterBindInputAttachments = maxPerStageDescriptorUpdateAfterBindInputAttachments
+  result.maxPerStageUpdateAfterBindResources = maxPerStageUpdateAfterBindResources
+  result.maxDescriptorSetUpdateAfterBindSamplers = maxDescriptorSetUpdateAfterBindSamplers
+  result.maxDescriptorSetUpdateAfterBindUniformBuffers = maxDescriptorSetUpdateAfterBindUniformBuffers
+  result.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = maxDescriptorSetUpdateAfterBindUniformBuffersDynamic
+  result.maxDescriptorSetUpdateAfterBindStorageBuffers = maxDescriptorSetUpdateAfterBindStorageBuffers
+  result.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = maxDescriptorSetUpdateAfterBindStorageBuffersDynamic
+  result.maxDescriptorSetUpdateAfterBindSampledImages = maxDescriptorSetUpdateAfterBindSampledImages
+  result.maxDescriptorSetUpdateAfterBindStorageImages = maxDescriptorSetUpdateAfterBindStorageImages
+  result.maxDescriptorSetUpdateAfterBindInputAttachments = maxDescriptorSetUpdateAfterBindInputAttachments
+
+proc newVkDescriptorSetLayoutBindingFlagsCreateInfo*(sType: VkStructureType, pNext: pointer = nil, bindingCount: uint32, pBindingFlags: ptr VkDescriptorBindingFlags): VkDescriptorSetLayoutBindingFlagsCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.bindingCount = bindingCount
+  result.pBindingFlags = pBindingFlags
+
+proc newVkDescriptorSetVariableDescriptorCountAllocateInfo*(sType: VkStructureType, pNext: pointer = nil, descriptorSetCount: uint32, pDescriptorCounts: ptr uint32): VkDescriptorSetVariableDescriptorCountAllocateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.descriptorSetCount = descriptorSetCount
+  result.pDescriptorCounts = pDescriptorCounts
+
+proc newVkDescriptorSetVariableDescriptorCountLayoutSupport*(sType: VkStructureType, pNext: pointer = nil, maxVariableDescriptorCount: uint32): VkDescriptorSetVariableDescriptorCountLayoutSupport =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxVariableDescriptorCount = maxVariableDescriptorCount
+
+proc newVkAttachmentDescription2*(sType: VkStructureType, pNext: pointer = nil, flags: VkAttachmentDescriptionFlags = 0.VkAttachmentDescriptionFlags, format: VkFormat, samples: VkSampleCountFlagBits, loadOp: VkAttachmentLoadOp, storeOp: VkAttachmentStoreOp, stencilLoadOp: VkAttachmentLoadOp, stencilStoreOp: VkAttachmentStoreOp, initialLayout: VkImageLayout, finalLayout: VkImageLayout): VkAttachmentDescription2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.format = format
+  result.samples = samples
+  result.loadOp = loadOp
+  result.storeOp = storeOp
+  result.stencilLoadOp = stencilLoadOp
+  result.stencilStoreOp = stencilStoreOp
+  result.initialLayout = initialLayout
+  result.finalLayout = finalLayout
+
+proc newVkAttachmentReference2*(sType: VkStructureType, pNext: pointer = nil, attachment: uint32, layout: VkImageLayout, aspectMask: VkImageAspectFlags): VkAttachmentReference2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.attachment = attachment
+  result.layout = layout
+  result.aspectMask = aspectMask
+
+proc newVkSubpassDescription2*(sType: VkStructureType, pNext: pointer = nil, flags: VkSubpassDescriptionFlags = 0.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): VkSubpassDescription2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.pipelineBindPoint = pipelineBindPoint
+  result.viewMask = viewMask
+  result.inputAttachmentCount = inputAttachmentCount
+  result.pInputAttachments = pInputAttachments
+  result.colorAttachmentCount = colorAttachmentCount
+  result.pColorAttachments = pColorAttachments
+  result.pResolveAttachments = pResolveAttachments
+  result.pDepthStencilAttachment = pDepthStencilAttachment
+  result.preserveAttachmentCount = preserveAttachmentCount
+  result.pPreserveAttachments = pPreserveAttachments
+
+proc newVkSubpassDependency2*(sType: VkStructureType, pNext: pointer = nil, srcSubpass: uint32, dstSubpass: uint32, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, srcAccessMask: VkAccessFlags, dstAccessMask: VkAccessFlags, dependencyFlags: VkDependencyFlags, viewOffset: int32): VkSubpassDependency2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.srcSubpass = srcSubpass
+  result.dstSubpass = dstSubpass
+  result.srcStageMask = srcStageMask
+  result.dstStageMask = dstStageMask
+  result.srcAccessMask = srcAccessMask
+  result.dstAccessMask = dstAccessMask
+  result.dependencyFlags = dependencyFlags
+  result.viewOffset = viewOffset
+
+proc newVkRenderPassCreateInfo2*(sType: VkStructureType, pNext: pointer = nil, flags: VkRenderPassCreateFlags = 0.VkRenderPassCreateFlags, attachmentCount: uint32, pAttachments: ptr VkAttachmentDescription2, subpassCount: uint32, pSubpasses: ptr VkSubpassDescription2, dependencyCount: uint32, pDependencies: ptr VkSubpassDependency2, correlatedViewMaskCount: uint32, pCorrelatedViewMasks: ptr uint32): VkRenderPassCreateInfo2 =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.attachmentCount = attachmentCount
+  result.pAttachments = pAttachments
+  result.subpassCount = subpassCount
+  result.pSubpasses = pSubpasses
+  result.dependencyCount = dependencyCount
+  result.pDependencies = pDependencies
+  result.correlatedViewMaskCount = correlatedViewMaskCount
+  result.pCorrelatedViewMasks = pCorrelatedViewMasks
+
+proc newVkSubpassBeginInfo*(sType: VkStructureType, pNext: pointer = nil, contents: VkSubpassContents): VkSubpassBeginInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.contents = contents
+
+proc newVkSubpassEndInfo*(sType: VkStructureType, pNext: pointer = nil): VkSubpassEndInfo =
+  result.sType = sType
+  result.pNext = pNext
+
+proc newVkPhysicalDeviceTimelineSemaphoreFeatures*(sType: VkStructureType, pNext: pointer = nil, timelineSemaphore: VkBool32): VkPhysicalDeviceTimelineSemaphoreFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.timelineSemaphore = timelineSemaphore
+
+proc newVkPhysicalDeviceTimelineSemaphoreProperties*(sType: VkStructureType, pNext: pointer = nil, maxTimelineSemaphoreValueDifference: uint64): VkPhysicalDeviceTimelineSemaphoreProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxTimelineSemaphoreValueDifference = maxTimelineSemaphoreValueDifference
+
+proc newVkSemaphoreTypeCreateInfo*(sType: VkStructureType, pNext: pointer = nil, semaphoreType: VkSemaphoreType, initialValue: uint64): VkSemaphoreTypeCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.semaphoreType = semaphoreType
+  result.initialValue = initialValue
+
+proc newVkTimelineSemaphoreSubmitInfo*(sType: VkStructureType, pNext: pointer = nil, waitSemaphoreValueCount: uint32, pWaitSemaphoreValues: ptr uint64, signalSemaphoreValueCount: uint32, pSignalSemaphoreValues: ptr uint64): VkTimelineSemaphoreSubmitInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.waitSemaphoreValueCount = waitSemaphoreValueCount
+  result.pWaitSemaphoreValues = pWaitSemaphoreValues
+  result.signalSemaphoreValueCount = signalSemaphoreValueCount
+  result.pSignalSemaphoreValues = pSignalSemaphoreValues
+
+proc newVkSemaphoreWaitInfo*(sType: VkStructureType, pNext: pointer = nil, flags: VkSemaphoreWaitFlags = 0.VkSemaphoreWaitFlags, semaphoreCount: uint32, pSemaphores: ptr VkSemaphore, pValues: ptr uint64): VkSemaphoreWaitInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.semaphoreCount = semaphoreCount
+  result.pSemaphores = pSemaphores
+  result.pValues = pValues
+
+proc newVkSemaphoreSignalInfo*(sType: VkStructureType, pNext: pointer = nil, semaphore: VkSemaphore, value: uint64): VkSemaphoreSignalInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.semaphore = semaphore
+  result.value = value
+
+proc newVkVertexInputBindingDivisorDescriptionEXT*(binding: uint32, divisor: uint32): VkVertexInputBindingDivisorDescriptionEXT =
+  result.binding = binding
+  result.divisor = divisor
+
+proc newVkPipelineVertexInputDivisorStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, vertexBindingDivisorCount: uint32, pVertexBindingDivisors: ptr VkVertexInputBindingDivisorDescriptionEXT): VkPipelineVertexInputDivisorStateCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.vertexBindingDivisorCount = vertexBindingDivisorCount
+  result.pVertexBindingDivisors = pVertexBindingDivisors
+
+proc newVkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxVertexAttribDivisor: uint32): VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxVertexAttribDivisor = maxVertexAttribDivisor
+
+proc newVkPhysicalDevicePCIBusInfoPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, pciDomain: uint32, pciBus: uint32, pciDevice: uint32, pciFunction: uint32): VkPhysicalDevicePCIBusInfoPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.pciDomain = pciDomain
+  result.pciBus = pciBus
+  result.pciDevice = pciDevice
+  result.pciFunction = pciFunction
+
+proc newVkImportAndroidHardwareBufferInfoANDROID*(sType: VkStructureType, pNext: pointer = nil, buffer: ptr AHardwareBuffer): VkImportAndroidHardwareBufferInfoANDROID =
+  result.sType = sType
+  result.pNext = pNext
+  result.buffer = buffer
+
+proc newVkAndroidHardwareBufferUsageANDROID*(sType: VkStructureType, pNext: pointer = nil, androidHardwareBufferUsage: uint64): VkAndroidHardwareBufferUsageANDROID =
+  result.sType = sType
+  result.pNext = pNext
+  result.androidHardwareBufferUsage = androidHardwareBufferUsage
+
+proc newVkAndroidHardwareBufferPropertiesANDROID*(sType: VkStructureType, pNext: pointer = nil, allocationSize: VkDeviceSize, memoryTypeBits: uint32): VkAndroidHardwareBufferPropertiesANDROID =
+  result.sType = sType
+  result.pNext = pNext
+  result.allocationSize = allocationSize
+  result.memoryTypeBits = memoryTypeBits
+
+proc newVkMemoryGetAndroidHardwareBufferInfoANDROID*(sType: VkStructureType, pNext: pointer = nil, memory: VkDeviceMemory): VkMemoryGetAndroidHardwareBufferInfoANDROID =
+  result.sType = sType
+  result.pNext = pNext
+  result.memory = memory
+
+proc newVkAndroidHardwareBufferFormatPropertiesANDROID*(sType: VkStructureType, pNext: pointer = nil, format: VkFormat, externalFormat: uint64, formatFeatures: VkFormatFeatureFlags, samplerYcbcrConversionComponents: VkComponentMapping, suggestedYcbcrModel: VkSamplerYcbcrModelConversion, suggestedYcbcrRange: VkSamplerYcbcrRange, suggestedXChromaOffset: VkChromaLocation, suggestedYChromaOffset: VkChromaLocation): VkAndroidHardwareBufferFormatPropertiesANDROID =
+  result.sType = sType
+  result.pNext = pNext
+  result.format = format
+  result.externalFormat = externalFormat
+  result.formatFeatures = formatFeatures
+  result.samplerYcbcrConversionComponents = samplerYcbcrConversionComponents
+  result.suggestedYcbcrModel = suggestedYcbcrModel
+  result.suggestedYcbcrRange = suggestedYcbcrRange
+  result.suggestedXChromaOffset = suggestedXChromaOffset
+  result.suggestedYChromaOffset = suggestedYChromaOffset
+
+proc newVkCommandBufferInheritanceConditionalRenderingInfoEXT*(sType: VkStructureType, pNext: pointer = nil, conditionalRenderingEnable: VkBool32): VkCommandBufferInheritanceConditionalRenderingInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.conditionalRenderingEnable = conditionalRenderingEnable
+
+proc newVkExternalFormatANDROID*(sType: VkStructureType, pNext: pointer = nil, externalFormat: uint64): VkExternalFormatANDROID =
+  result.sType = sType
+  result.pNext = pNext
+  result.externalFormat = externalFormat
+
+proc newVkPhysicalDevice8BitStorageFeatures*(sType: VkStructureType, pNext: pointer = nil, storageBuffer8BitAccess: VkBool32, uniformAndStorageBuffer8BitAccess: VkBool32, storagePushConstant8: VkBool32): VkPhysicalDevice8BitStorageFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.storageBuffer8BitAccess = storageBuffer8BitAccess
+  result.uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess
+  result.storagePushConstant8 = storagePushConstant8
+
+proc newVkPhysicalDeviceConditionalRenderingFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, conditionalRendering: VkBool32, inheritedConditionalRendering: VkBool32): VkPhysicalDeviceConditionalRenderingFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.conditionalRendering = conditionalRendering
+  result.inheritedConditionalRendering = inheritedConditionalRendering
+
+proc newVkPhysicalDeviceVulkanMemoryModelFeatures*(sType: VkStructureType, pNext: pointer = nil, vulkanMemoryModel: VkBool32, vulkanMemoryModelDeviceScope: VkBool32, vulkanMemoryModelAvailabilityVisibilityChains: VkBool32): VkPhysicalDeviceVulkanMemoryModelFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.vulkanMemoryModel = vulkanMemoryModel
+  result.vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope
+  result.vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains
+
+proc newVkPhysicalDeviceShaderAtomicInt64Features*(sType: VkStructureType, pNext: pointer = nil, shaderBufferInt64Atomics: VkBool32, shaderSharedInt64Atomics: VkBool32): VkPhysicalDeviceShaderAtomicInt64Features =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderBufferInt64Atomics = shaderBufferInt64Atomics
+  result.shaderSharedInt64Atomics = shaderSharedInt64Atomics
+
+proc newVkPhysicalDeviceShaderAtomicFloatFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, shaderBufferFloat32Atomics: VkBool32, shaderBufferFloat32AtomicAdd: VkBool32, shaderBufferFloat64Atomics: VkBool32, shaderBufferFloat64AtomicAdd: VkBool32, shaderSharedFloat32Atomics: VkBool32, shaderSharedFloat32AtomicAdd: VkBool32, shaderSharedFloat64Atomics: VkBool32, shaderSharedFloat64AtomicAdd: VkBool32, shaderImageFloat32Atomics: VkBool32, shaderImageFloat32AtomicAdd: VkBool32, sparseImageFloat32Atomics: VkBool32, sparseImageFloat32AtomicAdd: VkBool32): VkPhysicalDeviceShaderAtomicFloatFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderBufferFloat32Atomics = shaderBufferFloat32Atomics
+  result.shaderBufferFloat32AtomicAdd = shaderBufferFloat32AtomicAdd
+  result.shaderBufferFloat64Atomics = shaderBufferFloat64Atomics
+  result.shaderBufferFloat64AtomicAdd = shaderBufferFloat64AtomicAdd
+  result.shaderSharedFloat32Atomics = shaderSharedFloat32Atomics
+  result.shaderSharedFloat32AtomicAdd = shaderSharedFloat32AtomicAdd
+  result.shaderSharedFloat64Atomics = shaderSharedFloat64Atomics
+  result.shaderSharedFloat64AtomicAdd = shaderSharedFloat64AtomicAdd
+  result.shaderImageFloat32Atomics = shaderImageFloat32Atomics
+  result.shaderImageFloat32AtomicAdd = shaderImageFloat32AtomicAdd
+  result.sparseImageFloat32Atomics = sparseImageFloat32Atomics
+  result.sparseImageFloat32AtomicAdd = sparseImageFloat32AtomicAdd
+
+proc newVkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, vertexAttributeInstanceRateDivisor: VkBool32, vertexAttributeInstanceRateZeroDivisor: VkBool32): VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor
+  result.vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor
+
+proc newVkQueueFamilyCheckpointPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, checkpointExecutionStageMask: VkPipelineStageFlags): VkQueueFamilyCheckpointPropertiesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.checkpointExecutionStageMask = checkpointExecutionStageMask
+
+proc newVkCheckpointDataNV*(sType: VkStructureType, pNext: pointer = nil, stage: VkPipelineStageFlagBits, pCheckpointMarker: pointer = nil): VkCheckpointDataNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.stage = stage
+  result.pCheckpointMarker = pCheckpointMarker
+
+proc newVkPhysicalDeviceDepthStencilResolveProperties*(sType: VkStructureType, pNext: pointer = nil, supportedDepthResolveModes: VkResolveModeFlags, supportedStencilResolveModes: VkResolveModeFlags, independentResolveNone: VkBool32, independentResolve: VkBool32): VkPhysicalDeviceDepthStencilResolveProperties =
+  result.sType = sType
+  result.pNext = pNext
+  result.supportedDepthResolveModes = supportedDepthResolveModes
+  result.supportedStencilResolveModes = supportedStencilResolveModes
+  result.independentResolveNone = independentResolveNone
+  result.independentResolve = independentResolve
+
+proc newVkSubpassDescriptionDepthStencilResolve*(sType: VkStructureType, pNext: pointer = nil, depthResolveMode: VkResolveModeFlagBits, stencilResolveMode: VkResolveModeFlagBits, pDepthStencilResolveAttachment: ptr VkAttachmentReference2): VkSubpassDescriptionDepthStencilResolve =
+  result.sType = sType
+  result.pNext = pNext
+  result.depthResolveMode = depthResolveMode
+  result.stencilResolveMode = stencilResolveMode
+  result.pDepthStencilResolveAttachment = pDepthStencilResolveAttachment
+
+proc newVkImageViewASTCDecodeModeEXT*(sType: VkStructureType, pNext: pointer = nil, decodeMode: VkFormat): VkImageViewASTCDecodeModeEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.decodeMode = decodeMode
+
+proc newVkPhysicalDeviceASTCDecodeFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, decodeModeSharedExponent: VkBool32): VkPhysicalDeviceASTCDecodeFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.decodeModeSharedExponent = decodeModeSharedExponent
+
+proc newVkPhysicalDeviceTransformFeedbackFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, transformFeedback: VkBool32, geometryStreams: VkBool32): VkPhysicalDeviceTransformFeedbackFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.transformFeedback = transformFeedback
+  result.geometryStreams = geometryStreams
+
+proc newVkPhysicalDeviceTransformFeedbackPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxTransformFeedbackStreams: uint32, maxTransformFeedbackBuffers: uint32, maxTransformFeedbackBufferSize: VkDeviceSize, maxTransformFeedbackStreamDataSize: uint32, maxTransformFeedbackBufferDataSize: uint32, maxTransformFeedbackBufferDataStride: uint32, transformFeedbackQueries: VkBool32, transformFeedbackStreamsLinesTriangles: VkBool32, transformFeedbackRasterizationStreamSelect: VkBool32, transformFeedbackDraw: VkBool32): VkPhysicalDeviceTransformFeedbackPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxTransformFeedbackStreams = maxTransformFeedbackStreams
+  result.maxTransformFeedbackBuffers = maxTransformFeedbackBuffers
+  result.maxTransformFeedbackBufferSize = maxTransformFeedbackBufferSize
+  result.maxTransformFeedbackStreamDataSize = maxTransformFeedbackStreamDataSize
+  result.maxTransformFeedbackBufferDataSize = maxTransformFeedbackBufferDataSize
+  result.maxTransformFeedbackBufferDataStride = maxTransformFeedbackBufferDataStride
+  result.transformFeedbackQueries = transformFeedbackQueries
+  result.transformFeedbackStreamsLinesTriangles = transformFeedbackStreamsLinesTriangles
+  result.transformFeedbackRasterizationStreamSelect = transformFeedbackRasterizationStreamSelect
+  result.transformFeedbackDraw = transformFeedbackDraw
+
+proc newVkPipelineRasterizationStateStreamCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineRasterizationStateStreamCreateFlagsEXT = 0.VkPipelineRasterizationStateStreamCreateFlagsEXT, rasterizationStream: uint32): VkPipelineRasterizationStateStreamCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.rasterizationStream = rasterizationStream
+
+proc newVkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, representativeFragmentTest: VkBool32): VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.representativeFragmentTest = representativeFragmentTest
+
+proc newVkPipelineRepresentativeFragmentTestStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, representativeFragmentTestEnable: VkBool32): VkPipelineRepresentativeFragmentTestStateCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.representativeFragmentTestEnable = representativeFragmentTestEnable
+
+proc newVkPhysicalDeviceExclusiveScissorFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, exclusiveScissor: VkBool32): VkPhysicalDeviceExclusiveScissorFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.exclusiveScissor = exclusiveScissor
+
+proc newVkPipelineViewportExclusiveScissorStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, exclusiveScissorCount: uint32, pExclusiveScissors: ptr VkRect2D): VkPipelineViewportExclusiveScissorStateCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.exclusiveScissorCount = exclusiveScissorCount
+  result.pExclusiveScissors = pExclusiveScissors
+
+proc newVkPhysicalDeviceCornerSampledImageFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, cornerSampledImage: VkBool32): VkPhysicalDeviceCornerSampledImageFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.cornerSampledImage = cornerSampledImage
+
+proc newVkPhysicalDeviceComputeShaderDerivativesFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, computeDerivativeGroupQuads: VkBool32, computeDerivativeGroupLinear: VkBool32): VkPhysicalDeviceComputeShaderDerivativesFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.computeDerivativeGroupQuads = computeDerivativeGroupQuads
+  result.computeDerivativeGroupLinear = computeDerivativeGroupLinear
+
+proc newVkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, fragmentShaderBarycentric: VkBool32): VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.fragmentShaderBarycentric = fragmentShaderBarycentric
+
+proc newVkPhysicalDeviceShaderImageFootprintFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, imageFootprint: VkBool32): VkPhysicalDeviceShaderImageFootprintFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.imageFootprint = imageFootprint
+
+proc newVkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, dedicatedAllocationImageAliasing: VkBool32): VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing
+
+proc newVkShadingRatePaletteNV*(shadingRatePaletteEntryCount: uint32, pShadingRatePaletteEntries: ptr VkShadingRatePaletteEntryNV): VkShadingRatePaletteNV =
+  result.shadingRatePaletteEntryCount = shadingRatePaletteEntryCount
+  result.pShadingRatePaletteEntries = pShadingRatePaletteEntries
+
+proc newVkPipelineViewportShadingRateImageStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, shadingRateImageEnable: VkBool32, viewportCount: uint32, pShadingRatePalettes: ptr VkShadingRatePaletteNV): VkPipelineViewportShadingRateImageStateCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.shadingRateImageEnable = shadingRateImageEnable
+  result.viewportCount = viewportCount
+  result.pShadingRatePalettes = pShadingRatePalettes
+
+proc newVkPhysicalDeviceShadingRateImageFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, shadingRateImage: VkBool32, shadingRateCoarseSampleOrder: VkBool32): VkPhysicalDeviceShadingRateImageFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.shadingRateImage = shadingRateImage
+  result.shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder
+
+proc newVkPhysicalDeviceShadingRateImagePropertiesNV*(sType: VkStructureType, pNext: pointer = nil, shadingRateTexelSize: VkExtent2D, shadingRatePaletteSize: uint32, shadingRateMaxCoarseSamples: uint32): VkPhysicalDeviceShadingRateImagePropertiesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.shadingRateTexelSize = shadingRateTexelSize
+  result.shadingRatePaletteSize = shadingRatePaletteSize
+  result.shadingRateMaxCoarseSamples = shadingRateMaxCoarseSamples
+
+proc newVkCoarseSampleLocationNV*(pixelX: uint32, pixelY: uint32, sample: uint32): VkCoarseSampleLocationNV =
+  result.pixelX = pixelX
+  result.pixelY = pixelY
+  result.sample = sample
+
+proc newVkCoarseSampleOrderCustomNV*(shadingRate: VkShadingRatePaletteEntryNV, sampleCount: uint32, sampleLocationCount: uint32, pSampleLocations: ptr VkCoarseSampleLocationNV): VkCoarseSampleOrderCustomNV =
+  result.shadingRate = shadingRate
+  result.sampleCount = sampleCount
+  result.sampleLocationCount = sampleLocationCount
+  result.pSampleLocations = pSampleLocations
+
+proc newVkPipelineViewportCoarseSampleOrderStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32, pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV): VkPipelineViewportCoarseSampleOrderStateCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.sampleOrderType = sampleOrderType
+  result.customSampleOrderCount = customSampleOrderCount
+  result.pCustomSampleOrders = pCustomSampleOrders
+
+proc newVkPhysicalDeviceMeshShaderFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, taskShader: VkBool32, meshShader: VkBool32): VkPhysicalDeviceMeshShaderFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.taskShader = taskShader
+  result.meshShader = meshShader
+
+proc newVkPhysicalDeviceMeshShaderPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, 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): VkPhysicalDeviceMeshShaderPropertiesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxDrawMeshTasksCount = maxDrawMeshTasksCount
+  result.maxTaskWorkGroupInvocations = maxTaskWorkGroupInvocations
+  result.maxTaskWorkGroupSize = maxTaskWorkGroupSize
+  result.maxTaskTotalMemorySize = maxTaskTotalMemorySize
+  result.maxTaskOutputCount = maxTaskOutputCount
+  result.maxMeshWorkGroupInvocations = maxMeshWorkGroupInvocations
+  result.maxMeshWorkGroupSize = maxMeshWorkGroupSize
+  result.maxMeshTotalMemorySize = maxMeshTotalMemorySize
+  result.maxMeshOutputVertices = maxMeshOutputVertices
+  result.maxMeshOutputPrimitives = maxMeshOutputPrimitives
+  result.maxMeshMultiviewViewCount = maxMeshMultiviewViewCount
+  result.meshOutputPerVertexGranularity = meshOutputPerVertexGranularity
+  result.meshOutputPerPrimitiveGranularity = meshOutputPerPrimitiveGranularity
+
+proc newVkDrawMeshTasksIndirectCommandNV*(taskCount: uint32, firstTask: uint32): VkDrawMeshTasksIndirectCommandNV =
+  result.taskCount = taskCount
+  result.firstTask = firstTask
+
+proc newVkRayTracingShaderGroupCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, `type`: VkRayTracingShaderGroupTypeKHR, generalShader: uint32, closestHitShader: uint32, anyHitShader: uint32, intersectionShader: uint32): VkRayTracingShaderGroupCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.`type` = `type`
+  result.generalShader = generalShader
+  result.closestHitShader = closestHitShader
+  result.anyHitShader = anyHitShader
+  result.intersectionShader = intersectionShader
+
+proc newVkRayTracingShaderGroupCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, `type`: VkRayTracingShaderGroupTypeKHR, generalShader: uint32, closestHitShader: uint32, anyHitShader: uint32, intersectionShader: uint32, pShaderGroupCaptureReplayHandle: pointer = nil): VkRayTracingShaderGroupCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.`type` = `type`
+  result.generalShader = generalShader
+  result.closestHitShader = closestHitShader
+  result.anyHitShader = anyHitShader
+  result.intersectionShader = intersectionShader
+  result.pShaderGroupCaptureReplayHandle = pShaderGroupCaptureReplayHandle
+
+proc newVkRayTracingPipelineCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineCreateFlags = 0.VkPipelineCreateFlags, stageCount: uint32, pStages: ptr VkPipelineShaderStageCreateInfo, groupCount: uint32, pGroups: ptr VkRayTracingShaderGroupCreateInfoNV, maxRecursionDepth: uint32, layout: VkPipelineLayout, basePipelineHandle: VkPipeline, basePipelineIndex: int32): VkRayTracingPipelineCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.stageCount = stageCount
+  result.pStages = pStages
+  result.groupCount = groupCount
+  result.pGroups = pGroups
+  result.maxRecursionDepth = maxRecursionDepth
+  result.layout = layout
+  result.basePipelineHandle = basePipelineHandle
+  result.basePipelineIndex = basePipelineIndex
+
+proc newVkRayTracingPipelineCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineCreateFlags = 0.VkPipelineCreateFlags, stageCount: uint32, pStages: ptr VkPipelineShaderStageCreateInfo, groupCount: uint32, pGroups: ptr VkRayTracingShaderGroupCreateInfoKHR, maxRecursionDepth: uint32, libraries: VkPipelineLibraryCreateInfoKHR, pLibraryInterface: ptr VkRayTracingPipelineInterfaceCreateInfoKHR, layout: VkPipelineLayout, basePipelineHandle: VkPipeline, basePipelineIndex: int32): VkRayTracingPipelineCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.stageCount = stageCount
+  result.pStages = pStages
+  result.groupCount = groupCount
+  result.pGroups = pGroups
+  result.maxRecursionDepth = maxRecursionDepth
+  result.libraries = libraries
+  result.pLibraryInterface = pLibraryInterface
+  result.layout = layout
+  result.basePipelineHandle = basePipelineHandle
+  result.basePipelineIndex = basePipelineIndex
+
+proc newVkGeometryTrianglesNV*(sType: VkStructureType, pNext: pointer = nil, vertexData: VkBuffer, vertexOffset: VkDeviceSize, vertexCount: uint32, vertexStride: VkDeviceSize, vertexFormat: VkFormat, indexData: VkBuffer, indexOffset: VkDeviceSize, indexCount: uint32, indexType: VkIndexType, transformData: VkBuffer, transformOffset: VkDeviceSize): VkGeometryTrianglesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.vertexData = vertexData
+  result.vertexOffset = vertexOffset
+  result.vertexCount = vertexCount
+  result.vertexStride = vertexStride
+  result.vertexFormat = vertexFormat
+  result.indexData = indexData
+  result.indexOffset = indexOffset
+  result.indexCount = indexCount
+  result.indexType = indexType
+  result.transformData = transformData
+  result.transformOffset = transformOffset
+
+proc newVkGeometryAABBNV*(sType: VkStructureType, pNext: pointer = nil, aabbData: VkBuffer, numAABBs: uint32, stride: uint32, offset: VkDeviceSize): VkGeometryAABBNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.aabbData = aabbData
+  result.numAABBs = numAABBs
+  result.stride = stride
+  result.offset = offset
+
+proc newVkGeometryDataNV*(triangles: VkGeometryTrianglesNV, aabbs: VkGeometryAABBNV): VkGeometryDataNV =
+  result.triangles = triangles
+  result.aabbs = aabbs
+
+proc newVkGeometryNV*(sType: VkStructureType, pNext: pointer = nil, geometryType: VkGeometryTypeKHR, geometry: VkGeometryDataNV, flags: VkGeometryFlagsKHR = 0.VkGeometryFlagsKHR): VkGeometryNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.geometryType = geometryType
+  result.geometry = geometry
+  result.flags = flags
+
+proc newVkAccelerationStructureInfoNV*(sType: VkStructureType, pNext: pointer = nil, `type`: VkAccelerationStructureTypeNV, flags: VkBuildAccelerationStructureFlagsNV = 0.VkBuildAccelerationStructureFlagsNV, instanceCount: uint32, geometryCount: uint32, pGeometries: ptr VkGeometryNV): VkAccelerationStructureInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.`type` = `type`
+  result.flags = flags
+  result.instanceCount = instanceCount
+  result.geometryCount = geometryCount
+  result.pGeometries = pGeometries
+
+proc newVkAccelerationStructureCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, compactedSize: VkDeviceSize, info: VkAccelerationStructureInfoNV): VkAccelerationStructureCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.compactedSize = compactedSize
+  result.info = info
+
+proc newVkBindAccelerationStructureMemoryInfoKHR*(sType: VkStructureType, pNext: pointer = nil, accelerationStructure: VkAccelerationStructureKHR, memory: VkDeviceMemory, memoryOffset: VkDeviceSize, deviceIndexCount: uint32, pDeviceIndices: ptr uint32): VkBindAccelerationStructureMemoryInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.accelerationStructure = accelerationStructure
+  result.memory = memory
+  result.memoryOffset = memoryOffset
+  result.deviceIndexCount = deviceIndexCount
+  result.pDeviceIndices = pDeviceIndices
+
+proc newVkWriteDescriptorSetAccelerationStructureKHR*(sType: VkStructureType, pNext: pointer = nil, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR): VkWriteDescriptorSetAccelerationStructureKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.accelerationStructureCount = accelerationStructureCount
+  result.pAccelerationStructures = pAccelerationStructures
+
+proc newVkAccelerationStructureMemoryRequirementsInfoKHR*(sType: VkStructureType, pNext: pointer = nil, `type`: VkAccelerationStructureMemoryRequirementsTypeKHR, buildType: VkAccelerationStructureBuildTypeKHR, accelerationStructure: VkAccelerationStructureKHR): VkAccelerationStructureMemoryRequirementsInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.`type` = `type`
+  result.buildType = buildType
+  result.accelerationStructure = accelerationStructure
+
+proc newVkAccelerationStructureMemoryRequirementsInfoNV*(sType: VkStructureType, pNext: pointer = nil, `type`: VkAccelerationStructureMemoryRequirementsTypeNV, accelerationStructure: VkAccelerationStructureNV): VkAccelerationStructureMemoryRequirementsInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.`type` = `type`
+  result.accelerationStructure = accelerationStructure
+
+proc newVkPhysicalDeviceRayTracingFeaturesKHR*(sType: VkStructureType, pNext: pointer = nil, rayTracing: VkBool32, rayTracingShaderGroupHandleCaptureReplay: VkBool32, rayTracingShaderGroupHandleCaptureReplayMixed: VkBool32, rayTracingAccelerationStructureCaptureReplay: VkBool32, rayTracingIndirectTraceRays: VkBool32, rayTracingIndirectAccelerationStructureBuild: VkBool32, rayTracingHostAccelerationStructureCommands: VkBool32, rayQuery: VkBool32, rayTracingPrimitiveCulling: VkBool32): VkPhysicalDeviceRayTracingFeaturesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.rayTracing = rayTracing
+  result.rayTracingShaderGroupHandleCaptureReplay = rayTracingShaderGroupHandleCaptureReplay
+  result.rayTracingShaderGroupHandleCaptureReplayMixed = rayTracingShaderGroupHandleCaptureReplayMixed
+  result.rayTracingAccelerationStructureCaptureReplay = rayTracingAccelerationStructureCaptureReplay
+  result.rayTracingIndirectTraceRays = rayTracingIndirectTraceRays
+  result.rayTracingIndirectAccelerationStructureBuild = rayTracingIndirectAccelerationStructureBuild
+  result.rayTracingHostAccelerationStructureCommands = rayTracingHostAccelerationStructureCommands
+  result.rayQuery = rayQuery
+  result.rayTracingPrimitiveCulling = rayTracingPrimitiveCulling
+
+proc newVkPhysicalDeviceRayTracingPropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, shaderGroupHandleSize: uint32, maxRecursionDepth: uint32, maxShaderGroupStride: uint32, shaderGroupBaseAlignment: uint32, maxGeometryCount: uint64, maxInstanceCount: uint64, maxPrimitiveCount: uint64, maxDescriptorSetAccelerationStructures: uint32, shaderGroupHandleCaptureReplaySize: uint32): VkPhysicalDeviceRayTracingPropertiesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderGroupHandleSize = shaderGroupHandleSize
+  result.maxRecursionDepth = maxRecursionDepth
+  result.maxShaderGroupStride = maxShaderGroupStride
+  result.shaderGroupBaseAlignment = shaderGroupBaseAlignment
+  result.maxGeometryCount = maxGeometryCount
+  result.maxInstanceCount = maxInstanceCount
+  result.maxPrimitiveCount = maxPrimitiveCount
+  result.maxDescriptorSetAccelerationStructures = maxDescriptorSetAccelerationStructures
+  result.shaderGroupHandleCaptureReplaySize = shaderGroupHandleCaptureReplaySize
+
+proc newVkPhysicalDeviceRayTracingPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, shaderGroupHandleSize: uint32, maxRecursionDepth: uint32, maxShaderGroupStride: uint32, shaderGroupBaseAlignment: uint32, maxGeometryCount: uint64, maxInstanceCount: uint64, maxTriangleCount: uint64, maxDescriptorSetAccelerationStructures: uint32): VkPhysicalDeviceRayTracingPropertiesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderGroupHandleSize = shaderGroupHandleSize
+  result.maxRecursionDepth = maxRecursionDepth
+  result.maxShaderGroupStride = maxShaderGroupStride
+  result.shaderGroupBaseAlignment = shaderGroupBaseAlignment
+  result.maxGeometryCount = maxGeometryCount
+  result.maxInstanceCount = maxInstanceCount
+  result.maxTriangleCount = maxTriangleCount
+  result.maxDescriptorSetAccelerationStructures = maxDescriptorSetAccelerationStructures
+
+proc newVkStridedBufferRegionKHR*(buffer: VkBuffer, offset: VkDeviceSize, stride: VkDeviceSize, size: VkDeviceSize): VkStridedBufferRegionKHR =
+  result.buffer = buffer
+  result.offset = offset
+  result.stride = stride
+  result.size = size
+
+proc newVkTraceRaysIndirectCommandKHR*(width: uint32, height: uint32, depth: uint32): VkTraceRaysIndirectCommandKHR =
+  result.width = width
+  result.height = height
+  result.depth = depth
+
+proc newVkDrmFormatModifierPropertiesListEXT*(sType: VkStructureType, pNext: pointer = nil, drmFormatModifierCount: uint32, pDrmFormatModifierProperties: ptr VkDrmFormatModifierPropertiesEXT): VkDrmFormatModifierPropertiesListEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.drmFormatModifierCount = drmFormatModifierCount
+  result.pDrmFormatModifierProperties = pDrmFormatModifierProperties
+
+proc newVkDrmFormatModifierPropertiesEXT*(drmFormatModifier: uint64, drmFormatModifierPlaneCount: uint32, drmFormatModifierTilingFeatures: VkFormatFeatureFlags): VkDrmFormatModifierPropertiesEXT =
+  result.drmFormatModifier = drmFormatModifier
+  result.drmFormatModifierPlaneCount = drmFormatModifierPlaneCount
+  result.drmFormatModifierTilingFeatures = drmFormatModifierTilingFeatures
+
+proc newVkPhysicalDeviceImageDrmFormatModifierInfoEXT*(sType: VkStructureType, pNext: pointer = nil, drmFormatModifier: uint64, sharingMode: VkSharingMode, queueFamilyIndexCount: uint32, pQueueFamilyIndices: ptr uint32): VkPhysicalDeviceImageDrmFormatModifierInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.drmFormatModifier = drmFormatModifier
+  result.sharingMode = sharingMode
+  result.queueFamilyIndexCount = queueFamilyIndexCount
+  result.pQueueFamilyIndices = pQueueFamilyIndices
+
+proc newVkImageDrmFormatModifierListCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, drmFormatModifierCount: uint32, pDrmFormatModifiers: ptr uint64): VkImageDrmFormatModifierListCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.drmFormatModifierCount = drmFormatModifierCount
+  result.pDrmFormatModifiers = pDrmFormatModifiers
+
+proc newVkImageDrmFormatModifierExplicitCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, drmFormatModifier: uint64, drmFormatModifierPlaneCount: uint32, pPlaneLayouts: ptr VkSubresourceLayout): VkImageDrmFormatModifierExplicitCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.drmFormatModifier = drmFormatModifier
+  result.drmFormatModifierPlaneCount = drmFormatModifierPlaneCount
+  result.pPlaneLayouts = pPlaneLayouts
+
+proc newVkImageDrmFormatModifierPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, drmFormatModifier: uint64): VkImageDrmFormatModifierPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.drmFormatModifier = drmFormatModifier
+
+proc newVkImageStencilUsageCreateInfo*(sType: VkStructureType, pNext: pointer = nil, stencilUsage: VkImageUsageFlags): VkImageStencilUsageCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.stencilUsage = stencilUsage
+
+proc newVkDeviceMemoryOverallocationCreateInfoAMD*(sType: VkStructureType, pNext: pointer = nil, overallocationBehavior: VkMemoryOverallocationBehaviorAMD): VkDeviceMemoryOverallocationCreateInfoAMD =
+  result.sType = sType
+  result.pNext = pNext
+  result.overallocationBehavior = overallocationBehavior
+
+proc newVkPhysicalDeviceFragmentDensityMapFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, fragmentDensityMap: VkBool32, fragmentDensityMapDynamic: VkBool32, fragmentDensityMapNonSubsampledImages: VkBool32): VkPhysicalDeviceFragmentDensityMapFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.fragmentDensityMap = fragmentDensityMap
+  result.fragmentDensityMapDynamic = fragmentDensityMapDynamic
+  result.fragmentDensityMapNonSubsampledImages = fragmentDensityMapNonSubsampledImages
+
+proc newVkPhysicalDeviceFragmentDensityMap2FeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, fragmentDensityMapDeferred: VkBool32): VkPhysicalDeviceFragmentDensityMap2FeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.fragmentDensityMapDeferred = fragmentDensityMapDeferred
+
+proc newVkPhysicalDeviceFragmentDensityMapPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, minFragmentDensityTexelSize: VkExtent2D, maxFragmentDensityTexelSize: VkExtent2D, fragmentDensityInvocations: VkBool32): VkPhysicalDeviceFragmentDensityMapPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.minFragmentDensityTexelSize = minFragmentDensityTexelSize
+  result.maxFragmentDensityTexelSize = maxFragmentDensityTexelSize
+  result.fragmentDensityInvocations = fragmentDensityInvocations
+
+proc newVkPhysicalDeviceFragmentDensityMap2PropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, subsampledLoads: VkBool32, subsampledCoarseReconstructionEarlyAccess: VkBool32, maxSubsampledArrayLayers: uint32, maxDescriptorSetSubsampledSamplers: uint32): VkPhysicalDeviceFragmentDensityMap2PropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.subsampledLoads = subsampledLoads
+  result.subsampledCoarseReconstructionEarlyAccess = subsampledCoarseReconstructionEarlyAccess
+  result.maxSubsampledArrayLayers = maxSubsampledArrayLayers
+  result.maxDescriptorSetSubsampledSamplers = maxDescriptorSetSubsampledSamplers
+
+proc newVkRenderPassFragmentDensityMapCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, fragmentDensityMapAttachment: VkAttachmentReference): VkRenderPassFragmentDensityMapCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.fragmentDensityMapAttachment = fragmentDensityMapAttachment
+
+proc newVkPhysicalDeviceScalarBlockLayoutFeatures*(sType: VkStructureType, pNext: pointer = nil, scalarBlockLayout: VkBool32): VkPhysicalDeviceScalarBlockLayoutFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.scalarBlockLayout = scalarBlockLayout
+
+proc newVkSurfaceProtectedCapabilitiesKHR*(sType: VkStructureType, pNext: pointer = nil, supportsProtected: VkBool32): VkSurfaceProtectedCapabilitiesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.supportsProtected = supportsProtected
+
+proc newVkPhysicalDeviceUniformBufferStandardLayoutFeatures*(sType: VkStructureType, pNext: pointer = nil, uniformBufferStandardLayout: VkBool32): VkPhysicalDeviceUniformBufferStandardLayoutFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.uniformBufferStandardLayout = uniformBufferStandardLayout
+
+proc newVkPhysicalDeviceDepthClipEnableFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, depthClipEnable: VkBool32): VkPhysicalDeviceDepthClipEnableFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.depthClipEnable = depthClipEnable
+
+proc newVkPipelineRasterizationDepthClipStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineRasterizationDepthClipStateCreateFlagsEXT = 0.VkPipelineRasterizationDepthClipStateCreateFlagsEXT, depthClipEnable: VkBool32): VkPipelineRasterizationDepthClipStateCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.depthClipEnable = depthClipEnable
+
+proc newVkPhysicalDeviceMemoryBudgetPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, heapBudget: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize], heapUsage: array[VK_MAX_MEMORY_HEAPS, VkDeviceSize]): VkPhysicalDeviceMemoryBudgetPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.heapBudget = heapBudget
+  result.heapUsage = heapUsage
+
+proc newVkPhysicalDeviceMemoryPriorityFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, memoryPriority: VkBool32): VkPhysicalDeviceMemoryPriorityFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.memoryPriority = memoryPriority
+
+proc newVkMemoryPriorityAllocateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, priority: float32): VkMemoryPriorityAllocateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.priority = priority
+
+proc newVkPhysicalDeviceBufferDeviceAddressFeatures*(sType: VkStructureType, pNext: pointer = nil, bufferDeviceAddress: VkBool32, bufferDeviceAddressCaptureReplay: VkBool32, bufferDeviceAddressMultiDevice: VkBool32): VkPhysicalDeviceBufferDeviceAddressFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.bufferDeviceAddress = bufferDeviceAddress
+  result.bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay
+  result.bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice
+
+proc newVkPhysicalDeviceBufferDeviceAddressFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, bufferDeviceAddress: VkBool32, bufferDeviceAddressCaptureReplay: VkBool32, bufferDeviceAddressMultiDevice: VkBool32): VkPhysicalDeviceBufferDeviceAddressFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.bufferDeviceAddress = bufferDeviceAddress
+  result.bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay
+  result.bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice
+
+proc newVkBufferDeviceAddressInfo*(sType: VkStructureType, pNext: pointer = nil, buffer: VkBuffer): VkBufferDeviceAddressInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.buffer = buffer
+
+proc newVkBufferOpaqueCaptureAddressCreateInfo*(sType: VkStructureType, pNext: pointer = nil, opaqueCaptureAddress: uint64): VkBufferOpaqueCaptureAddressCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.opaqueCaptureAddress = opaqueCaptureAddress
+
+proc newVkBufferDeviceAddressCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, deviceAddress: VkDeviceAddress): VkBufferDeviceAddressCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceAddress = deviceAddress
+
+proc newVkPhysicalDeviceImageViewImageFormatInfoEXT*(sType: VkStructureType, pNext: pointer = nil, imageViewType: VkImageViewType): VkPhysicalDeviceImageViewImageFormatInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.imageViewType = imageViewType
+
+proc newVkFilterCubicImageViewImageFormatPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, filterCubic: VkBool32, filterCubicMinmax: VkBool32): VkFilterCubicImageViewImageFormatPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.filterCubic = filterCubic
+  result.filterCubicMinmax = filterCubicMinmax
+
+proc newVkPhysicalDeviceImagelessFramebufferFeatures*(sType: VkStructureType, pNext: pointer = nil, imagelessFramebuffer: VkBool32): VkPhysicalDeviceImagelessFramebufferFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.imagelessFramebuffer = imagelessFramebuffer
+
+proc newVkFramebufferAttachmentsCreateInfo*(sType: VkStructureType, pNext: pointer = nil, attachmentImageInfoCount: uint32, pAttachmentImageInfos: ptr VkFramebufferAttachmentImageInfo): VkFramebufferAttachmentsCreateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.attachmentImageInfoCount = attachmentImageInfoCount
+  result.pAttachmentImageInfos = pAttachmentImageInfos
+
+proc newVkFramebufferAttachmentImageInfo*(sType: VkStructureType, pNext: pointer = nil, flags: VkImageCreateFlags = 0.VkImageCreateFlags, usage: VkImageUsageFlags, width: uint32, height: uint32, layerCount: uint32, viewFormatCount: uint32, pViewFormats: ptr VkFormat): VkFramebufferAttachmentImageInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.usage = usage
+  result.width = width
+  result.height = height
+  result.layerCount = layerCount
+  result.viewFormatCount = viewFormatCount
+  result.pViewFormats = pViewFormats
+
+proc newVkRenderPassAttachmentBeginInfo*(sType: VkStructureType, pNext: pointer = nil, attachmentCount: uint32, pAttachments: ptr VkImageView): VkRenderPassAttachmentBeginInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.attachmentCount = attachmentCount
+  result.pAttachments = pAttachments
+
+proc newVkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, textureCompressionASTC_HDR: VkBool32): VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.textureCompressionASTC_HDR = textureCompressionASTC_HDR
+
+proc newVkPhysicalDeviceCooperativeMatrixFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, cooperativeMatrix: VkBool32, cooperativeMatrixRobustBufferAccess: VkBool32): VkPhysicalDeviceCooperativeMatrixFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.cooperativeMatrix = cooperativeMatrix
+  result.cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess
+
+proc newVkPhysicalDeviceCooperativeMatrixPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, cooperativeMatrixSupportedStages: VkShaderStageFlags): VkPhysicalDeviceCooperativeMatrixPropertiesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.cooperativeMatrixSupportedStages = cooperativeMatrixSupportedStages
+
+proc newVkCooperativeMatrixPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, MSize: uint32, NSize: uint32, KSize: uint32, AType: VkComponentTypeNV, BType: VkComponentTypeNV, CType: VkComponentTypeNV, DType: VkComponentTypeNV, scope: VkScopeNV): VkCooperativeMatrixPropertiesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.MSize = MSize
+  result.NSize = NSize
+  result.KSize = KSize
+  result.AType = AType
+  result.BType = BType
+  result.CType = CType
+  result.DType = DType
+  result.scope = scope
+
+proc newVkPhysicalDeviceYcbcrImageArraysFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, ycbcrImageArrays: VkBool32): VkPhysicalDeviceYcbcrImageArraysFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.ycbcrImageArrays = ycbcrImageArrays
+
+proc newVkImageViewHandleInfoNVX*(sType: VkStructureType, pNext: pointer = nil, imageView: VkImageView, descriptorType: VkDescriptorType, sampler: VkSampler): VkImageViewHandleInfoNVX =
+  result.sType = sType
+  result.pNext = pNext
+  result.imageView = imageView
+  result.descriptorType = descriptorType
+  result.sampler = sampler
+
+proc newVkImageViewAddressPropertiesNVX*(sType: VkStructureType, pNext: pointer = nil, deviceAddress: VkDeviceAddress, size: VkDeviceSize): VkImageViewAddressPropertiesNVX =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceAddress = deviceAddress
+  result.size = size
+
+proc newVkPresentFrameTokenGGP*(sType: VkStructureType, pNext: pointer = nil, frameToken: GgpFrameToken): VkPresentFrameTokenGGP =
+  result.sType = sType
+  result.pNext = pNext
+  result.frameToken = frameToken
+
+proc newVkPipelineCreationFeedbackEXT*(flags: VkPipelineCreationFeedbackFlagsEXT = 0.VkPipelineCreationFeedbackFlagsEXT, duration: uint64): VkPipelineCreationFeedbackEXT =
+  result.flags = flags
+  result.duration = duration
+
+proc newVkPipelineCreationFeedbackCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, pPipelineCreationFeedback: ptr VkPipelineCreationFeedbackEXT, pipelineStageCreationFeedbackCount: uint32, pPipelineStageCreationFeedbacks: ptr ptr VkPipelineCreationFeedbackEXT): VkPipelineCreationFeedbackCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.pPipelineCreationFeedback = pPipelineCreationFeedback
+  result.pipelineStageCreationFeedbackCount = pipelineStageCreationFeedbackCount
+  result.pPipelineStageCreationFeedbacks = pPipelineStageCreationFeedbacks
+
+proc newVkSurfaceFullScreenExclusiveInfoEXT*(sType: VkStructureType, pNext: pointer = nil, fullScreenExclusive: VkFullScreenExclusiveEXT): VkSurfaceFullScreenExclusiveInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.fullScreenExclusive = fullScreenExclusive
+
+proc newVkSurfaceFullScreenExclusiveWin32InfoEXT*(sType: VkStructureType, pNext: pointer = nil, hmonitor: HMONITOR): VkSurfaceFullScreenExclusiveWin32InfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.hmonitor = hmonitor
+
+proc newVkSurfaceCapabilitiesFullScreenExclusiveEXT*(sType: VkStructureType, pNext: pointer = nil, fullScreenExclusiveSupported: VkBool32): VkSurfaceCapabilitiesFullScreenExclusiveEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.fullScreenExclusiveSupported = fullScreenExclusiveSupported
+
+proc newVkPhysicalDevicePerformanceQueryFeaturesKHR*(sType: VkStructureType, pNext: pointer = nil, performanceCounterQueryPools: VkBool32, performanceCounterMultipleQueryPools: VkBool32): VkPhysicalDevicePerformanceQueryFeaturesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.performanceCounterQueryPools = performanceCounterQueryPools
+  result.performanceCounterMultipleQueryPools = performanceCounterMultipleQueryPools
+
+proc newVkPhysicalDevicePerformanceQueryPropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, allowCommandBufferQueryCopies: VkBool32): VkPhysicalDevicePerformanceQueryPropertiesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.allowCommandBufferQueryCopies = allowCommandBufferQueryCopies
+
+proc newVkPerformanceCounterKHR*(sType: VkStructureType, pNext: pointer = nil, unit: VkPerformanceCounterUnitKHR, scope: VkPerformanceCounterScopeKHR, storage: VkPerformanceCounterStorageKHR, uuid: array[VK_UUID_SIZE, uint8]): VkPerformanceCounterKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.unit = unit
+  result.scope = scope
+  result.storage = storage
+  result.uuid = uuid
+
+proc newVkPerformanceCounterDescriptionKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkPerformanceCounterDescriptionFlagsKHR = 0.VkPerformanceCounterDescriptionFlagsKHR, name: array[VK_MAX_DESCRIPTION_SIZE, char], category: array[VK_MAX_DESCRIPTION_SIZE, char], description: array[VK_MAX_DESCRIPTION_SIZE, char]): VkPerformanceCounterDescriptionKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.name = name
+  result.category = category
+  result.description = description
+
+proc newVkQueryPoolPerformanceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, queueFamilyIndex: uint32, counterIndexCount: uint32, pCounterIndices: ptr uint32): VkQueryPoolPerformanceCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.queueFamilyIndex = queueFamilyIndex
+  result.counterIndexCount = counterIndexCount
+  result.pCounterIndices = pCounterIndices
+
+proc newVkAcquireProfilingLockInfoKHR*(sType: VkStructureType, pNext: pointer = nil, flags: VkAcquireProfilingLockFlagsKHR = 0.VkAcquireProfilingLockFlagsKHR, timeout: uint64): VkAcquireProfilingLockInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.timeout = timeout
+
+proc newVkPerformanceQuerySubmitInfoKHR*(sType: VkStructureType, pNext: pointer = nil, counterPassIndex: uint32): VkPerformanceQuerySubmitInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.counterPassIndex = counterPassIndex
+
+proc newVkHeadlessSurfaceCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, flags: VkHeadlessSurfaceCreateFlagsEXT = 0.VkHeadlessSurfaceCreateFlagsEXT): VkHeadlessSurfaceCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+
+proc newVkPhysicalDeviceCoverageReductionModeFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, coverageReductionMode: VkBool32): VkPhysicalDeviceCoverageReductionModeFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.coverageReductionMode = coverageReductionMode
+
+proc newVkPipelineCoverageReductionStateCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkPipelineCoverageReductionStateCreateFlagsNV = 0.VkPipelineCoverageReductionStateCreateFlagsNV, coverageReductionMode: VkCoverageReductionModeNV): VkPipelineCoverageReductionStateCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+  result.coverageReductionMode = coverageReductionMode
+
+proc newVkFramebufferMixedSamplesCombinationNV*(sType: VkStructureType, pNext: pointer = nil, coverageReductionMode: VkCoverageReductionModeNV, rasterizationSamples: VkSampleCountFlagBits, depthStencilSamples: VkSampleCountFlags, colorSamples: VkSampleCountFlags): VkFramebufferMixedSamplesCombinationNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.coverageReductionMode = coverageReductionMode
+  result.rasterizationSamples = rasterizationSamples
+  result.depthStencilSamples = depthStencilSamples
+  result.colorSamples = colorSamples
+
+proc newVkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*(sType: VkStructureType, pNext: pointer = nil, shaderIntegerFunctions2: VkBool32): VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderIntegerFunctions2 = shaderIntegerFunctions2
+
+proc newVkPerformanceValueINTEL*(`type`: VkPerformanceValueTypeINTEL, data: VkPerformanceValueDataINTEL): VkPerformanceValueINTEL =
+  result.`type` = `type`
+  result.data = data
+
+proc newVkInitializePerformanceApiInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, pUserData: pointer = nil): VkInitializePerformanceApiInfoINTEL =
+  result.sType = sType
+  result.pNext = pNext
+  result.pUserData = pUserData
+
+proc newVkQueryPoolPerformanceQueryCreateInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, performanceCountersSampling: VkQueryPoolSamplingModeINTEL): VkQueryPoolPerformanceQueryCreateInfoINTEL =
+  result.sType = sType
+  result.pNext = pNext
+  result.performanceCountersSampling = performanceCountersSampling
+
+proc newVkPerformanceMarkerInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, marker: uint64): VkPerformanceMarkerInfoINTEL =
+  result.sType = sType
+  result.pNext = pNext
+  result.marker = marker
+
+proc newVkPerformanceStreamMarkerInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, marker: uint32): VkPerformanceStreamMarkerInfoINTEL =
+  result.sType = sType
+  result.pNext = pNext
+  result.marker = marker
+
+proc newVkPerformanceOverrideInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, `type`: VkPerformanceOverrideTypeINTEL, enable: VkBool32, parameter: uint64): VkPerformanceOverrideInfoINTEL =
+  result.sType = sType
+  result.pNext = pNext
+  result.`type` = `type`
+  result.enable = enable
+  result.parameter = parameter
+
+proc newVkPerformanceConfigurationAcquireInfoINTEL*(sType: VkStructureType, pNext: pointer = nil, `type`: VkPerformanceConfigurationTypeINTEL): VkPerformanceConfigurationAcquireInfoINTEL =
+  result.sType = sType
+  result.pNext = pNext
+  result.`type` = `type`
+
+proc newVkPhysicalDeviceShaderClockFeaturesKHR*(sType: VkStructureType, pNext: pointer = nil, shaderSubgroupClock: VkBool32, shaderDeviceClock: VkBool32): VkPhysicalDeviceShaderClockFeaturesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderSubgroupClock = shaderSubgroupClock
+  result.shaderDeviceClock = shaderDeviceClock
+
+proc newVkPhysicalDeviceIndexTypeUint8FeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, indexTypeUint8: VkBool32): VkPhysicalDeviceIndexTypeUint8FeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.indexTypeUint8 = indexTypeUint8
+
+proc newVkPhysicalDeviceShaderSMBuiltinsPropertiesNV*(sType: VkStructureType, pNext: pointer = nil, shaderSMCount: uint32, shaderWarpsPerSM: uint32): VkPhysicalDeviceShaderSMBuiltinsPropertiesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderSMCount = shaderSMCount
+  result.shaderWarpsPerSM = shaderWarpsPerSM
+
+proc newVkPhysicalDeviceShaderSMBuiltinsFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, shaderSMBuiltins: VkBool32): VkPhysicalDeviceShaderSMBuiltinsFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderSMBuiltins = shaderSMBuiltins
+
+proc newVkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, fragmentShaderSampleInterlock: VkBool32, fragmentShaderPixelInterlock: VkBool32, fragmentShaderShadingRateInterlock: VkBool32): VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.fragmentShaderSampleInterlock = fragmentShaderSampleInterlock
+  result.fragmentShaderPixelInterlock = fragmentShaderPixelInterlock
+  result.fragmentShaderShadingRateInterlock = fragmentShaderShadingRateInterlock
+
+proc newVkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*(sType: VkStructureType, pNext: pointer = nil, separateDepthStencilLayouts: VkBool32): VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures =
+  result.sType = sType
+  result.pNext = pNext
+  result.separateDepthStencilLayouts = separateDepthStencilLayouts
+
+proc newVkAttachmentReferenceStencilLayout*(sType: VkStructureType, pNext: pointer = nil, stencilLayout: VkImageLayout): VkAttachmentReferenceStencilLayout =
+  result.sType = sType
+  result.pNext = pNext
+  result.stencilLayout = stencilLayout
+
+proc newVkAttachmentDescriptionStencilLayout*(sType: VkStructureType, pNext: pointer = nil, stencilInitialLayout: VkImageLayout, stencilFinalLayout: VkImageLayout): VkAttachmentDescriptionStencilLayout =
+  result.sType = sType
+  result.pNext = pNext
+  result.stencilInitialLayout = stencilInitialLayout
+  result.stencilFinalLayout = stencilFinalLayout
+
+proc newVkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*(sType: VkStructureType, pNext: pointer = nil, pipelineExecutableInfo: VkBool32): VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.pipelineExecutableInfo = pipelineExecutableInfo
+
+proc newVkPipelineInfoKHR*(sType: VkStructureType, pNext: pointer = nil, pipeline: VkPipeline): VkPipelineInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.pipeline = pipeline
+
+proc newVkPipelineExecutablePropertiesKHR*(sType: VkStructureType, pNext: pointer = nil, stages: VkShaderStageFlags, name: array[VK_MAX_DESCRIPTION_SIZE, char], description: array[VK_MAX_DESCRIPTION_SIZE, char], subgroupSize: uint32): VkPipelineExecutablePropertiesKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.stages = stages
+  result.name = name
+  result.description = description
+  result.subgroupSize = subgroupSize
+
+proc newVkPipelineExecutableInfoKHR*(sType: VkStructureType, pNext: pointer = nil, pipeline: VkPipeline, executableIndex: uint32): VkPipelineExecutableInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.pipeline = pipeline
+  result.executableIndex = executableIndex
+
+proc newVkPipelineExecutableStatisticKHR*(sType: VkStructureType, pNext: pointer = nil, name: array[VK_MAX_DESCRIPTION_SIZE, char], description: array[VK_MAX_DESCRIPTION_SIZE, char], format: VkPipelineExecutableStatisticFormatKHR, value: VkPipelineExecutableStatisticValueKHR): VkPipelineExecutableStatisticKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.name = name
+  result.description = description
+  result.format = format
+  result.value = value
+
+proc newVkPipelineExecutableInternalRepresentationKHR*(sType: VkStructureType, pNext: pointer = nil, name: array[VK_MAX_DESCRIPTION_SIZE, char], description: array[VK_MAX_DESCRIPTION_SIZE, char], isText: VkBool32, dataSize: uint, pData: pointer = nil): VkPipelineExecutableInternalRepresentationKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.name = name
+  result.description = description
+  result.isText = isText
+  result.dataSize = dataSize
+  result.pData = pData
+
+proc newVkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, shaderDemoteToHelperInvocation: VkBool32): VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation
+
+proc newVkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, texelBufferAlignment: VkBool32): VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.texelBufferAlignment = texelBufferAlignment
+
+proc newVkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, storageTexelBufferOffsetAlignmentBytes: VkDeviceSize, storageTexelBufferOffsetSingleTexelAlignment: VkBool32, uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize, uniformTexelBufferOffsetSingleTexelAlignment: VkBool32): VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.storageTexelBufferOffsetAlignmentBytes = storageTexelBufferOffsetAlignmentBytes
+  result.storageTexelBufferOffsetSingleTexelAlignment = storageTexelBufferOffsetSingleTexelAlignment
+  result.uniformTexelBufferOffsetAlignmentBytes = uniformTexelBufferOffsetAlignmentBytes
+  result.uniformTexelBufferOffsetSingleTexelAlignment = uniformTexelBufferOffsetSingleTexelAlignment
+
+proc newVkPhysicalDeviceSubgroupSizeControlFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, subgroupSizeControl: VkBool32, computeFullSubgroups: VkBool32): VkPhysicalDeviceSubgroupSizeControlFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.subgroupSizeControl = subgroupSizeControl
+  result.computeFullSubgroups = computeFullSubgroups
+
+proc newVkPhysicalDeviceSubgroupSizeControlPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, minSubgroupSize: uint32, maxSubgroupSize: uint32, maxComputeWorkgroupSubgroups: uint32, requiredSubgroupSizeStages: VkShaderStageFlags): VkPhysicalDeviceSubgroupSizeControlPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.minSubgroupSize = minSubgroupSize
+  result.maxSubgroupSize = maxSubgroupSize
+  result.maxComputeWorkgroupSubgroups = maxComputeWorkgroupSubgroups
+  result.requiredSubgroupSizeStages = requiredSubgroupSizeStages
+
+proc newVkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, requiredSubgroupSize: uint32): VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.requiredSubgroupSize = requiredSubgroupSize
+
+proc newVkMemoryOpaqueCaptureAddressAllocateInfo*(sType: VkStructureType, pNext: pointer = nil, opaqueCaptureAddress: uint64): VkMemoryOpaqueCaptureAddressAllocateInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.opaqueCaptureAddress = opaqueCaptureAddress
+
+proc newVkDeviceMemoryOpaqueCaptureAddressInfo*(sType: VkStructureType, pNext: pointer = nil, memory: VkDeviceMemory): VkDeviceMemoryOpaqueCaptureAddressInfo =
+  result.sType = sType
+  result.pNext = pNext
+  result.memory = memory
+
+proc newVkPhysicalDeviceLineRasterizationFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, rectangularLines: VkBool32, bresenhamLines: VkBool32, smoothLines: VkBool32, stippledRectangularLines: VkBool32, stippledBresenhamLines: VkBool32, stippledSmoothLines: VkBool32): VkPhysicalDeviceLineRasterizationFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.rectangularLines = rectangularLines
+  result.bresenhamLines = bresenhamLines
+  result.smoothLines = smoothLines
+  result.stippledRectangularLines = stippledRectangularLines
+  result.stippledBresenhamLines = stippledBresenhamLines
+  result.stippledSmoothLines = stippledSmoothLines
+
+proc newVkPhysicalDeviceLineRasterizationPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, lineSubPixelPrecisionBits: uint32): VkPhysicalDeviceLineRasterizationPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.lineSubPixelPrecisionBits = lineSubPixelPrecisionBits
+
+proc newVkPipelineRasterizationLineStateCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, lineRasterizationMode: VkLineRasterizationModeEXT, stippledLineEnable: VkBool32, lineStippleFactor: uint32, lineStipplePattern: uint16): VkPipelineRasterizationLineStateCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.lineRasterizationMode = lineRasterizationMode
+  result.stippledLineEnable = stippledLineEnable
+  result.lineStippleFactor = lineStippleFactor
+  result.lineStipplePattern = lineStipplePattern
+
+proc newVkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, pipelineCreationCacheControl: VkBool32): VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.pipelineCreationCacheControl = pipelineCreationCacheControl
+
+proc newVkPhysicalDeviceVulkan11Features*(sType: VkStructureType, pNext: pointer = nil, storageBuffer16BitAccess: VkBool32, uniformAndStorageBuffer16BitAccess: VkBool32, storagePushConstant16: VkBool32, storageInputOutput16: VkBool32, multiview: VkBool32, multiviewGeometryShader: VkBool32, multiviewTessellationShader: VkBool32, variablePointersStorageBuffer: VkBool32, variablePointers: VkBool32, protectedMemory: VkBool32, samplerYcbcrConversion: VkBool32, shaderDrawParameters: VkBool32): VkPhysicalDeviceVulkan11Features =
+  result.sType = sType
+  result.pNext = pNext
+  result.storageBuffer16BitAccess = storageBuffer16BitAccess
+  result.uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess
+  result.storagePushConstant16 = storagePushConstant16
+  result.storageInputOutput16 = storageInputOutput16
+  result.multiview = multiview
+  result.multiviewGeometryShader = multiviewGeometryShader
+  result.multiviewTessellationShader = multiviewTessellationShader
+  result.variablePointersStorageBuffer = variablePointersStorageBuffer
+  result.variablePointers = variablePointers
+  result.protectedMemory = protectedMemory
+  result.samplerYcbcrConversion = samplerYcbcrConversion
+  result.shaderDrawParameters = shaderDrawParameters
+
+proc newVkPhysicalDeviceVulkan11Properties*(sType: VkStructureType, pNext: pointer = nil, 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): VkPhysicalDeviceVulkan11Properties =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceUUID = deviceUUID
+  result.driverUUID = driverUUID
+  result.deviceLUID = deviceLUID
+  result.deviceNodeMask = deviceNodeMask
+  result.deviceLUIDValid = deviceLUIDValid
+  result.subgroupSize = subgroupSize
+  result.subgroupSupportedStages = subgroupSupportedStages
+  result.subgroupSupportedOperations = subgroupSupportedOperations
+  result.subgroupQuadOperationsInAllStages = subgroupQuadOperationsInAllStages
+  result.pointClippingBehavior = pointClippingBehavior
+  result.maxMultiviewViewCount = maxMultiviewViewCount
+  result.maxMultiviewInstanceIndex = maxMultiviewInstanceIndex
+  result.protectedNoFault = protectedNoFault
+  result.maxPerSetDescriptors = maxPerSetDescriptors
+  result.maxMemoryAllocationSize = maxMemoryAllocationSize
+
+proc newVkPhysicalDeviceVulkan12Features*(sType: VkStructureType, pNext: pointer = nil, 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): VkPhysicalDeviceVulkan12Features =
+  result.sType = sType
+  result.pNext = pNext
+  result.samplerMirrorClampToEdge = samplerMirrorClampToEdge
+  result.drawIndirectCount = drawIndirectCount
+  result.storageBuffer8BitAccess = storageBuffer8BitAccess
+  result.uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess
+  result.storagePushConstant8 = storagePushConstant8
+  result.shaderBufferInt64Atomics = shaderBufferInt64Atomics
+  result.shaderSharedInt64Atomics = shaderSharedInt64Atomics
+  result.shaderFloat16 = shaderFloat16
+  result.shaderInt8 = shaderInt8
+  result.descriptorIndexing = descriptorIndexing
+  result.shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing
+  result.shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing
+  result.shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing
+  result.shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing
+  result.shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing
+  result.shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing
+  result.shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing
+  result.shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing
+  result.shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing
+  result.shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing
+  result.descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind
+  result.descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind
+  result.descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind
+  result.descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind
+  result.descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind
+  result.descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind
+  result.descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending
+  result.descriptorBindingPartiallyBound = descriptorBindingPartiallyBound
+  result.descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount
+  result.runtimeDescriptorArray = runtimeDescriptorArray
+  result.samplerFilterMinmax = samplerFilterMinmax
+  result.scalarBlockLayout = scalarBlockLayout
+  result.imagelessFramebuffer = imagelessFramebuffer
+  result.uniformBufferStandardLayout = uniformBufferStandardLayout
+  result.shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes
+  result.separateDepthStencilLayouts = separateDepthStencilLayouts
+  result.hostQueryReset = hostQueryReset
+  result.timelineSemaphore = timelineSemaphore
+  result.bufferDeviceAddress = bufferDeviceAddress
+  result.bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay
+  result.bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice
+  result.vulkanMemoryModel = vulkanMemoryModel
+  result.vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope
+  result.vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains
+  result.shaderOutputViewportIndex = shaderOutputViewportIndex
+  result.shaderOutputLayer = shaderOutputLayer
+  result.subgroupBroadcastDynamicId = subgroupBroadcastDynamicId
+
+proc newVkPhysicalDeviceVulkan12Properties*(sType: VkStructureType, pNext: pointer = nil, 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): VkPhysicalDeviceVulkan12Properties =
+  result.sType = sType
+  result.pNext = pNext
+  result.driverID = driverID
+  result.driverName = driverName
+  result.driverInfo = driverInfo
+  result.conformanceVersion = conformanceVersion
+  result.denormBehaviorIndependence = denormBehaviorIndependence
+  result.roundingModeIndependence = roundingModeIndependence
+  result.shaderSignedZeroInfNanPreserveFloat16 = shaderSignedZeroInfNanPreserveFloat16
+  result.shaderSignedZeroInfNanPreserveFloat32 = shaderSignedZeroInfNanPreserveFloat32
+  result.shaderSignedZeroInfNanPreserveFloat64 = shaderSignedZeroInfNanPreserveFloat64
+  result.shaderDenormPreserveFloat16 = shaderDenormPreserveFloat16
+  result.shaderDenormPreserveFloat32 = shaderDenormPreserveFloat32
+  result.shaderDenormPreserveFloat64 = shaderDenormPreserveFloat64
+  result.shaderDenormFlushToZeroFloat16 = shaderDenormFlushToZeroFloat16
+  result.shaderDenormFlushToZeroFloat32 = shaderDenormFlushToZeroFloat32
+  result.shaderDenormFlushToZeroFloat64 = shaderDenormFlushToZeroFloat64
+  result.shaderRoundingModeRTEFloat16 = shaderRoundingModeRTEFloat16
+  result.shaderRoundingModeRTEFloat32 = shaderRoundingModeRTEFloat32
+  result.shaderRoundingModeRTEFloat64 = shaderRoundingModeRTEFloat64
+  result.shaderRoundingModeRTZFloat16 = shaderRoundingModeRTZFloat16
+  result.shaderRoundingModeRTZFloat32 = shaderRoundingModeRTZFloat32
+  result.shaderRoundingModeRTZFloat64 = shaderRoundingModeRTZFloat64
+  result.maxUpdateAfterBindDescriptorsInAllPools = maxUpdateAfterBindDescriptorsInAllPools
+  result.shaderUniformBufferArrayNonUniformIndexingNative = shaderUniformBufferArrayNonUniformIndexingNative
+  result.shaderSampledImageArrayNonUniformIndexingNative = shaderSampledImageArrayNonUniformIndexingNative
+  result.shaderStorageBufferArrayNonUniformIndexingNative = shaderStorageBufferArrayNonUniformIndexingNative
+  result.shaderStorageImageArrayNonUniformIndexingNative = shaderStorageImageArrayNonUniformIndexingNative
+  result.shaderInputAttachmentArrayNonUniformIndexingNative = shaderInputAttachmentArrayNonUniformIndexingNative
+  result.robustBufferAccessUpdateAfterBind = robustBufferAccessUpdateAfterBind
+  result.quadDivergentImplicitLod = quadDivergentImplicitLod
+  result.maxPerStageDescriptorUpdateAfterBindSamplers = maxPerStageDescriptorUpdateAfterBindSamplers
+  result.maxPerStageDescriptorUpdateAfterBindUniformBuffers = maxPerStageDescriptorUpdateAfterBindUniformBuffers
+  result.maxPerStageDescriptorUpdateAfterBindStorageBuffers = maxPerStageDescriptorUpdateAfterBindStorageBuffers
+  result.maxPerStageDescriptorUpdateAfterBindSampledImages = maxPerStageDescriptorUpdateAfterBindSampledImages
+  result.maxPerStageDescriptorUpdateAfterBindStorageImages = maxPerStageDescriptorUpdateAfterBindStorageImages
+  result.maxPerStageDescriptorUpdateAfterBindInputAttachments = maxPerStageDescriptorUpdateAfterBindInputAttachments
+  result.maxPerStageUpdateAfterBindResources = maxPerStageUpdateAfterBindResources
+  result.maxDescriptorSetUpdateAfterBindSamplers = maxDescriptorSetUpdateAfterBindSamplers
+  result.maxDescriptorSetUpdateAfterBindUniformBuffers = maxDescriptorSetUpdateAfterBindUniformBuffers
+  result.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = maxDescriptorSetUpdateAfterBindUniformBuffersDynamic
+  result.maxDescriptorSetUpdateAfterBindStorageBuffers = maxDescriptorSetUpdateAfterBindStorageBuffers
+  result.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = maxDescriptorSetUpdateAfterBindStorageBuffersDynamic
+  result.maxDescriptorSetUpdateAfterBindSampledImages = maxDescriptorSetUpdateAfterBindSampledImages
+  result.maxDescriptorSetUpdateAfterBindStorageImages = maxDescriptorSetUpdateAfterBindStorageImages
+  result.maxDescriptorSetUpdateAfterBindInputAttachments = maxDescriptorSetUpdateAfterBindInputAttachments
+  result.supportedDepthResolveModes = supportedDepthResolveModes
+  result.supportedStencilResolveModes = supportedStencilResolveModes
+  result.independentResolveNone = independentResolveNone
+  result.independentResolve = independentResolve
+  result.filterMinmaxSingleComponentFormats = filterMinmaxSingleComponentFormats
+  result.filterMinmaxImageComponentMapping = filterMinmaxImageComponentMapping
+  result.maxTimelineSemaphoreValueDifference = maxTimelineSemaphoreValueDifference
+  result.framebufferIntegerColorSampleCounts = framebufferIntegerColorSampleCounts
+
+proc newVkPipelineCompilerControlCreateInfoAMD*(sType: VkStructureType, pNext: pointer = nil, compilerControlFlags: VkPipelineCompilerControlFlagsAMD): VkPipelineCompilerControlCreateInfoAMD =
+  result.sType = sType
+  result.pNext = pNext
+  result.compilerControlFlags = compilerControlFlags
+
+proc newVkPhysicalDeviceCoherentMemoryFeaturesAMD*(sType: VkStructureType, pNext: pointer = nil, deviceCoherentMemory: VkBool32): VkPhysicalDeviceCoherentMemoryFeaturesAMD =
+  result.sType = sType
+  result.pNext = pNext
+  result.deviceCoherentMemory = deviceCoherentMemory
+
+proc newVkPhysicalDeviceToolPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, 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]): VkPhysicalDeviceToolPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.name = name
+  result.version = version
+  result.purposes = purposes
+  result.description = description
+  result.layer = layer
+
+proc newVkSamplerCustomBorderColorCreateInfoEXT*(sType: VkStructureType, pNext: pointer = nil, customBorderColor: VkClearColorValue, format: VkFormat): VkSamplerCustomBorderColorCreateInfoEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.customBorderColor = customBorderColor
+  result.format = format
+
+proc newVkPhysicalDeviceCustomBorderColorPropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, maxCustomBorderColorSamplers: uint32): VkPhysicalDeviceCustomBorderColorPropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxCustomBorderColorSamplers = maxCustomBorderColorSamplers
+
+proc newVkPhysicalDeviceCustomBorderColorFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, customBorderColors: VkBool32, customBorderColorWithoutFormat: VkBool32): VkPhysicalDeviceCustomBorderColorFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.customBorderColors = customBorderColors
+  result.customBorderColorWithoutFormat = customBorderColorWithoutFormat
+
+proc newVkAccelerationStructureGeometryTrianglesDataKHR*(sType: VkStructureType, pNext: pointer = nil, vertexFormat: VkFormat, vertexData: VkDeviceOrHostAddressConstKHR, vertexStride: VkDeviceSize, indexType: VkIndexType, indexData: VkDeviceOrHostAddressConstKHR, transformData: VkDeviceOrHostAddressConstKHR): VkAccelerationStructureGeometryTrianglesDataKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.vertexFormat = vertexFormat
+  result.vertexData = vertexData
+  result.vertexStride = vertexStride
+  result.indexType = indexType
+  result.indexData = indexData
+  result.transformData = transformData
+
+proc newVkAccelerationStructureGeometryAabbsDataKHR*(sType: VkStructureType, pNext: pointer = nil, data: VkDeviceOrHostAddressConstKHR, stride: VkDeviceSize): VkAccelerationStructureGeometryAabbsDataKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.data = data
+  result.stride = stride
+
+proc newVkAccelerationStructureGeometryInstancesDataKHR*(sType: VkStructureType, pNext: pointer = nil, arrayOfPointers: VkBool32, data: VkDeviceOrHostAddressConstKHR): VkAccelerationStructureGeometryInstancesDataKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.arrayOfPointers = arrayOfPointers
+  result.data = data
+
+proc newVkAccelerationStructureGeometryKHR*(sType: VkStructureType, pNext: pointer = nil, geometryType: VkGeometryTypeKHR, geometry: VkAccelerationStructureGeometryDataKHR, flags: VkGeometryFlagsKHR = 0.VkGeometryFlagsKHR): VkAccelerationStructureGeometryKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.geometryType = geometryType
+  result.geometry = geometry
+  result.flags = flags
+
+proc newVkAccelerationStructureBuildGeometryInfoKHR*(sType: VkStructureType, pNext: pointer = nil, `type`: VkAccelerationStructureTypeKHR, flags: VkBuildAccelerationStructureFlagsKHR = 0.VkBuildAccelerationStructureFlagsKHR, update: VkBool32, srcAccelerationStructure: VkAccelerationStructureKHR, dstAccelerationStructure: VkAccelerationStructureKHR, geometryArrayOfPointers: VkBool32, geometryCount: uint32, ppGeometries: ptr ptr VkAccelerationStructureGeometryKHR, scratchData: VkDeviceOrHostAddressKHR): VkAccelerationStructureBuildGeometryInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.`type` = `type`
+  result.flags = flags
+  result.update = update
+  result.srcAccelerationStructure = srcAccelerationStructure
+  result.dstAccelerationStructure = dstAccelerationStructure
+  result.geometryArrayOfPointers = geometryArrayOfPointers
+  result.geometryCount = geometryCount
+  result.ppGeometries = ppGeometries
+  result.scratchData = scratchData
+
+proc newVkAccelerationStructureBuildOffsetInfoKHR*(primitiveCount: uint32, primitiveOffset: uint32, firstVertex: uint32, transformOffset: uint32): VkAccelerationStructureBuildOffsetInfoKHR =
+  result.primitiveCount = primitiveCount
+  result.primitiveOffset = primitiveOffset
+  result.firstVertex = firstVertex
+  result.transformOffset = transformOffset
+
+proc newVkAccelerationStructureCreateGeometryTypeInfoKHR*(sType: VkStructureType, pNext: pointer = nil, geometryType: VkGeometryTypeKHR, maxPrimitiveCount: uint32, indexType: VkIndexType, maxVertexCount: uint32, vertexFormat: VkFormat, allowsTransforms: VkBool32): VkAccelerationStructureCreateGeometryTypeInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.geometryType = geometryType
+  result.maxPrimitiveCount = maxPrimitiveCount
+  result.indexType = indexType
+  result.maxVertexCount = maxVertexCount
+  result.vertexFormat = vertexFormat
+  result.allowsTransforms = allowsTransforms
+
+proc newVkAccelerationStructureCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, compactedSize: VkDeviceSize, `type`: VkAccelerationStructureTypeKHR, flags: VkBuildAccelerationStructureFlagsKHR = 0.VkBuildAccelerationStructureFlagsKHR, maxGeometryCount: uint32, pGeometryInfos: ptr VkAccelerationStructureCreateGeometryTypeInfoKHR, deviceAddress: VkDeviceAddress): VkAccelerationStructureCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.compactedSize = compactedSize
+  result.`type` = `type`
+  result.flags = flags
+  result.maxGeometryCount = maxGeometryCount
+  result.pGeometryInfos = pGeometryInfos
+  result.deviceAddress = deviceAddress
+
+proc newVkAabbPositionsKHR*(minX: float32, minY: float32, minZ: float32, maxX: float32, maxY: float32, maxZ: float32): VkAabbPositionsKHR =
+  result.minX = minX
+  result.minY = minY
+  result.minZ = minZ
+  result.maxX = maxX
+  result.maxY = maxY
+  result.maxZ = maxZ
+
+proc newVkTransformMatrixKHR*(matrix: array[3, float32]): VkTransformMatrixKHR =
+  result.matrix = matrix
+
+proc newVkAccelerationStructureInstanceKHR*(transform: VkTransformMatrixKHR, instanceCustomIndex: uint32, mask: uint32, instanceShaderBindingTableRecordOffset: uint32, flags: VkGeometryInstanceFlagsKHR = 0.VkGeometryInstanceFlagsKHR, accelerationStructureReference: uint64): VkAccelerationStructureInstanceKHR =
+  result.transform = transform
+  result.instanceCustomIndex = instanceCustomIndex
+  result.mask = mask
+  result.instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset
+  result.flags = flags
+  result.accelerationStructureReference = accelerationStructureReference
+
+proc newVkAccelerationStructureDeviceAddressInfoKHR*(sType: VkStructureType, pNext: pointer = nil, accelerationStructure: VkAccelerationStructureKHR): VkAccelerationStructureDeviceAddressInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.accelerationStructure = accelerationStructure
+
+proc newVkAccelerationStructureVersionKHR*(sType: VkStructureType, pNext: pointer = nil, versionData: ptr uint8): VkAccelerationStructureVersionKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.versionData = versionData
+
+proc newVkCopyAccelerationStructureInfoKHR*(sType: VkStructureType, pNext: pointer = nil, src: VkAccelerationStructureKHR, dst: VkAccelerationStructureKHR, mode: VkCopyAccelerationStructureModeKHR): VkCopyAccelerationStructureInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.src = src
+  result.dst = dst
+  result.mode = mode
+
+proc newVkCopyAccelerationStructureToMemoryInfoKHR*(sType: VkStructureType, pNext: pointer = nil, src: VkAccelerationStructureKHR, dst: VkDeviceOrHostAddressKHR, mode: VkCopyAccelerationStructureModeKHR): VkCopyAccelerationStructureToMemoryInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.src = src
+  result.dst = dst
+  result.mode = mode
+
+proc newVkCopyMemoryToAccelerationStructureInfoKHR*(sType: VkStructureType, pNext: pointer = nil, src: VkDeviceOrHostAddressConstKHR, dst: VkAccelerationStructureKHR, mode: VkCopyAccelerationStructureModeKHR): VkCopyMemoryToAccelerationStructureInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.src = src
+  result.dst = dst
+  result.mode = mode
+
+proc newVkRayTracingPipelineInterfaceCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, maxPayloadSize: uint32, maxAttributeSize: uint32, maxCallableSize: uint32): VkRayTracingPipelineInterfaceCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.maxPayloadSize = maxPayloadSize
+  result.maxAttributeSize = maxAttributeSize
+  result.maxCallableSize = maxCallableSize
+
+proc newVkDeferredOperationInfoKHR*(sType: VkStructureType, pNext: pointer = nil, operationHandle: VkDeferredOperationKHR): VkDeferredOperationInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.operationHandle = operationHandle
+
+proc newVkPipelineLibraryCreateInfoKHR*(sType: VkStructureType, pNext: pointer = nil, libraryCount: uint32, pLibraries: ptr VkPipeline): VkPipelineLibraryCreateInfoKHR =
+  result.sType = sType
+  result.pNext = pNext
+  result.libraryCount = libraryCount
+  result.pLibraries = pLibraries
+
+proc newVkPhysicalDeviceExtendedDynamicStateFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, extendedDynamicState: VkBool32): VkPhysicalDeviceExtendedDynamicStateFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.extendedDynamicState = extendedDynamicState
+
+proc newVkRenderPassTransformBeginInfoQCOM*(sType: VkStructureType, pNext: pointer = nil, transform: VkSurfaceTransformFlagBitsKHR): VkRenderPassTransformBeginInfoQCOM =
+  result.sType = sType
+  result.pNext = pNext
+  result.transform = transform
+
+proc newVkCommandBufferInheritanceRenderPassTransformInfoQCOM*(sType: VkStructureType, pNext: pointer = nil, transform: VkSurfaceTransformFlagBitsKHR, renderArea: VkRect2D): VkCommandBufferInheritanceRenderPassTransformInfoQCOM =
+  result.sType = sType
+  result.pNext = pNext
+  result.transform = transform
+  result.renderArea = renderArea
+
+proc newVkPhysicalDeviceDiagnosticsConfigFeaturesNV*(sType: VkStructureType, pNext: pointer = nil, diagnosticsConfig: VkBool32): VkPhysicalDeviceDiagnosticsConfigFeaturesNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.diagnosticsConfig = diagnosticsConfig
+
+proc newVkDeviceDiagnosticsConfigCreateInfoNV*(sType: VkStructureType, pNext: pointer = nil, flags: VkDeviceDiagnosticsConfigFlagsNV = 0.VkDeviceDiagnosticsConfigFlagsNV): VkDeviceDiagnosticsConfigCreateInfoNV =
+  result.sType = sType
+  result.pNext = pNext
+  result.flags = flags
+
+proc newVkPhysicalDeviceRobustness2FeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, robustBufferAccess2: VkBool32, robustImageAccess2: VkBool32, nullDescriptor: VkBool32): VkPhysicalDeviceRobustness2FeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.robustBufferAccess2 = robustBufferAccess2
+  result.robustImageAccess2 = robustImageAccess2
+  result.nullDescriptor = nullDescriptor
+
+proc newVkPhysicalDeviceRobustness2PropertiesEXT*(sType: VkStructureType, pNext: pointer = nil, robustStorageBufferAccessSizeAlignment: VkDeviceSize, robustUniformBufferAccessSizeAlignment: VkDeviceSize): VkPhysicalDeviceRobustness2PropertiesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.robustStorageBufferAccessSizeAlignment = robustStorageBufferAccessSizeAlignment
+  result.robustUniformBufferAccessSizeAlignment = robustUniformBufferAccessSizeAlignment
+
+proc newVkPhysicalDeviceImageRobustnessFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, robustImageAccess: VkBool32): VkPhysicalDeviceImageRobustnessFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.robustImageAccess = robustImageAccess
+
+proc newVkPhysicalDevice4444FormatsFeaturesEXT*(sType: VkStructureType, pNext: pointer = nil, formatA4R4G4B4: VkBool32, formatA4B4G4R4: VkBool32): VkPhysicalDevice4444FormatsFeaturesEXT =
+  result.sType = sType
+  result.pNext = pNext
+  result.formatA4R4G4B4 = formatA4R4G4B4
+  result.formatA4B4G4R4 = formatA4B4G4R4
+
+# 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, `type`: 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, `type`: 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, renderPass: VkRenderPass, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}
+  vkGetRenderAreaGranularity*: proc(device: VkDevice, renderPass: 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, `type`: 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*() =
+  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, `type`: 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, `type`: 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, renderPass: VkRenderPass, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyRenderPass"))
+  vkGetRenderAreaGranularity = cast[proc(device: VkDevice, renderPass: 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"))
+
+# Vulkan 1_1
+proc vkLoad1_1*() =
+  vkEnumerateInstanceVersion = cast[proc(pApiVersion: ptr uint32 ): VkResult {.stdcall.}](vkGetProc("vkEnumerateInstanceVersion"))
+  vkBindBufferMemory2 = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindBufferMemoryInfo ): VkResult {.stdcall.}](vkGetProc("vkBindBufferMemory2"))
+  vkBindImageMemory2 = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindImageMemoryInfo ): VkResult {.stdcall.}](vkGetProc("vkBindImageMemory2"))
+  vkGetDeviceGroupPeerMemoryFeatures = cast[proc(device: VkDevice, heapIndex: uint32, localDeviceIndex: uint32, remoteDeviceIndex: uint32, pPeerMemoryFeatures: ptr VkPeerMemoryFeatureFlags ): void {.stdcall.}](vkGetProc("vkGetDeviceGroupPeerMemoryFeatures"))
+  vkCmdSetDeviceMask = cast[proc(commandBuffer: VkCommandBuffer, deviceMask: uint32): void {.stdcall.}](vkGetProc("vkCmdSetDeviceMask"))
+  vkCmdDispatchBase = cast[proc(commandBuffer: VkCommandBuffer, baseGroupX: uint32, baseGroupY: uint32, baseGroupZ: uint32, groupCountX: uint32, groupCountY: uint32, groupCountZ: uint32): void {.stdcall.}](vkGetProc("vkCmdDispatchBase"))
+  vkEnumeratePhysicalDeviceGroups = cast[proc(instance: VkInstance, pPhysicalDeviceGroupCount: ptr uint32 , pPhysicalDeviceGroupProperties: ptr VkPhysicalDeviceGroupProperties ): VkResult {.stdcall.}](vkGetProc("vkEnumeratePhysicalDeviceGroups"))
+  vkGetImageMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkImageMemoryRequirementsInfo2 , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}](vkGetProc("vkGetImageMemoryRequirements2"))
+  vkGetBufferMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkBufferMemoryRequirementsInfo2 , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}](vkGetProc("vkGetBufferMemoryRequirements2"))
+  vkGetImageSparseMemoryRequirements2 = cast[proc(device: VkDevice, pInfo: ptr VkImageSparseMemoryRequirementsInfo2 , pSparseMemoryRequirementCount: ptr uint32 , pSparseMemoryRequirements: ptr VkSparseImageMemoryRequirements2 ): void {.stdcall.}](vkGetProc("vkGetImageSparseMemoryRequirements2"))
+  vkGetPhysicalDeviceFeatures2 = cast[proc(physicalDevice: VkPhysicalDevice, pFeatures: ptr VkPhysicalDeviceFeatures2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceFeatures2"))
+  vkGetPhysicalDeviceProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pProperties: ptr VkPhysicalDeviceProperties2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceProperties2"))
+  vkGetPhysicalDeviceFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: ptr VkFormatProperties2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceFormatProperties2"))
+  vkGetPhysicalDeviceImageFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pImageFormatInfo: ptr VkPhysicalDeviceImageFormatInfo2 , pImageFormatProperties: ptr VkImageFormatProperties2 ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceImageFormatProperties2"))
+  vkGetPhysicalDeviceQueueFamilyProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: ptr uint32 , pQueueFamilyProperties: ptr VkQueueFamilyProperties2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceQueueFamilyProperties2"))
+  vkGetPhysicalDeviceMemoryProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pMemoryProperties: ptr VkPhysicalDeviceMemoryProperties2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceMemoryProperties2"))
+  vkGetPhysicalDeviceSparseImageFormatProperties2 = cast[proc(physicalDevice: VkPhysicalDevice, pFormatInfo: ptr VkPhysicalDeviceSparseImageFormatInfo2 , pPropertyCount: ptr uint32 , pProperties: ptr VkSparseImageFormatProperties2 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSparseImageFormatProperties2"))
+  vkTrimCommandPool = cast[proc(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags): void {.stdcall.}](vkGetProc("vkTrimCommandPool"))
+  vkGetDeviceQueue2 = cast[proc(device: VkDevice, pQueueInfo: ptr VkDeviceQueueInfo2 , pQueue: ptr VkQueue ): void {.stdcall.}](vkGetProc("vkGetDeviceQueue2"))
+  vkCreateSamplerYcbcrConversion = cast[proc(device: VkDevice, pCreateInfo: ptr VkSamplerYcbcrConversionCreateInfo , pAllocator: ptr VkAllocationCallbacks , pYcbcrConversion: ptr VkSamplerYcbcrConversion ): VkResult {.stdcall.}](vkGetProc("vkCreateSamplerYcbcrConversion"))
+  vkDestroySamplerYcbcrConversion = cast[proc(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySamplerYcbcrConversion"))
+  vkCreateDescriptorUpdateTemplate = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorUpdateTemplateCreateInfo , pAllocator: ptr VkAllocationCallbacks , pDescriptorUpdateTemplate: ptr VkDescriptorUpdateTemplate ): VkResult {.stdcall.}](vkGetProc("vkCreateDescriptorUpdateTemplate"))
+  vkDestroyDescriptorUpdateTemplate = cast[proc(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDescriptorUpdateTemplate"))
+  vkUpdateDescriptorSetWithTemplate = cast[proc(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: pointer ): void {.stdcall.}](vkGetProc("vkUpdateDescriptorSetWithTemplate"))
+  vkGetPhysicalDeviceExternalBufferProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: ptr VkPhysicalDeviceExternalBufferInfo , pExternalBufferProperties: ptr VkExternalBufferProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceExternalBufferProperties"))
+  vkGetPhysicalDeviceExternalFenceProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: ptr VkPhysicalDeviceExternalFenceInfo , pExternalFenceProperties: ptr VkExternalFenceProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceExternalFenceProperties"))
+  vkGetPhysicalDeviceExternalSemaphoreProperties = cast[proc(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: ptr VkPhysicalDeviceExternalSemaphoreInfo , pExternalSemaphoreProperties: ptr VkExternalSemaphoreProperties ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceExternalSemaphoreProperties"))
+  vkGetDescriptorSetLayoutSupport = cast[proc(device: VkDevice, pCreateInfo: ptr VkDescriptorSetLayoutCreateInfo , pSupport: ptr VkDescriptorSetLayoutSupport ): void {.stdcall.}](vkGetProc("vkGetDescriptorSetLayoutSupport"))
+
+# Vulkan 1_2
+proc vkLoad1_2*() =
+  vkCmdDrawIndirectCount = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndirectCount"))
+  vkCmdDrawIndexedIndirectCount = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndexedIndirectCount"))
+  vkCreateRenderPass2 = cast[proc(device: VkDevice, pCreateInfo: ptr VkRenderPassCreateInfo2 , pAllocator: ptr VkAllocationCallbacks , pRenderPass: ptr VkRenderPass ): VkResult {.stdcall.}](vkGetProc("vkCreateRenderPass2"))
+  vkCmdBeginRenderPass2 = cast[proc(commandBuffer: VkCommandBuffer, pRenderPassBegin: ptr VkRenderPassBeginInfo      , pSubpassBeginInfo: ptr VkSubpassBeginInfo      ): void {.stdcall.}](vkGetProc("vkCmdBeginRenderPass2"))
+  vkCmdNextSubpass2 = cast[proc(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: ptr VkSubpassBeginInfo      , pSubpassEndInfo: ptr VkSubpassEndInfo        ): void {.stdcall.}](vkGetProc("vkCmdNextSubpass2"))
+  vkCmdEndRenderPass2 = cast[proc(commandBuffer: VkCommandBuffer, pSubpassEndInfo: ptr VkSubpassEndInfo        ): void {.stdcall.}](vkGetProc("vkCmdEndRenderPass2"))
+  vkResetQueryPool = cast[proc(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32, queryCount: uint32): void {.stdcall.}](vkGetProc("vkResetQueryPool"))
+  vkGetSemaphoreCounterValue = cast[proc(device: VkDevice, semaphore: VkSemaphore, pValue: ptr uint64 ): VkResult {.stdcall.}](vkGetProc("vkGetSemaphoreCounterValue"))
+  vkWaitSemaphores = cast[proc(device: VkDevice, pWaitInfo: ptr VkSemaphoreWaitInfo , timeout: uint64): VkResult {.stdcall.}](vkGetProc("vkWaitSemaphores"))
+  vkSignalSemaphore = cast[proc(device: VkDevice, pSignalInfo: ptr VkSemaphoreSignalInfo ): VkResult {.stdcall.}](vkGetProc("vkSignalSemaphore"))
+  vkGetBufferDeviceAddress = cast[proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo ): VkDeviceAddress {.stdcall.}](vkGetProc("vkGetBufferDeviceAddress"))
+  vkGetBufferOpaqueCaptureAddress = cast[proc(device: VkDevice, pInfo: ptr VkBufferDeviceAddressInfo ): uint64 {.stdcall.}](vkGetProc("vkGetBufferOpaqueCaptureAddress"))
+  vkGetDeviceMemoryOpaqueCaptureAddress = cast[proc(device: VkDevice, pInfo: ptr VkDeviceMemoryOpaqueCaptureAddressInfo ): uint64 {.stdcall.}](vkGetProc("vkGetDeviceMemoryOpaqueCaptureAddress"))
+
+# Load VK_KHR_surface
+proc loadVK_KHR_surface*() =
+  vkDestroySurfaceKHR = cast[proc(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySurfaceKHR"))
+  vkGetPhysicalDeviceSurfaceSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, surface: VkSurfaceKHR, pSupported: ptr VkBool32 ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceSupportKHR"))
+  vkGetPhysicalDeviceSurfaceCapabilitiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilitiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))
+  vkGetPhysicalDeviceSurfaceFormatsKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: ptr uint32 , pSurfaceFormats: ptr VkSurfaceFormatKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceFormatsKHR"))
+  vkGetPhysicalDeviceSurfacePresentModesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: ptr uint32 , pPresentModes: ptr VkPresentModeKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfacePresentModesKHR"))
+
+# Load VK_KHR_swapchain
+proc loadVK_KHR_swapchain*() =
+  vkCreateSwapchainKHR = cast[proc(device: VkDevice, pCreateInfo: ptr VkSwapchainCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSwapchain: ptr VkSwapchainKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateSwapchainKHR"))
+  vkDestroySwapchainKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroySwapchainKHR"))
+  vkGetSwapchainImagesKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: ptr uint32 , pSwapchainImages: ptr VkImage ): VkResult {.stdcall.}](vkGetProc("vkGetSwapchainImagesKHR"))
+  vkAcquireNextImageKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, timeout: uint64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: ptr uint32 ): VkResult {.stdcall.}](vkGetProc("vkAcquireNextImageKHR"))
+  vkQueuePresentKHR = cast[proc(queue: VkQueue, pPresentInfo: ptr VkPresentInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkQueuePresentKHR"))
+  vkGetDeviceGroupPresentCapabilitiesKHR = cast[proc(device: VkDevice, pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupPresentCapabilitiesKHR"))
+  vkGetDeviceGroupSurfacePresentModesKHR = cast[proc(device: VkDevice, surface: VkSurfaceKHR, pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupSurfacePresentModesKHR"))
+  vkGetPhysicalDevicePresentRectanglesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: ptr uint32 , pRects: ptr VkRect2D ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDevicePresentRectanglesKHR"))
+  vkAcquireNextImage2KHR = cast[proc(device: VkDevice, pAcquireInfo: ptr VkAcquireNextImageInfoKHR , pImageIndex: ptr uint32 ): VkResult {.stdcall.}](vkGetProc("vkAcquireNextImage2KHR"))
+
+# Load VK_KHR_display
+proc loadVK_KHR_display*() =
+  vkGetPhysicalDeviceDisplayPropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceDisplayPropertiesKHR"))
+  vkGetPhysicalDeviceDisplayPlanePropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPlanePropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
+  vkGetDisplayPlaneSupportedDisplaysKHR = cast[proc(physicalDevice: VkPhysicalDevice, planeIndex: uint32, pDisplayCount: ptr uint32 , pDisplays: ptr VkDisplayKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDisplayPlaneSupportedDisplaysKHR"))
+  vkGetDisplayModePropertiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayModePropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDisplayModePropertiesKHR"))
+  vkCreateDisplayModeKHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: ptr VkDisplayModeCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pMode: ptr VkDisplayModeKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateDisplayModeKHR"))
+  vkGetDisplayPlaneCapabilitiesKHR = cast[proc(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: uint32, pCapabilities: ptr VkDisplayPlaneCapabilitiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDisplayPlaneCapabilitiesKHR"))
+  vkCreateDisplayPlaneSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDisplaySurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateDisplayPlaneSurfaceKHR"))
+
+# Load VK_KHR_display_swapchain
+proc loadVK_KHR_display_swapchain*() =
+  vkCreateSharedSwapchainsKHR = cast[proc(device: VkDevice, swapchainCount: uint32, pCreateInfos: ptr VkSwapchainCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSwapchains: ptr VkSwapchainKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateSharedSwapchainsKHR"))
+
+# Load VK_KHR_xlib_surface
+proc loadVK_KHR_xlib_surface*() =
+  vkCreateXlibSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkXlibSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateXlibSurfaceKHR"))
+  vkGetPhysicalDeviceXlibPresentationSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, dpy: ptr Display , visualID: VisualID): VkBool32 {.stdcall.}](vkGetProc("vkGetPhysicalDeviceXlibPresentationSupportKHR"))
+
+# Load VK_KHR_xcb_surface
+proc loadVK_KHR_xcb_surface*() =
+  vkCreateXcbSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkXcbSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateXcbSurfaceKHR"))
+  vkGetPhysicalDeviceXcbPresentationSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, connection: ptr xcb_connection_t , visual_id: xcb_visualid_t): VkBool32 {.stdcall.}](vkGetProc("vkGetPhysicalDeviceXcbPresentationSupportKHR"))
+
+# Load VK_KHR_wayland_surface
+proc loadVK_KHR_wayland_surface*() =
+  vkCreateWaylandSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkWaylandSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateWaylandSurfaceKHR"))
+  vkGetPhysicalDeviceWaylandPresentationSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, display: ptr wl_display ): VkBool32 {.stdcall.}](vkGetProc("vkGetPhysicalDeviceWaylandPresentationSupportKHR"))
+
+# Load VK_KHR_android_surface
+proc loadVK_KHR_android_surface*() =
+  vkCreateAndroidSurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkAndroidSurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateAndroidSurfaceKHR"))
+
+# Load VK_KHR_win32_surface
+proc loadVK_KHR_win32_surface*() =
+  vkCreateWin32SurfaceKHR = cast[proc(instance: VkInstance, pCreateInfo: ptr VkWin32SurfaceCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateWin32SurfaceKHR"))
+  vkGetPhysicalDeviceWin32PresentationSupportKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32): VkBool32 {.stdcall.}](vkGetProc("vkGetPhysicalDeviceWin32PresentationSupportKHR"))
+
+# Load VK_ANDROID_native_buffer
+proc loadVK_ANDROID_native_buffer*() =
+  vkGetSwapchainGrallocUsageANDROID = cast[proc(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, grallocUsage: ptr int ): VkResult {.stdcall.}](vkGetProc("vkGetSwapchainGrallocUsageANDROID"))
+  vkAcquireImageANDROID = cast[proc(device: VkDevice, image: VkImage, nativeFenceFd: int, semaphore: VkSemaphore, fence: VkFence): VkResult {.stdcall.}](vkGetProc("vkAcquireImageANDROID"))
+  vkQueueSignalReleaseImageANDROID = cast[proc(queue: VkQueue, waitSemaphoreCount: uint32, pWaitSemaphores: ptr VkSemaphore , image: VkImage, pNativeFenceFd: ptr int ): VkResult {.stdcall.}](vkGetProc("vkQueueSignalReleaseImageANDROID"))
+  vkGetSwapchainGrallocUsage2ANDROID = cast[proc(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, swapchainImageUsage: VkSwapchainImageUsageFlagsANDROID, grallocConsumerUsage: ptr uint64 , grallocProducerUsage: ptr uint64 ): VkResult {.stdcall.}](vkGetProc("vkGetSwapchainGrallocUsage2ANDROID"))
+
+# Load VK_EXT_debug_report
+proc loadVK_EXT_debug_report*() =
+  vkCreateDebugReportCallbackEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDebugReportCallbackCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pCallback: ptr VkDebugReportCallbackEXT ): VkResult {.stdcall.}](vkGetProc("vkCreateDebugReportCallbackEXT"))
+  vkDestroyDebugReportCallbackEXT = cast[proc(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDebugReportCallbackEXT"))
+  vkDebugReportMessageEXT = cast[proc(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, `object`: uint64, location: uint, messageCode: int32, pLayerPrefix: cstring , pMessage: cstring ): void {.stdcall.}](vkGetProc("vkDebugReportMessageEXT"))
+
+# Load VK_EXT_debug_marker
+proc loadVK_EXT_debug_marker*() =
+  vkDebugMarkerSetObjectTagEXT = cast[proc(device: VkDevice, pTagInfo: ptr VkDebugMarkerObjectTagInfoEXT ): VkResult {.stdcall.}](vkGetProc("vkDebugMarkerSetObjectTagEXT"))
+  vkDebugMarkerSetObjectNameEXT = cast[proc(device: VkDevice, pNameInfo: ptr VkDebugMarkerObjectNameInfoEXT ): VkResult {.stdcall.}](vkGetProc("vkDebugMarkerSetObjectNameEXT"))
+  vkCmdDebugMarkerBeginEXT = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT ): void {.stdcall.}](vkGetProc("vkCmdDebugMarkerBeginEXT"))
+  vkCmdDebugMarkerEndEXT = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetProc("vkCmdDebugMarkerEndEXT"))
+  vkCmdDebugMarkerInsertEXT = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkDebugMarkerMarkerInfoEXT ): void {.stdcall.}](vkGetProc("vkCmdDebugMarkerInsertEXT"))
+
+# Load VK_EXT_transform_feedback
+proc loadVK_EXT_transform_feedback*() =
+  vkCmdBindTransformFeedbackBuffersEXT = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize , pSizes: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkCmdBindTransformFeedbackBuffersEXT"))
+  vkCmdBeginTransformFeedbackEXT = cast[proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer , pCounterBufferOffsets: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkCmdBeginTransformFeedbackEXT"))
+  vkCmdEndTransformFeedbackEXT = cast[proc(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32, counterBufferCount: uint32, pCounterBuffers: ptr VkBuffer , pCounterBufferOffsets: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkCmdEndTransformFeedbackEXT"))
+  vkCmdBeginQueryIndexedEXT = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, flags: VkQueryControlFlags, index: uint32): void {.stdcall.}](vkGetProc("vkCmdBeginQueryIndexedEXT"))
+  vkCmdEndQueryIndexedEXT = cast[proc(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32, index: uint32): void {.stdcall.}](vkGetProc("vkCmdEndQueryIndexedEXT"))
+  vkCmdDrawIndirectByteCountEXT = cast[proc(commandBuffer: VkCommandBuffer, instanceCount: uint32, firstInstance: uint32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: uint32, vertexStride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawIndirectByteCountEXT"))
+
+# Load VK_NVX_image_view_handle
+proc loadVK_NVX_image_view_handle*() =
+  vkGetImageViewHandleNVX = cast[proc(device: VkDevice, pInfo: ptr VkImageViewHandleInfoNVX ): uint32 {.stdcall.}](vkGetProc("vkGetImageViewHandleNVX"))
+  vkGetImageViewAddressNVX = cast[proc(device: VkDevice, imageView: VkImageView, pProperties: ptr VkImageViewAddressPropertiesNVX ): VkResult {.stdcall.}](vkGetProc("vkGetImageViewAddressNVX"))
+
+# Load VK_AMD_shader_info
+proc loadVK_AMD_shader_info*() =
+  vkGetShaderInfoAMD = cast[proc(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: ptr uint , pInfo: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetShaderInfoAMD"))
+
+# Load VK_GGP_stream_descriptor_surface
+proc loadVK_GGP_stream_descriptor_surface*() =
+  vkCreateStreamDescriptorSurfaceGGP = cast[proc(instance: VkInstance, pCreateInfo: ptr VkStreamDescriptorSurfaceCreateInfoGGP , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateStreamDescriptorSurfaceGGP"))
+
+# Load VK_NV_external_memory_capabilities
+proc loadVK_NV_external_memory_capabilities*() =
+  vkGetPhysicalDeviceExternalImageFormatPropertiesNV = cast[proc(physicalDevice: VkPhysicalDevice, format: VkFormat, `type`: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: ptr VkExternalImageFormatPropertiesNV ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceExternalImageFormatPropertiesNV"))
+
+# Load VK_NV_external_memory_win32
+proc loadVK_NV_external_memory_win32*() =
+  vkGetMemoryWin32HandleNV = cast[proc(device: VkDevice, memory: VkDeviceMemory, handleType: VkExternalMemoryHandleTypeFlagsNV, pHandle: ptr HANDLE ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryWin32HandleNV"))
+
+# Load VK_KHR_device_group
+proc loadVK_KHR_device_group*() =
+  vkGetDeviceGroupPresentCapabilitiesKHR = cast[proc(device: VkDevice, pDeviceGroupPresentCapabilities: ptr VkDeviceGroupPresentCapabilitiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupPresentCapabilitiesKHR"))
+  vkGetDeviceGroupSurfacePresentModesKHR = cast[proc(device: VkDevice, surface: VkSurfaceKHR, pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupSurfacePresentModesKHR"))
+  vkGetPhysicalDevicePresentRectanglesKHR = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: ptr uint32 , pRects: ptr VkRect2D ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDevicePresentRectanglesKHR"))
+  vkAcquireNextImage2KHR = cast[proc(device: VkDevice, pAcquireInfo: ptr VkAcquireNextImageInfoKHR , pImageIndex: ptr uint32 ): VkResult {.stdcall.}](vkGetProc("vkAcquireNextImage2KHR"))
+
+# Load VK_NN_vi_surface
+proc loadVK_NN_vi_surface*() =
+  vkCreateViSurfaceNN = cast[proc(instance: VkInstance, pCreateInfo: ptr VkViSurfaceCreateInfoNN , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateViSurfaceNN"))
+
+# Load VK_KHR_external_memory_win32
+proc loadVK_KHR_external_memory_win32*() =
+  vkGetMemoryWin32HandleKHR = cast[proc(device: VkDevice, pGetWin32HandleInfo: ptr VkMemoryGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryWin32HandleKHR"))
+  vkGetMemoryWin32HandlePropertiesKHR = cast[proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, handle: HANDLE, pMemoryWin32HandleProperties: ptr VkMemoryWin32HandlePropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryWin32HandlePropertiesKHR"))
+
+# Load VK_KHR_external_memory_fd
+proc loadVK_KHR_external_memory_fd*() =
+  vkGetMemoryFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkMemoryGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryFdKHR"))
+  vkGetMemoryFdPropertiesKHR = cast[proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: int, pMemoryFdProperties: ptr VkMemoryFdPropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryFdPropertiesKHR"))
+
+# Load VK_KHR_external_semaphore_win32
+proc loadVK_KHR_external_semaphore_win32*() =
+  vkImportSemaphoreWin32HandleKHR = cast[proc(device: VkDevice, pImportSemaphoreWin32HandleInfo: ptr VkImportSemaphoreWin32HandleInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkImportSemaphoreWin32HandleKHR"))
+  vkGetSemaphoreWin32HandleKHR = cast[proc(device: VkDevice, pGetWin32HandleInfo: ptr VkSemaphoreGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}](vkGetProc("vkGetSemaphoreWin32HandleKHR"))
+
+# Load VK_KHR_external_semaphore_fd
+proc loadVK_KHR_external_semaphore_fd*() =
+  vkImportSemaphoreFdKHR = cast[proc(device: VkDevice, pImportSemaphoreFdInfo: ptr VkImportSemaphoreFdInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkImportSemaphoreFdKHR"))
+  vkGetSemaphoreFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkSemaphoreGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}](vkGetProc("vkGetSemaphoreFdKHR"))
+
+# Load VK_KHR_push_descriptor
+proc loadVK_KHR_push_descriptor*() =
+  vkCmdPushDescriptorSetKHR = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32, descriptorWriteCount: uint32, pDescriptorWrites: ptr VkWriteDescriptorSet ): void {.stdcall.}](vkGetProc("vkCmdPushDescriptorSetKHR"))
+  vkCmdPushDescriptorSetWithTemplateKHR = cast[proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer ): void {.stdcall.}](vkGetProc("vkCmdPushDescriptorSetWithTemplateKHR"))
+  vkCmdPushDescriptorSetWithTemplateKHR = cast[proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer ): void {.stdcall.}](vkGetProc("vkCmdPushDescriptorSetWithTemplateKHR"))
+
+# Load VK_EXT_conditional_rendering
+proc loadVK_EXT_conditional_rendering*() =
+  vkCmdBeginConditionalRenderingEXT = cast[proc(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: ptr VkConditionalRenderingBeginInfoEXT ): void {.stdcall.}](vkGetProc("vkCmdBeginConditionalRenderingEXT"))
+  vkCmdEndConditionalRenderingEXT = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetProc("vkCmdEndConditionalRenderingEXT"))
+
+# Load VK_KHR_descriptor_update_template
+proc loadVK_KHR_descriptor_update_template*() =
+  vkCmdPushDescriptorSetWithTemplateKHR = cast[proc(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32, pData: pointer ): void {.stdcall.}](vkGetProc("vkCmdPushDescriptorSetWithTemplateKHR"))
+
+# Load VK_NV_clip_space_w_scaling
+proc loadVK_NV_clip_space_w_scaling*() =
+  vkCmdSetViewportWScalingNV = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pViewportWScalings: ptr VkViewportWScalingNV ): void {.stdcall.}](vkGetProc("vkCmdSetViewportWScalingNV"))
+
+# Load VK_EXT_direct_mode_display
+proc loadVK_EXT_direct_mode_display*() =
+  vkReleaseDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR): VkResult {.stdcall.}](vkGetProc("vkReleaseDisplayEXT"))
+
+# Load VK_EXT_acquire_xlib_display
+proc loadVK_EXT_acquire_xlib_display*() =
+  vkAcquireXlibDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, dpy: ptr Display , display: VkDisplayKHR): VkResult {.stdcall.}](vkGetProc("vkAcquireXlibDisplayEXT"))
+  vkGetRandROutputDisplayEXT = cast[proc(physicalDevice: VkPhysicalDevice, dpy: ptr Display , rrOutput: RROutput, pDisplay: ptr VkDisplayKHR ): VkResult {.stdcall.}](vkGetProc("vkGetRandROutputDisplayEXT"))
+
+# Load VK_EXT_display_surface_counter
+proc loadVK_EXT_display_surface_counter*() =
+  vkGetPhysicalDeviceSurfaceCapabilities2EXT = cast[proc(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: ptr VkSurfaceCapabilities2EXT ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceCapabilities2EXT"))
+
+# Load VK_EXT_display_control
+proc loadVK_EXT_display_control*() =
+  vkDisplayPowerControlEXT = cast[proc(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: ptr VkDisplayPowerInfoEXT ): VkResult {.stdcall.}](vkGetProc("vkDisplayPowerControlEXT"))
+  vkRegisterDeviceEventEXT = cast[proc(device: VkDevice, pDeviceEventInfo: ptr VkDeviceEventInfoEXT , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}](vkGetProc("vkRegisterDeviceEventEXT"))
+  vkRegisterDisplayEventEXT = cast[proc(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: ptr VkDisplayEventInfoEXT , pAllocator: ptr VkAllocationCallbacks , pFence: ptr VkFence ): VkResult {.stdcall.}](vkGetProc("vkRegisterDisplayEventEXT"))
+  vkGetSwapchainCounterEXT = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: ptr uint64 ): VkResult {.stdcall.}](vkGetProc("vkGetSwapchainCounterEXT"))
+
+# Load VK_GOOGLE_display_timing
+proc loadVK_GOOGLE_display_timing*() =
+  vkGetRefreshCycleDurationGOOGLE = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: ptr VkRefreshCycleDurationGOOGLE ): VkResult {.stdcall.}](vkGetProc("vkGetRefreshCycleDurationGOOGLE"))
+  vkGetPastPresentationTimingGOOGLE = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: ptr uint32 , pPresentationTimings: ptr VkPastPresentationTimingGOOGLE ): VkResult {.stdcall.}](vkGetProc("vkGetPastPresentationTimingGOOGLE"))
+
+# Load VK_EXT_discard_rectangles
+proc loadVK_EXT_discard_rectangles*() =
+  vkCmdSetDiscardRectangleEXT = cast[proc(commandBuffer: VkCommandBuffer, firstDiscardRectangle: uint32, discardRectangleCount: uint32, pDiscardRectangles: ptr VkRect2D ): void {.stdcall.}](vkGetProc("vkCmdSetDiscardRectangleEXT"))
+
+# Load VK_EXT_hdr_metadata
+proc loadVK_EXT_hdr_metadata*() =
+  vkSetHdrMetadataEXT = cast[proc(device: VkDevice, swapchainCount: uint32, pSwapchains: ptr VkSwapchainKHR , pMetadata: ptr VkHdrMetadataEXT ): void {.stdcall.}](vkGetProc("vkSetHdrMetadataEXT"))
+
+# Load VK_KHR_shared_presentable_image
+proc loadVK_KHR_shared_presentable_image*() =
+  vkGetSwapchainStatusKHR = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}](vkGetProc("vkGetSwapchainStatusKHR"))
+
+# Load VK_KHR_external_fence_win32
+proc loadVK_KHR_external_fence_win32*() =
+  vkImportFenceWin32HandleKHR = cast[proc(device: VkDevice, pImportFenceWin32HandleInfo: ptr VkImportFenceWin32HandleInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkImportFenceWin32HandleKHR"))
+  vkGetFenceWin32HandleKHR = cast[proc(device: VkDevice, pGetWin32HandleInfo: ptr VkFenceGetWin32HandleInfoKHR , pHandle: ptr HANDLE ): VkResult {.stdcall.}](vkGetProc("vkGetFenceWin32HandleKHR"))
+
+# Load VK_KHR_external_fence_fd
+proc loadVK_KHR_external_fence_fd*() =
+  vkImportFenceFdKHR = cast[proc(device: VkDevice, pImportFenceFdInfo: ptr VkImportFenceFdInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkImportFenceFdKHR"))
+  vkGetFenceFdKHR = cast[proc(device: VkDevice, pGetFdInfo: ptr VkFenceGetFdInfoKHR , pFd: ptr int ): VkResult {.stdcall.}](vkGetProc("vkGetFenceFdKHR"))
+
+# Load VK_KHR_performance_query
+proc loadVK_KHR_performance_query*() =
+  vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, pCounterCount: ptr uint32 , pCounters: ptr VkPerformanceCounterKHR , pCounterDescriptions: ptr VkPerformanceCounterDescriptionKHR ): VkResult {.stdcall.}](vkGetProc("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"))
+  vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = cast[proc(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: ptr VkQueryPoolPerformanceCreateInfoKHR , pNumPasses: ptr uint32 ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"))
+  vkAcquireProfilingLockKHR = cast[proc(device: VkDevice, pInfo: ptr VkAcquireProfilingLockInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkAcquireProfilingLockKHR"))
+  vkReleaseProfilingLockKHR = cast[proc(device: VkDevice): void {.stdcall.}](vkGetProc("vkReleaseProfilingLockKHR"))
+
+# Load VK_KHR_get_surface_capabilities2
+proc loadVK_KHR_get_surface_capabilities2*() =
+  vkGetPhysicalDeviceSurfaceCapabilities2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pSurfaceCapabilities: ptr VkSurfaceCapabilities2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceCapabilities2KHR"))
+  vkGetPhysicalDeviceSurfaceFormats2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pSurfaceFormatCount: ptr uint32 , pSurfaceFormats: ptr VkSurfaceFormat2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfaceFormats2KHR"))
+
+# Load VK_KHR_get_display_properties2
+proc loadVK_KHR_get_display_properties2*() =
+  vkGetPhysicalDeviceDisplayProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayProperties2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceDisplayProperties2KHR"))
+  vkGetPhysicalDeviceDisplayPlaneProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayPlaneProperties2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceDisplayPlaneProperties2KHR"))
+  vkGetDisplayModeProperties2KHR = cast[proc(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: ptr uint32 , pProperties: ptr VkDisplayModeProperties2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetDisplayModeProperties2KHR"))
+  vkGetDisplayPlaneCapabilities2KHR = cast[proc(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: ptr VkDisplayPlaneInfo2KHR , pCapabilities: ptr VkDisplayPlaneCapabilities2KHR ): VkResult {.stdcall.}](vkGetProc("vkGetDisplayPlaneCapabilities2KHR"))
+
+# Load VK_MVK_ios_surface
+proc loadVK_MVK_ios_surface*() =
+  vkCreateIOSSurfaceMVK = cast[proc(instance: VkInstance, pCreateInfo: ptr VkIOSSurfaceCreateInfoMVK , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateIOSSurfaceMVK"))
+
+# Load VK_MVK_macos_surface
+proc loadVK_MVK_macos_surface*() =
+  vkCreateMacOSSurfaceMVK = cast[proc(instance: VkInstance, pCreateInfo: ptr VkMacOSSurfaceCreateInfoMVK , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateMacOSSurfaceMVK"))
+
+# Load VK_EXT_debug_utils
+proc loadVK_EXT_debug_utils*(instance: VkInstance) =
+  vkSetDebugUtilsObjectNameEXT = cast[proc(device: VkDevice, pNameInfo: ptr VkDebugUtilsObjectNameInfoEXT ): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT"))
+  vkSetDebugUtilsObjectTagEXT = cast[proc(device: VkDevice, pTagInfo: ptr VkDebugUtilsObjectTagInfoEXT ): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectTagEXT"))
+  vkQueueBeginDebugUtilsLabelEXT = cast[proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueBeginDebugUtilsLabelEXT"))
+  vkQueueEndDebugUtilsLabelEXT = cast[proc(queue: VkQueue): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueEndDebugUtilsLabelEXT"))
+  vkQueueInsertDebugUtilsLabelEXT = cast[proc(queue: VkQueue, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkQueueInsertDebugUtilsLabelEXT"))
+  vkCmdBeginDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdBeginDebugUtilsLabelEXT"))
+  vkCmdEndDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdEndDebugUtilsLabelEXT"))
+  vkCmdInsertDebugUtilsLabelEXT = cast[proc(commandBuffer: VkCommandBuffer, pLabelInfo: ptr VkDebugUtilsLabelEXT ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCmdInsertDebugUtilsLabelEXT"))
+  vkCreateDebugUtilsMessengerEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDebugUtilsMessengerCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pMessenger: ptr VkDebugUtilsMessengerEXT ): VkResult {.stdcall.}](vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"))
+  vkDestroyDebugUtilsMessengerEXT = cast[proc(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT"))
+  vkSubmitDebugUtilsMessageEXT = cast[proc(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: ptr VkDebugUtilsMessengerCallbackDataEXT ): void {.stdcall.}](vkGetInstanceProcAddr(instance, "vkSubmitDebugUtilsMessageEXT"))
+
+# Load VK_ANDROID_external_memory_android_hardware_buffer
+proc loadVK_ANDROID_external_memory_android_hardware_buffer*() =
+  vkGetAndroidHardwareBufferPropertiesANDROID = cast[proc(device: VkDevice, buffer: ptr AHardwareBuffer , pProperties: ptr VkAndroidHardwareBufferPropertiesANDROID ): VkResult {.stdcall.}](vkGetProc("vkGetAndroidHardwareBufferPropertiesANDROID"))
+  vkGetMemoryAndroidHardwareBufferANDROID = cast[proc(device: VkDevice, pInfo: ptr VkMemoryGetAndroidHardwareBufferInfoANDROID , pBuffer: ptr ptr AHardwareBuffer ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryAndroidHardwareBufferANDROID"))
+
+# Load VK_EXT_sample_locations
+proc loadVK_EXT_sample_locations*() =
+  vkCmdSetSampleLocationsEXT = cast[proc(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: ptr VkSampleLocationsInfoEXT ): void {.stdcall.}](vkGetProc("vkCmdSetSampleLocationsEXT"))
+  vkGetPhysicalDeviceMultisamplePropertiesEXT = cast[proc(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: ptr VkMultisamplePropertiesEXT ): void {.stdcall.}](vkGetProc("vkGetPhysicalDeviceMultisamplePropertiesEXT"))
+
+# Load VK_KHR_ray_tracing
+proc loadVK_KHR_ray_tracing*() =
+  vkCreateAccelerationStructureKHR = cast[proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoKHR        , pAllocator: ptr VkAllocationCallbacks       , pAccelerationStructure: ptr VkAccelerationStructureKHR                        ): VkResult {.stdcall.}](vkGetProc("vkCreateAccelerationStructureKHR"))
+  vkDestroyAccelerationStructureKHR = cast[proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyAccelerationStructureKHR"))
+  vkGetAccelerationStructureMemoryRequirementsKHR = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoKHR , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}](vkGetProc("vkGetAccelerationStructureMemoryRequirementsKHR"))
+  vkBindAccelerationStructureMemoryKHR = cast[proc(device: VkDevice, bindInfoCount: uint32, pBindInfos: ptr VkBindAccelerationStructureMemoryInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkBindAccelerationStructureMemoryKHR"))
+  vkCmdBuildAccelerationStructureKHR = cast[proc(commandBuffer: VkCommandBuffer, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR , ppOffsetInfos: ptr ptr VkAccelerationStructureBuildOffsetInfoKHR ): void {.stdcall.}](vkGetProc("vkCmdBuildAccelerationStructureKHR"))
+  vkCmdBuildAccelerationStructureIndirectKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureBuildGeometryInfoKHR , indirectBuffer: VkBuffer, indirectOffset: VkDeviceSize, indirectStride: uint32): void {.stdcall.}](vkGetProc("vkCmdBuildAccelerationStructureIndirectKHR"))
+  vkBuildAccelerationStructureKHR = cast[proc(device: VkDevice, infoCount: uint32, pInfos: ptr VkAccelerationStructureBuildGeometryInfoKHR , ppOffsetInfos: ptr ptr VkAccelerationStructureBuildOffsetInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkBuildAccelerationStructureKHR"))
+  vkCopyAccelerationStructureKHR = cast[proc(device: VkDevice, pInfo: ptr VkCopyAccelerationStructureInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkCopyAccelerationStructureKHR"))
+  vkCopyAccelerationStructureToMemoryKHR = cast[proc(device: VkDevice, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkCopyAccelerationStructureToMemoryKHR"))
+  vkCopyMemoryToAccelerationStructureKHR = cast[proc(device: VkDevice, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR ): VkResult {.stdcall.}](vkGetProc("vkCopyMemoryToAccelerationStructureKHR"))
+  vkWriteAccelerationStructuresPropertiesKHR = cast[proc(device: VkDevice, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR , queryType: VkQueryType, dataSize: uint, pData: pointer , stride: uint): VkResult {.stdcall.}](vkGetProc("vkWriteAccelerationStructuresPropertiesKHR"))
+  vkCmdCopyAccelerationStructureKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureInfoKHR ): void {.stdcall.}](vkGetProc("vkCmdCopyAccelerationStructureKHR"))
+  vkCmdCopyAccelerationStructureToMemoryKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyAccelerationStructureToMemoryInfoKHR ): void {.stdcall.}](vkGetProc("vkCmdCopyAccelerationStructureToMemoryKHR"))
+  vkCmdCopyMemoryToAccelerationStructureKHR = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkCopyMemoryToAccelerationStructureInfoKHR ): void {.stdcall.}](vkGetProc("vkCmdCopyMemoryToAccelerationStructureKHR"))
+  vkCmdTraceRaysKHR = cast[proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedBufferRegionKHR , pMissShaderBindingTable: ptr VkStridedBufferRegionKHR , pHitShaderBindingTable: ptr VkStridedBufferRegionKHR , pCallableShaderBindingTable: ptr VkStridedBufferRegionKHR , width: uint32, height: uint32, depth: uint32): void {.stdcall.}](vkGetProc("vkCmdTraceRaysKHR"))
+  vkCreateRayTracingPipelinesKHR = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoKHR , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}](vkGetProc("vkCreateRayTracingPipelinesKHR"))
+  vkGetRayTracingShaderGroupHandlesKHR = cast[proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: uint, pData: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetRayTracingShaderGroupHandlesKHR"))
+  vkGetAccelerationStructureDeviceAddressKHR = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureDeviceAddressInfoKHR ): VkDeviceAddress {.stdcall.}](vkGetProc("vkGetAccelerationStructureDeviceAddressKHR"))
+  vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = cast[proc(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32, groupCount: uint32, dataSize: uint, pData: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"))
+  vkCmdWriteAccelerationStructuresPropertiesKHR = cast[proc(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32, pAccelerationStructures: ptr VkAccelerationStructureKHR , queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32): void {.stdcall.}](vkGetProc("vkCmdWriteAccelerationStructuresPropertiesKHR"))
+  vkCmdTraceRaysIndirectKHR = cast[proc(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: ptr VkStridedBufferRegionKHR , pMissShaderBindingTable: ptr VkStridedBufferRegionKHR , pHitShaderBindingTable: ptr VkStridedBufferRegionKHR , pCallableShaderBindingTable: ptr VkStridedBufferRegionKHR , buffer: VkBuffer, offset: VkDeviceSize): void {.stdcall.}](vkGetProc("vkCmdTraceRaysIndirectKHR"))
+  vkGetDeviceAccelerationStructureCompatibilityKHR = cast[proc(device: VkDevice, version: ptr VkAccelerationStructureVersionKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceAccelerationStructureCompatibilityKHR"))
+
+# Load VK_EXT_image_drm_format_modifier
+proc loadVK_EXT_image_drm_format_modifier*() =
+  vkGetImageDrmFormatModifierPropertiesEXT = cast[proc(device: VkDevice, image: VkImage, pProperties: ptr VkImageDrmFormatModifierPropertiesEXT ): VkResult {.stdcall.}](vkGetProc("vkGetImageDrmFormatModifierPropertiesEXT"))
+
+# Load VK_EXT_validation_cache
+proc loadVK_EXT_validation_cache*() =
+  vkCreateValidationCacheEXT = cast[proc(device: VkDevice, pCreateInfo: ptr VkValidationCacheCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pValidationCache: ptr VkValidationCacheEXT ): VkResult {.stdcall.}](vkGetProc("vkCreateValidationCacheEXT"))
+  vkDestroyValidationCacheEXT = cast[proc(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyValidationCacheEXT"))
+  vkMergeValidationCachesEXT = cast[proc(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: uint32, pSrcCaches: ptr VkValidationCacheEXT ): VkResult {.stdcall.}](vkGetProc("vkMergeValidationCachesEXT"))
+  vkGetValidationCacheDataEXT = cast[proc(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: ptr uint , pData: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetValidationCacheDataEXT"))
+
+# Load VK_NV_shading_rate_image
+proc loadVK_NV_shading_rate_image*() =
+  vkCmdBindShadingRateImageNV = cast[proc(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout): void {.stdcall.}](vkGetProc("vkCmdBindShadingRateImageNV"))
+  vkCmdSetViewportShadingRatePaletteNV = cast[proc(commandBuffer: VkCommandBuffer, firstViewport: uint32, viewportCount: uint32, pShadingRatePalettes: ptr VkShadingRatePaletteNV ): void {.stdcall.}](vkGetProc("vkCmdSetViewportShadingRatePaletteNV"))
+  vkCmdSetCoarseSampleOrderNV = cast[proc(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32, pCustomSampleOrders: ptr VkCoarseSampleOrderCustomNV ): void {.stdcall.}](vkGetProc("vkCmdSetCoarseSampleOrderNV"))
+
+# Load VK_NV_ray_tracing
+proc loadVK_NV_ray_tracing*() =
+  vkCreateAccelerationStructureNV = cast[proc(device: VkDevice, pCreateInfo: ptr VkAccelerationStructureCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pAccelerationStructure: ptr VkAccelerationStructureNV ): VkResult {.stdcall.}](vkGetProc("vkCreateAccelerationStructureNV"))
+  vkGetAccelerationStructureMemoryRequirementsNV = cast[proc(device: VkDevice, pInfo: ptr VkAccelerationStructureMemoryRequirementsInfoNV , pMemoryRequirements: ptr VkMemoryRequirements2KHR ): void {.stdcall.}](vkGetProc("vkGetAccelerationStructureMemoryRequirementsNV"))
+  vkCmdBuildAccelerationStructureNV = cast[proc(commandBuffer: VkCommandBuffer, pInfo: ptr VkAccelerationStructureInfoNV , instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureKHR, src: VkAccelerationStructureKHR, scratch: VkBuffer, scratchOffset: VkDeviceSize): void {.stdcall.}](vkGetProc("vkCmdBuildAccelerationStructureNV"))
+  vkCmdCopyAccelerationStructureNV = cast[proc(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureKHR, src: VkAccelerationStructureKHR, mode: VkCopyAccelerationStructureModeKHR): void {.stdcall.}](vkGetProc("vkCmdCopyAccelerationStructureNV"))
+  vkCmdTraceRaysNV = cast[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.}](vkGetProc("vkCmdTraceRaysNV"))
+  vkCreateRayTracingPipelinesNV = cast[proc(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32, pCreateInfos: ptr VkRayTracingPipelineCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pPipelines: ptr VkPipeline ): VkResult {.stdcall.}](vkGetProc("vkCreateRayTracingPipelinesNV"))
+  vkGetAccelerationStructureHandleNV = cast[proc(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, dataSize: uint, pData: pointer ): VkResult {.stdcall.}](vkGetProc("vkGetAccelerationStructureHandleNV"))
+  vkCompileDeferredNV = cast[proc(device: VkDevice, pipeline: VkPipeline, shader: uint32): VkResult {.stdcall.}](vkGetProc("vkCompileDeferredNV"))
+
+# Load VK_EXT_external_memory_host
+proc loadVK_EXT_external_memory_host*() =
+  vkGetMemoryHostPointerPropertiesEXT = cast[proc(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: pointer , pMemoryHostPointerProperties: ptr VkMemoryHostPointerPropertiesEXT ): VkResult {.stdcall.}](vkGetProc("vkGetMemoryHostPointerPropertiesEXT"))
+
+# Load VK_AMD_buffer_marker
+proc loadVK_AMD_buffer_marker*() =
+  vkCmdWriteBufferMarkerAMD = cast[proc(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32): void {.stdcall.}](vkGetProc("vkCmdWriteBufferMarkerAMD"))
+
+# Load VK_EXT_calibrated_timestamps
+proc loadVK_EXT_calibrated_timestamps*() =
+  vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = cast[proc(physicalDevice: VkPhysicalDevice, pTimeDomainCount: ptr uint32 , pTimeDomains: ptr VkTimeDomainEXT ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"))
+  vkGetCalibratedTimestampsEXT = cast[proc(device: VkDevice, timestampCount: uint32, pTimestampInfos: ptr VkCalibratedTimestampInfoEXT , pTimestamps: ptr uint64 , pMaxDeviation: ptr uint64 ): VkResult {.stdcall.}](vkGetProc("vkGetCalibratedTimestampsEXT"))
+
+# Load VK_NV_mesh_shader
+proc loadVK_NV_mesh_shader*() =
+  vkCmdDrawMeshTasksNV = cast[proc(commandBuffer: VkCommandBuffer, taskCount: uint32, firstTask: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawMeshTasksNV"))
+  vkCmdDrawMeshTasksIndirectNV = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawMeshTasksIndirectNV"))
+  vkCmdDrawMeshTasksIndirectCountNV = cast[proc(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32, stride: uint32): void {.stdcall.}](vkGetProc("vkCmdDrawMeshTasksIndirectCountNV"))
+
+# Load VK_NV_scissor_exclusive
+proc loadVK_NV_scissor_exclusive*() =
+  vkCmdSetExclusiveScissorNV = cast[proc(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32, exclusiveScissorCount: uint32, pExclusiveScissors: ptr VkRect2D ): void {.stdcall.}](vkGetProc("vkCmdSetExclusiveScissorNV"))
+
+# Load VK_NV_device_diagnostic_checkpoints
+proc loadVK_NV_device_diagnostic_checkpoints*() =
+  vkCmdSetCheckpointNV = cast[proc(commandBuffer: VkCommandBuffer, pCheckpointMarker: pointer ): void {.stdcall.}](vkGetProc("vkCmdSetCheckpointNV"))
+  vkGetQueueCheckpointDataNV = cast[proc(queue: VkQueue, pCheckpointDataCount: ptr uint32 , pCheckpointData: ptr VkCheckpointDataNV ): void {.stdcall.}](vkGetProc("vkGetQueueCheckpointDataNV"))
+
+# Load VK_INTEL_performance_query
+proc loadVK_INTEL_performance_query*() =
+  vkInitializePerformanceApiINTEL = cast[proc(device: VkDevice, pInitializeInfo: ptr VkInitializePerformanceApiInfoINTEL ): VkResult {.stdcall.}](vkGetProc("vkInitializePerformanceApiINTEL"))
+  vkUninitializePerformanceApiINTEL = cast[proc(device: VkDevice): void {.stdcall.}](vkGetProc("vkUninitializePerformanceApiINTEL"))
+  vkCmdSetPerformanceMarkerINTEL = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceMarkerInfoINTEL ): VkResult {.stdcall.}](vkGetProc("vkCmdSetPerformanceMarkerINTEL"))
+  vkCmdSetPerformanceStreamMarkerINTEL = cast[proc(commandBuffer: VkCommandBuffer, pMarkerInfo: ptr VkPerformanceStreamMarkerInfoINTEL ): VkResult {.stdcall.}](vkGetProc("vkCmdSetPerformanceStreamMarkerINTEL"))
+  vkCmdSetPerformanceOverrideINTEL = cast[proc(commandBuffer: VkCommandBuffer, pOverrideInfo: ptr VkPerformanceOverrideInfoINTEL ): VkResult {.stdcall.}](vkGetProc("vkCmdSetPerformanceOverrideINTEL"))
+  vkAcquirePerformanceConfigurationINTEL = cast[proc(device: VkDevice, pAcquireInfo: ptr VkPerformanceConfigurationAcquireInfoINTEL , pConfiguration: ptr VkPerformanceConfigurationINTEL ): VkResult {.stdcall.}](vkGetProc("vkAcquirePerformanceConfigurationINTEL"))
+  vkReleasePerformanceConfigurationINTEL = cast[proc(device: VkDevice, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}](vkGetProc("vkReleasePerformanceConfigurationINTEL"))
+  vkQueueSetPerformanceConfigurationINTEL = cast[proc(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL): VkResult {.stdcall.}](vkGetProc("vkQueueSetPerformanceConfigurationINTEL"))
+  vkGetPerformanceParameterINTEL = cast[proc(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: ptr VkPerformanceValueINTEL ): VkResult {.stdcall.}](vkGetProc("vkGetPerformanceParameterINTEL"))
+
+# Load VK_AMD_display_native_hdr
+proc loadVK_AMD_display_native_hdr*() =
+  vkSetLocalDimmingAMD = cast[proc(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32): void {.stdcall.}](vkGetProc("vkSetLocalDimmingAMD"))
+
+# Load VK_FUCHSIA_imagepipe_surface
+proc loadVK_FUCHSIA_imagepipe_surface*() =
+  vkCreateImagePipeSurfaceFUCHSIA = cast[proc(instance: VkInstance, pCreateInfo: ptr VkImagePipeSurfaceCreateInfoFUCHSIA , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateImagePipeSurfaceFUCHSIA"))
+
+# Load VK_EXT_metal_surface
+proc loadVK_EXT_metal_surface*() =
+  vkCreateMetalSurfaceEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkMetalSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateMetalSurfaceEXT"))
+
+# Load VK_EXT_tooling_info
+proc loadVK_EXT_tooling_info*() =
+  vkGetPhysicalDeviceToolPropertiesEXT = cast[proc(physicalDevice: VkPhysicalDevice, pToolCount: ptr uint32 , pToolProperties: ptr VkPhysicalDeviceToolPropertiesEXT ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceToolPropertiesEXT"))
+
+# Load VK_NV_cooperative_matrix
+proc loadVK_NV_cooperative_matrix*() =
+  vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = cast[proc(physicalDevice: VkPhysicalDevice, pPropertyCount: ptr uint32 , pProperties: ptr VkCooperativeMatrixPropertiesNV ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"))
+
+# Load VK_NV_coverage_reduction_mode
+proc loadVK_NV_coverage_reduction_mode*() =
+  vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = cast[proc(physicalDevice: VkPhysicalDevice, pCombinationCount: ptr uint32 , pCombinations: ptr VkFramebufferMixedSamplesCombinationNV ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"))
+
+# Load VK_EXT_full_screen_exclusive
+proc loadVK_EXT_full_screen_exclusive*() =
+  vkGetPhysicalDeviceSurfacePresentModes2EXT = cast[proc(physicalDevice: VkPhysicalDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pPresentModeCount: ptr uint32 , pPresentModes: ptr VkPresentModeKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPhysicalDeviceSurfacePresentModes2EXT"))
+  vkAcquireFullScreenExclusiveModeEXT = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}](vkGetProc("vkAcquireFullScreenExclusiveModeEXT"))
+  vkReleaseFullScreenExclusiveModeEXT = cast[proc(device: VkDevice, swapchain: VkSwapchainKHR): VkResult {.stdcall.}](vkGetProc("vkReleaseFullScreenExclusiveModeEXT"))
+  vkGetDeviceGroupSurfacePresentModes2EXT = cast[proc(device: VkDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupSurfacePresentModes2EXT"))
+  vkGetDeviceGroupSurfacePresentModes2EXT = cast[proc(device: VkDevice, pSurfaceInfo: ptr VkPhysicalDeviceSurfaceInfo2KHR , pModes: ptr VkDeviceGroupPresentModeFlagsKHR ): VkResult {.stdcall.}](vkGetProc("vkGetDeviceGroupSurfacePresentModes2EXT"))
+
+# Load VK_EXT_headless_surface
+proc loadVK_EXT_headless_surface*() =
+  vkCreateHeadlessSurfaceEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkHeadlessSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateHeadlessSurfaceEXT"))
+
+# Load VK_EXT_line_rasterization
+proc loadVK_EXT_line_rasterization*() =
+  vkCmdSetLineStippleEXT = cast[proc(commandBuffer: VkCommandBuffer, lineStippleFactor: uint32, lineStipplePattern: uint16): void {.stdcall.}](vkGetProc("vkCmdSetLineStippleEXT"))
+
+# Load VK_EXT_extended_dynamic_state
+proc loadVK_EXT_extended_dynamic_state*() =
+  vkCmdSetCullModeEXT = cast[proc(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags): void {.stdcall.}](vkGetProc("vkCmdSetCullModeEXT"))
+  vkCmdSetFrontFaceEXT = cast[proc(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace): void {.stdcall.}](vkGetProc("vkCmdSetFrontFaceEXT"))
+  vkCmdSetPrimitiveTopologyEXT = cast[proc(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology): void {.stdcall.}](vkGetProc("vkCmdSetPrimitiveTopologyEXT"))
+  vkCmdSetViewportWithCountEXT = cast[proc(commandBuffer: VkCommandBuffer, viewportCount: uint32, pViewports: ptr VkViewport ): void {.stdcall.}](vkGetProc("vkCmdSetViewportWithCountEXT"))
+  vkCmdSetScissorWithCountEXT = cast[proc(commandBuffer: VkCommandBuffer, scissorCount: uint32, pScissors: ptr VkRect2D ): void {.stdcall.}](vkGetProc("vkCmdSetScissorWithCountEXT"))
+  vkCmdBindVertexBuffers2EXT = cast[proc(commandBuffer: VkCommandBuffer, firstBinding: uint32, bindingCount: uint32, pBuffers: ptr VkBuffer , pOffsets: ptr VkDeviceSize , pSizes: ptr VkDeviceSize , pStrides: ptr VkDeviceSize ): void {.stdcall.}](vkGetProc("vkCmdBindVertexBuffers2EXT"))
+  vkCmdSetDepthTestEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32): void {.stdcall.}](vkGetProc("vkCmdSetDepthTestEnableEXT"))
+  vkCmdSetDepthWriteEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32): void {.stdcall.}](vkGetProc("vkCmdSetDepthWriteEnableEXT"))
+  vkCmdSetDepthCompareOpEXT = cast[proc(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp): void {.stdcall.}](vkGetProc("vkCmdSetDepthCompareOpEXT"))
+  vkCmdSetDepthBoundsTestEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32): void {.stdcall.}](vkGetProc("vkCmdSetDepthBoundsTestEnableEXT"))
+  vkCmdSetStencilTestEnableEXT = cast[proc(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32): void {.stdcall.}](vkGetProc("vkCmdSetStencilTestEnableEXT"))
+  vkCmdSetStencilOpEXT = cast[proc(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp): void {.stdcall.}](vkGetProc("vkCmdSetStencilOpEXT"))
+
+# Load VK_KHR_deferred_host_operations
+proc loadVK_KHR_deferred_host_operations*() =
+  vkCreateDeferredOperationKHR = cast[proc(device: VkDevice, pAllocator: ptr VkAllocationCallbacks , pDeferredOperation: ptr VkDeferredOperationKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateDeferredOperationKHR"))
+  vkDestroyDeferredOperationKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyDeferredOperationKHR"))
+  vkGetDeferredOperationMaxConcurrencyKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): uint32 {.stdcall.}](vkGetProc("vkGetDeferredOperationMaxConcurrencyKHR"))
+  vkGetDeferredOperationResultKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}](vkGetProc("vkGetDeferredOperationResultKHR"))
+  vkDeferredOperationJoinKHR = cast[proc(device: VkDevice, operation: VkDeferredOperationKHR): VkResult {.stdcall.}](vkGetProc("vkDeferredOperationJoinKHR"))
+
+# Load VK_KHR_pipeline_executable_properties
+proc loadVK_KHR_pipeline_executable_properties*() =
+  vkGetPipelineExecutablePropertiesKHR = cast[proc(device: VkDevice, pPipelineInfo: ptr VkPipelineInfoKHR        , pExecutableCount: ptr uint32 , pProperties: ptr VkPipelineExecutablePropertiesKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPipelineExecutablePropertiesKHR"))
+  vkGetPipelineExecutableStatisticsKHR = cast[proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR  , pStatisticCount: ptr uint32 , pStatistics: ptr VkPipelineExecutableStatisticKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPipelineExecutableStatisticsKHR"))
+  vkGetPipelineExecutableInternalRepresentationsKHR = cast[proc(device: VkDevice, pExecutableInfo: ptr VkPipelineExecutableInfoKHR  , pInternalRepresentationCount: ptr uint32 , pInternalRepresentations: ptr VkPipelineExecutableInternalRepresentationKHR ): VkResult {.stdcall.}](vkGetProc("vkGetPipelineExecutableInternalRepresentationsKHR"))
+
+# Load VK_NV_device_generated_commands
+proc loadVK_NV_device_generated_commands*() =
+  vkGetGeneratedCommandsMemoryRequirementsNV = cast[proc(device: VkDevice, pInfo: ptr VkGeneratedCommandsMemoryRequirementsInfoNV , pMemoryRequirements: ptr VkMemoryRequirements2 ): void {.stdcall.}](vkGetProc("vkGetGeneratedCommandsMemoryRequirementsNV"))
+  vkCmdPreprocessGeneratedCommandsNV = cast[proc(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV ): void {.stdcall.}](vkGetProc("vkCmdPreprocessGeneratedCommandsNV"))
+  vkCmdExecuteGeneratedCommandsNV = cast[proc(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: ptr VkGeneratedCommandsInfoNV ): void {.stdcall.}](vkGetProc("vkCmdExecuteGeneratedCommandsNV"))
+  vkCmdBindPipelineShaderGroupNV = cast[proc(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: uint32): void {.stdcall.}](vkGetProc("vkCmdBindPipelineShaderGroupNV"))
+  vkCreateIndirectCommandsLayoutNV = cast[proc(device: VkDevice, pCreateInfo: ptr VkIndirectCommandsLayoutCreateInfoNV , pAllocator: ptr VkAllocationCallbacks , pIndirectCommandsLayout: ptr VkIndirectCommandsLayoutNV ): VkResult {.stdcall.}](vkGetProc("vkCreateIndirectCommandsLayoutNV"))
+  vkDestroyIndirectCommandsLayoutNV = cast[proc(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyIndirectCommandsLayoutNV"))
+
+# Load VK_EXT_private_data
+proc loadVK_EXT_private_data*() =
+  vkCreatePrivateDataSlotEXT = cast[proc(device: VkDevice, pCreateInfo: ptr VkPrivateDataSlotCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pPrivateDataSlot: ptr VkPrivateDataSlotEXT ): VkResult {.stdcall.}](vkGetProc("vkCreatePrivateDataSlotEXT"))
+  vkDestroyPrivateDataSlotEXT = cast[proc(device: VkDevice, privateDataSlot: VkPrivateDataSlotEXT, pAllocator: ptr VkAllocationCallbacks ): void {.stdcall.}](vkGetProc("vkDestroyPrivateDataSlotEXT"))
+  vkSetPrivateDataEXT = cast[proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlotEXT, data: uint64): VkResult {.stdcall.}](vkGetProc("vkSetPrivateDataEXT"))
+  vkGetPrivateDataEXT = cast[proc(device: VkDevice, objectType: VkObjectType, objectHandle: uint64, privateDataSlot: VkPrivateDataSlotEXT, pData: ptr uint64 ): void {.stdcall.}](vkGetProc("vkGetPrivateDataEXT"))
+
+# Load VK_EXT_directfb_surface
+proc loadVK_EXT_directfb_surface*() =
+  vkCreateDirectFBSurfaceEXT = cast[proc(instance: VkInstance, pCreateInfo: ptr VkDirectFBSurfaceCreateInfoEXT , pAllocator: ptr VkAllocationCallbacks , pSurface: ptr VkSurfaceKHR ): VkResult {.stdcall.}](vkGetProc("vkCreateDirectFBSurfaceEXT"))
+  vkGetPhysicalDeviceDirectFBPresentationSupportEXT = cast[proc(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32, dfb: ptr IDirectFB ): VkBool32 {.stdcall.}](vkGetProc("vkGetPhysicalDeviceDirectFBPresentationSupportEXT"))
+
+proc vkInit*(load1_0: bool = true, load1_1: bool = true): bool =
+  if load1_0:
+    vkLoad1_0()
+  when not defined(macosx):
+    if load1_1:
+      vkLoad1_1()
+  return true