Mercurial > games > semicongine
changeset 7:a48af6ac67d6
Merge remote-tracking branch 'github/main'
| author | Sam <sam@basx.dev> |
|---|---|
| date | Thu, 22 Dec 2022 19:33:00 +0700 |
| parents | 4ed9cb098315 (diff) 091ed9ba0594 (current diff) |
| children | 1134f41a49e9 |
| files | |
| diffstat | 14 files changed, 12488 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Makefile Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,69 @@ +SOURCES := $(shell find src -name '*.nim') +COMPILE_OPTIONS := --path:src --mm:orc --experimental:strictEffects --threads:on +DEBUG_OPTIONS := --debugger:native --checks:on --assertions:on +RELEASE_OPTIONS := -d:release --checks:off --assertions:off + +# build +build/debug/linux/test: ${SOURCES} + mkdir -p $$( dirname $@ ) + nim c ${COMPILE_OPTIONS} ${DEBUG_OPTIONS} -o:$@ examples/test.nim +build/release/linux/test: ${SOURCES} + mkdir -p $$( dirname $@ ) + nim c ${COMPILE_OPTIONS} ${RELEASE_OPTIONS} -o:$@ examples/test.nim +build/debug/windows/test: ${SOURCES} + mkdir -p $$( dirname $@ ) + nim c ${COMPILE_OPTIONS} ${DEBUG_OPTIONS} -o:$@ examples/test.nim +build/release/windows/test: ${SOURCES} + mkdir -p $$( dirname $@ ) + nim c ${COMPILE_OPTIONS} ${RELEASE_OPTIONS} -o:$@ examples/test.nim + +build_all: build/debug/linux/test build/release/linux/test build/debug/windows/test build/release/windows/test + +# publish +publish_linux_debug: build/debug/linux/test + scp $< basx.dev:/var/www/public.basx.dev/joni/linux/debug/ +publish_linux_release: build/release/linux/test + scp $< basx.dev:/var/www/public.basx.dev/joni/linux/release/ +publish_windows_debug: build/debug/linux/test + scp $< basx.dev:/var/www/public.basx.dev/joni/windows/debug/ +publish_windows_release: build/release/linux/test + scp $< basx.dev:/var/www/public.basx.dev/joni/windows/release/ + +publish_all: publish_linux_debug publish_linux_release publish_windows_debug publish_windows_release + + +# download thirdparty-libraries + +thirdparty/lib/glslang/linux_debug: + mkdir -p $@ + wget --directory-prefix=$@ https://github.com/KhronosGroup/glslang/releases/download/master-tot/glslang-master-linux-Debug.zip + uzip glslang-master-linux-Debug.zip +thirdparty/lib/glslang/linux_release: + mkdir -p $@ + wget --directory-prefix=$@ https://github.com/KhronosGroup/glslang/releases/download/master-tot/glslang-master-linux-Release.zip + unzip glslang-master-linux-Release.zip +thirdparty/lib/glslang/windows_debug: + mkdir -p $@ + wget --directory-prefix=$@ https://github.com/KhronosGroup/glslang/releases/download/master-tot/glslang-master-windows-x64-Debug.zip + unzip glslang-master-windows-x64-Debug.zip +thirdparty/lib/glslang/windows_release: + mkdir -p $@ + wget --directory-prefix=$@ https://github.com/KhronosGroup/glslang/releases/download/master-tot/glslang-master-windows-x64-Release.zip + unzip glslang-master-windows-x64-Release.zip + +thirdparty/lib/spirv-tools/linux_debug: + mkdir -p $@ + wget --directory-prefix=$@ https://storage.googleapis.com/spirv-tools/artifacts/prod/graphics_shader_compiler/spirv-tools/linux-gcc-debug/continuous/1899/20221216-081758/install.tgz + tar -xf $@/install.tgz +thirdparty/lib/spirv-tools/linux_release: + mkdir -p $@ + wget --directory-prefix=$@ https://storage.googleapis.com/spirv-tools/artifacts/prod/graphics_shader_compiler/spirv-tools/linux-gcc-release/continuous/1889/20221216-081754/install.tgz + tar -xf $@/install.tgz +thirdparty/lib/spirv-tools/windows_debug: + mkdir -p $@ + wget --directory-prefix=$@ https://storage.googleapis.com/spirv-tools/artifacts/prod/graphics_shader_compiler/spirv-tools/windows-msvc-2017-debug/continuous/1599/20221216-081803/install.zip + unzip $@/install.zip +thirdparty/lib/spirv-tools/windows_release: + mkdir -p $@ + wget --directory-prefix=$@ https://storage.googleapis.com/spirv-tools/artifacts/prod/graphics_shader_compiler/spirv-tools/windows-msvc-2017-release/continuous/1885/20221216-081805/install.zip + unzip $@/install.zip
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/examples/test.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,7 @@ +import engine + + +when isMainModule: + var myengine = igniteEngine() + myengine.fullThrottle() + myengine.trash()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/engine.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,645 @@ +import std/typetraits +import std/strformat +import std/enumerate +import std/logging + + +import ./vulkan +import ./vulkan_helpers +import ./window +import ./events + +import ./glslang/glslang + +const MAX_FRAMES_IN_FLIGHT = 2 + +var logger = newConsoleLogger() +addHandler(logger) + + +var vertexShaderCode: string = """#version 450 +layout(location = 0) out vec3 fragColor; +vec3 colors[3] = vec3[]( + vec3(1.0, 0.0, 0.0), + vec3(0.0, 1.0, 0.0), + vec3(0.0, 0.0, 1.0) +); +vec2 positions[3] = vec2[]( + vec2(0.0, -0.5), + vec2(0.5, 0.5), + vec2(-0.5, 0.5) +); +void main() { + gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0); + fragColor = colors[gl_VertexIndex]; +}""" + +var fragmentShaderCode: string = """#version 450 +layout(location = 0) out vec4 outColor; +layout(location = 0) in vec3 fragColor; +void main() { + outColor = vec4(fragColor, 1.0); +}""" + +const VULKAN_VERSION = VK_MAKE_API_VERSION(0'u32, 1'u32, 2'u32, 0'u32) + +type + Device = object + physicalDevice: PhysicalDevice + graphicsQueueFamily: uint32 + presentationQueueFamily: uint32 + device: VkDevice + graphicsQueue: VkQueue + presentationQueue: VkQueue + Swapchain = object + swapchain: VkSwapchainKHR + images: seq[VkImage] + imageviews: seq[VkImageView] + RenderPipeline = object + shaderStages*: seq[VkPipelineShaderStageCreateInfo] + layout*: VkPipelineLayout + pipeline*: VkPipeline + 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 + pipeline*: RenderPipeline + 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] + Engine* = object + vulkan*: Vulkan + window: NativeWindow + +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), + ) + +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 setupRenderPipeline(device: VkDevice, frameDimension: VkExtent2D, renderPass: VkRenderPass): RenderPipeline = + # (seq[VkPipelineShaderStageCreateInfo], VkViewport, VkRect2D, VkPipelineLayout, VkPipeline) = + + # load shaders + result.shaderStages.add(device.createShaderStage(VK_SHADER_STAGE_VERTEX_BIT, vertexShaderCode)) + result.shaderStages.add(device.createShaderStage(VK_SHADER_STAGE_FRAGMENT_BIT, fragmentShaderCode)) + + 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]), + ) + # define input data format + vertexInputInfo = VkPipelineVertexInputStateCreateInfo( + sType: VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + vertexBindingDescriptionCount: 0, + pVertexBindingDescriptions: nil, + vertexAttributeDescriptionCount: 0, + pVertexAttributeDescriptions: nil, + ) + 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], + ) + + # create pipeline + pipelineLayoutInfo = VkPipelineLayoutCreateInfo( + sType: VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, + setLayoutCount: 0, + pSetLayouts: nil, + pushConstantRangeCount: 0, + pPushConstantRanges: nil, + ) + checkVkResult device.vkCreatePipelineLayout(addr(pipelineLayoutInfo), nil, addr(result.layout)) + + var pipelineInfo = VkGraphicsPipelineCreateInfo( + sType: VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, + stageCount: 2, + pStages: addr(result.shaderStages[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 device.vkCreateGraphicsPipelines( + 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 + ) + + # createFramebuffers(); + + +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*(): Engine = + + result.window = createWindow("Hello triangle") + + # setup vulkan functions + vkLoad1_0() + vkLoad1_1() + vkLoad1_2() + checkGlslangResult glslang_initialize_process() + + # create vulkan instance + result.vulkan.instance = createVulkanInstance(VULKAN_VERSION) + when ENABLEVULKANVALIDATIONLAYERS: + 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.pipeline = result.vulkan.device.device.setupRenderPipeline(result.vulkan.frameDimension, result.vulkan.renderPass) + 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 recordCommandBuffer(renderPass: VkRenderPass, pipeline: VkPipeline, commandBuffer: VkCommandBuffer, framebuffer: VkFramebuffer, frameDimension: VkExtent2D) = + 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 commandBuffer.vkBeginCommandBuffer(addr(beginInfo)) + commandBuffer.vkCmdBeginRenderPass(addr(renderPassInfo), VK_SUBPASS_CONTENTS_INLINE) + commandBuffer.vkCmdBindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline) + commandBuffer.vkCmdSetViewport(firstViewport=0, viewportCount=1, addr(viewport)) + commandBuffer.vkCmdSetScissor(firstScissor=0, scissorCount=1, addr(scissor)) + commandBuffer.vkCmdDraw(vertexCount=3, instanceCount=1, firstVertex=0, firstInstance=0) + commandBuffer.vkCmdEndRenderPass() + checkVkResult commandBuffer.vkEndCommandBuffer() + +proc drawFrame(window: NativeWindow, vulkan: var Vulkan, currentFrame: int, resized: bool) = + checkVkResult vulkan.device.device.vkWaitForFences(1, addr(vulkan.inFlightFences[currentFrame]), VK_TRUE, high(uint64)) + var bufferImageIndex: uint32 + let nextImageResult = vulkan.device.device.vkAcquireNextImageKHR( + 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() + return + elif not (nextImageResult in [VK_SUCCESS, VK_SUBOPTIMAL_KHR]): + raise newException(Exception, "Vulkan error: vkAcquireNextImageKHR returned " & $nextImageResult) + checkVkResult vulkan.device.device.vkResetFences(1, addr(vulkan.inFlightFences[currentFrame])) + + checkVkResult vulkan.commandBuffers[currentFrame].vkResetCommandBuffer(VkCommandBufferResetFlags(0)) + vulkan.renderPass.recordCommandBuffer(vulkan.pipeline.pipeline, vulkan.commandBuffers[currentFrame], vulkan.framebuffers[bufferImageIndex], vulkan.frameDimension) + 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 fullThrottle*(engine: var Engine) = + var + killed = false + currentFrame = 0 + resized = false + + while not killed: + for event in engine.window.pendingEvents(): + case event.eventType: + of Quit: + killed = true + of ResizedWindow: + resized = true + of KeyDown: + echo event + if event.key == Escape: + killed = true + else: + discard + engine.window.drawFrame(engine.vulkan, currentFrame, resized) + resized = false + currentFrame = (currentFrame + 1) mod MAX_FRAMES_IN_FLIGHT; + checkVkResult engine.vulkan.device.device.vkDeviceWaitIdle() + +proc trash*(engine: Engine) = + engine.vulkan.device.device.trash(engine.vulkan.swapchain, engine.vulkan.framebuffers) + checkVkResult engine.vulkan.device.device.vkDeviceWaitIdle() + + 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.vkDestroyCommandPool(engine.vulkan.commandPool, nil) + engine.vulkan.device.device.vkDestroyPipeline(engine.vulkan.pipeline.pipeline, nil) + engine.vulkan.device.device.vkDestroyPipelineLayout(engine.vulkan.pipeline.layout, nil) + engine.vulkan.device.device.vkDestroyRenderPass(engine.vulkan.renderPass, nil) + + for shaderStage in engine.vulkan.pipeline.shaderStages: + engine.vulkan.device.device.vkDestroyShaderModule(shaderStage.module, nil) + + engine.vulkan.instance.vkDestroySurfaceKHR(engine.vulkan.surface, nil) + engine.vulkan.device.device.vkDestroyDevice(nil) + when ENABLEVULKANVALIDATIONLAYERS: + engine.vulkan.instance.vkDestroyDebugUtilsMessengerEXT(engine.vulkan.debugMessenger, nil) + glslang_finalize_process() + engine.vulkan.instance.vkDestroyInstance(nil) + engine.window.trash()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/events.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,20 @@ +type + EventType* = enum + Quit + ResizedWindow + KeyDown + KeyUp + Key* = enum + UNKNOWN + 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 + 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 + `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `0` + Minus, Plus, Underscore, Equals, Space, Enter, Backspace, Tab + Comma, Period, Semicolon, Colon, + Escape, CtrlL, ShirtL, AltL, CtrlR, ShirtR, AltR + Event* = object + case eventType*: EventType + of KeyDown, KeyUp: + key*: Key + else: + discard
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/glslang/glslang.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,75 @@ +import glslang_c_interface +import glslang_c_shader_types + +export + glslang_stage_t, + glslang_initialize_process, + glslang_finalize_process + +type + ShaderVersion = enum + ES_VERSION = 100 + DESKTOP_VERSION = 110 + +proc compileGLSLToSPIRV*(stage: glslang_stage_t, shaderSource: string, fileName: string): seq[uint32] = + var input = glslang_input_t( + stage: stage, + language: GLSLANG_SOURCE_GLSL, + client: GLSLANG_CLIENT_VULKAN, + client_version: GLSLANG_TARGET_VULKAN_1_2, + target_language: GLSLANG_TARGET_SPV, + target_language_version: GLSLANG_TARGET_SPV_1_5, + code: cstring(shaderSource), + default_version: ord(DESKTOP_VERSION), + default_profile: GLSLANG_CORE_PROFILE, + force_default_version_and_profile: false.cint, + forward_compatible: false.cint, + messages: GLSLANG_MSG_DEBUG_INFO_BIT, + resource: glslang_default_resource(), + ) + + var shader = glslang_shader_create(addr(input)) + + if not bool(glslang_shader_preprocess(shader, addr(input))): + echo "GLSL preprocessing failed " & fileName + echo glslang_shader_get_info_log(shader) + echo glslang_shader_get_info_debug_log(shader) + echo input.code + glslang_shader_delete(shader) + return + + if not bool(glslang_shader_parse(shader, addr(input))): + echo "GLSL parsing failed " & fileName + echo glslang_shader_get_info_log(shader) + echo glslang_shader_get_info_debug_log(shader) + echo glslang_shader_get_preprocessed_code(shader) + glslang_shader_delete(shader) + return + + var program: ptr glslang_program_t = glslang_program_create() + glslang_program_add_shader(program, shader) + + if not bool(glslang_program_link(program, ord(GLSLANG_MSG_SPV_RULES_BIT) or ord(GLSLANG_MSG_VULKAN_RULES_BIT))): + echo "GLSL linking failed " & fileName + echo glslang_program_get_info_log(program) + echo glslang_program_get_info_debug_log(program) + glslang_program_delete(program) + glslang_shader_delete(shader) + return + + glslang_program_SPIRV_generate(program, stage) + + result = newSeq[uint32](glslang_program_SPIRV_get_size(program)) + glslang_program_SPIRV_get(program, addr(result[0])) + + var spirv_messages: cstring = glslang_program_SPIRV_get_messages(program) + if spirv_messages != nil: + echo "(%s) %s\b", fileName, spirv_messages + + glslang_program_delete(program) + glslang_shader_delete(shader) + +template checkGlslangResult*(call: untyped) = + let value = call + if value != 1: + raise newException(Exception, "glgslang error: " & astToStr(call) & " returned " & $value)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/glslang/glslang_c_interface.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,230 @@ +import std/strformat + +when defined(linux): + const platform = "linux" +when defined(windows): + const platform = "windows" + + +when defined(release): + const libversion = "release" +else: + const libversion = "debug" + + +# required to link the GLSL compiler +{.passl: &"-Lthirdparty/lib/glslang/{platform}_{libversion}" .} +{.passl: &"-Lthirdparty/lib/spirv-tools/{platform}_{libversion}" .} + +{.passl: "-lglslang" .} +{.passl: "-lglslang-default-resource-limits" .} +{.passl: "-lHLSL" .} +{.passl: "-lMachineIndependent" .} +{.passl: "-lGenericCodeGen" .} +{.passl: "-lOSDependent" .} +{.passl: "-lOGLCompiler" .} +{.passl: "-lSPIRV" .} +{.passl: "-lSPIRV-Tools-opt" .} +{.passl: "-lSPIRV-Tools" .} +{.passl: "-lSPIRV-Tools-diff" .} +{.passl: "-lSPIRV-Tools-fuzz" .} +{.passl: "-lSPIRV-Tools-link" .} +{.passl: "-lSPIRV-Tools-lint" .} +{.passl: "-lSPIRV-Tools-opt" .} +{.passl: "-lSPIRV-Tools-reduce" .} + +{.passl: "-lstdc++" .} +{.passl: "-lm" .} + +import + glslang_c_shader_types + +type + glslang_shader_t* {.nodecl incompleteStruct.} = object + glslang_program_t* {.nodecl incompleteStruct.} = object + glslang_limits_t* {.bycopy.} = object + non_inductive_for_loops*: bool + while_loops*: bool + do_while_loops*: bool + general_uniform_indexing*: bool + general_attribute_matrix_vector_indexing*: bool + general_varying_indexing*: bool + general_sampler_indexing*: bool + general_variable_indexing*: bool + general_constant_matrix_vector_indexing*: bool + glslang_resource_t* {.bycopy.} = object + max_lights*: cint + max_clip_planes*: cint + max_texture_units*: cint + max_texture_coords*: cint + max_vertex_attribs*: cint + max_vertex_uniform_components*: cint + max_varying_floats*: cint + max_vertex_texture_image_units*: cint + max_combined_texture_image_units*: cint + max_texture_image_units*: cint + max_fragment_uniform_components*: cint + max_draw_buffers*: cint + max_vertex_uniform_vectors*: cint + max_varying_vectors*: cint + max_fragment_uniform_vectors*: cint + max_vertex_output_vectors*: cint + max_fragment_input_vectors*: cint + min_program_texel_offset*: cint + max_program_texel_offset*: cint + max_clip_distances*: cint + max_compute_work_group_count_x*: cint + max_compute_work_group_count_y*: cint + max_compute_work_group_count_z*: cint + max_compute_work_group_size_x*: cint + max_compute_work_group_size_y*: cint + max_compute_work_group_size_z*: cint + max_compute_uniform_components*: cint + max_compute_texture_image_units*: cint + max_compute_image_uniforms*: cint + max_compute_atomic_counters*: cint + max_compute_atomic_counter_buffers*: cint + max_varying_components*: cint + max_vertex_output_components*: cint + max_geometry_input_components*: cint + max_geometry_output_components*: cint + max_fragment_input_components*: cint + max_image_units*: cint + max_combined_image_units_and_fragment_outputs*: cint + max_combined_shader_output_resources*: cint + max_image_samples*: cint + max_vertex_image_uniforms*: cint + max_tess_control_image_uniforms*: cint + max_tess_evaluation_image_uniforms*: cint + max_geometry_image_uniforms*: cint + max_fragment_image_uniforms*: cint + max_combined_image_uniforms*: cint + max_geometry_texture_image_units*: cint + max_geometry_output_vertices*: cint + max_geometry_total_output_components*: cint + max_geometry_uniform_components*: cint + max_geometry_varying_components*: cint + max_tess_control_input_components*: cint + max_tess_control_output_components*: cint + max_tess_control_texture_image_units*: cint + max_tess_control_uniform_components*: cint + max_tess_control_total_output_components*: cint + max_tess_evaluation_input_components*: cint + max_tess_evaluation_output_components*: cint + max_tess_evaluation_texture_image_units*: cint + max_tess_evaluation_uniform_components*: cint + max_tess_patch_components*: cint + max_patch_vertices*: cint + max_tess_gen_level*: cint + max_viewports*: cint + max_vertex_atomic_counters*: cint + max_tess_control_atomic_counters*: cint + max_tess_evaluation_atomic_counters*: cint + max_geometry_atomic_counters*: cint + max_fragment_atomic_counters*: cint + max_combined_atomic_counters*: cint + max_atomic_counter_bindings*: cint + max_vertex_atomic_counter_buffers*: cint + max_tess_control_atomic_counter_buffers*: cint + max_tess_evaluation_atomic_counter_buffers*: cint + max_geometry_atomic_counter_buffers*: cint + max_fragment_atomic_counter_buffers*: cint + max_combined_atomic_counter_buffers*: cint + max_atomic_counter_buffer_size*: cint + max_transform_feedback_buffers*: cint + max_transform_feedback_interleaved_components*: cint + max_cull_distances*: cint + max_combined_clip_and_cull_distances*: cint + max_samples*: cint + max_mesh_output_vertices_nv*: cint + max_mesh_output_primitives_nv*: cint + max_mesh_work_group_size_x_nv*: cint + max_mesh_work_group_size_y_nv*: cint + max_mesh_work_group_size_z_nv*: cint + max_task_work_group_size_x_nv*: cint + max_task_work_group_size_y_nv*: cint + max_task_work_group_size_z_nv*: cint + max_mesh_view_count_nv*: cint + max_mesh_output_vertices_ext*: cint + max_mesh_output_primitives_ext*: cint + max_mesh_work_group_size_x_ext*: cint + max_mesh_work_group_size_y_ext*: cint + max_mesh_work_group_size_z_ext*: cint + max_task_work_group_size_x_ext*: cint + max_task_work_group_size_y_ext*: cint + max_task_work_group_size_z_ext*: cint + max_mesh_view_count_ext*: cint + maxDualSourceDrawBuffersEXT*: cint + limits*: glslang_limits_t + glslang_input_t* {.bycopy.} = object + language*: glslang_source_t + stage*: glslang_stage_t + client*: glslang_client_t + client_version*: glslang_target_client_version_t + target_language*: glslang_target_language_t + target_language_version*: glslang_target_language_version_t + code*: cstring + default_version*: cint + default_profile*: glslang_profile_t + force_default_version_and_profile*: cint + forward_compatible*: cint + messages*: glslang_messages_t + resource*: ptr glslang_resource_t + glsl_include_result_t* {.bycopy.} = object + ## Header file name or NULL if inclusion failed + header_name*: cstring + ## Header contents or NULL + header_data*: cstring + header_length*: csize_t + glsl_include_local_func* = proc (ctx: pointer; header_name: cstring; includer_name: cstring; include_depth: csize_t): ptr glsl_include_result_t + glsl_include_system_func* = proc (ctx: pointer; header_name: cstring; includer_name: cstring; include_depth: csize_t): ptr glsl_include_result_t + glsl_free_include_result_func* = proc (ctx: pointer; result: ptr glsl_include_result_t): cint + glsl_include_callbacks_t* {.bycopy.} = object + include_system*: glsl_include_system_func + include_local*: glsl_include_local_func + free_include_result*: glsl_free_include_result_func + glslang_spv_options_t* {.bycopy.} = object + generate_debug_info*: bool + strip_debug_info*: bool + disable_optimizer*: bool + optimize_size*: bool + disassemble*: bool + validate*: bool + emit_nonsemantic_shader_debug_info*: bool + emit_nonsemantic_shader_debug_source*: bool + +proc glslang_initialize_process*(): cint {.importc.} +proc glslang_finalize_process*() {.importc.} +proc glslang_shader_create*(input: ptr glslang_input_t): ptr glslang_shader_t {.importc.} +proc glslang_shader_delete*(shader: ptr glslang_shader_t) {.importc.} +proc glslang_shader_set_preamble*(shader: ptr glslang_shader_t; s: cstring) {.importc.} +proc glslang_shader_shift_binding*(shader: ptr glslang_shader_t; res: glslang_resource_type_t; base: cuint) {.importc.} +proc glslang_shader_shift_binding_for_set*(shader: ptr glslang_shader_t; res: glslang_resource_type_t; base: cuint; set: cuint) {.importc.} +proc glslang_shader_set_options*(shader: ptr glslang_shader_t; options: cint) {.importc.} + +proc glslang_shader_set_glsl_version*(shader: ptr glslang_shader_t; version: cint) {.importc.} +proc glslang_shader_preprocess*(shader: ptr glslang_shader_t; input: ptr glslang_input_t): cint {.importc.} +proc glslang_shader_parse*(shader: ptr glslang_shader_t; input: ptr glslang_input_t): cint {.importc.} +proc glslang_shader_get_preprocessed_code*(shader: ptr glslang_shader_t): cstring {.importc.} +proc glslang_shader_get_info_log*(shader: ptr glslang_shader_t): cstring {.importc.} +proc glslang_shader_get_info_debug_log*(shader: ptr glslang_shader_t): cstring {.importc.} +proc glslang_program_create*(): ptr glslang_program_t {.importc.} +proc glslang_program_delete*(program: ptr glslang_program_t) {.importc.} +proc glslang_program_add_shader*(program: ptr glslang_program_t; shader: ptr glslang_shader_t) {.importc.} +proc glslang_program_link*(program: ptr glslang_program_t; messages: cint): cint {.importc.} + +proc glslang_program_add_source_text*(program: ptr glslang_program_t; stage: glslang_stage_t; text: cstring; len: csize_t) {.importc.} +proc glslang_program_set_source_file*(program: ptr glslang_program_t; stage: glslang_stage_t; file: cstring) {.importc.} +proc glslang_program_map_io*(program: ptr glslang_program_t): cint {.importc.} +proc glslang_program_SPIRV_generate*(program: ptr glslang_program_t; stage: glslang_stage_t) {.importc.} +proc glslang_program_SPIRV_generate_with_options*(program: ptr glslang_program_t; stage: glslang_stage_t; spv_options: ptr glslang_spv_options_t) {.importc.} +proc glslang_program_SPIRV_get_size*(program: ptr glslang_program_t): csize_t {.importc.} +proc glslang_program_SPIRV_get*(program: ptr glslang_program_t; a2: ptr cuint) {.importc.} +proc glslang_program_SPIRV_get_ptr*(program: ptr glslang_program_t): ptr cuint {.importc.} +proc glslang_program_SPIRV_get_messages*(program: ptr glslang_program_t): cstring {.importc.} +proc glslang_program_get_info_log*(program: ptr glslang_program_t): cstring {.importc.} +proc glslang_program_get_info_debug_log*(program: ptr glslang_program_t): cstring {.importc.} + +proc glslang_default_resource*(): ptr glslang_resource_t {.importc.} +proc glslang_default_resource_string*(): cstring {.importc.} +proc glslang_decode_resource_limits*(resources: ptr glslang_resource_t , config: cstring) {.importc.}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/glslang/glslang_c_shader_types.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,161 @@ +type + + # EShLanguage counterpart + glslang_stage_t* {.size: sizeof(cint).} = enum + GLSLANG_STAGE_VERTEX + GLSLANG_STAGE_TESSCONTROL + GLSLANG_STAGE_TESSEVALUATION + GLSLANG_STAGE_GEOMETRY + GLSLANG_STAGE_FRAGMENT + GLSLANG_STAGE_COMPUTE + GLSLANG_STAGE_RAYGEN + GLSLANG_STAGE_INTERSECT + GLSLANG_STAGE_ANYHIT + GLSLANG_STAGE_CLOSESTHIT + GLSLANG_STAGE_MISS + GLSLANG_STAGE_CALLABLE + GLSLANG_STAGE_TASK + GLSLANG_STAGE_MESH + GLSLANG_STAGE_COUNT + + # EShLanguageMask counterpart + glslang_stage_mask_t* {.size: sizeof(cint).} = enum + GLSLANG_STAGE_VERTEX_MASK = (1 shl ord(GLSLANG_STAGE_VERTEX)) + GLSLANG_STAGE_TESSCONTROL_MASK = (1 shl ord(GLSLANG_STAGE_TESSCONTROL)) + GLSLANG_STAGE_TESSEVALUATION_MASK = (1 shl ord(GLSLANG_STAGE_TESSEVALUATION)) + GLSLANG_STAGE_GEOMETRY_MASK = (1 shl ord(GLSLANG_STAGE_GEOMETRY)) + GLSLANG_STAGE_FRAGMENT_MASK = (1 shl ord(GLSLANG_STAGE_FRAGMENT)) + GLSLANG_STAGE_COMPUTE_MASK = (1 shl ord(GLSLANG_STAGE_COMPUTE)) + GLSLANG_STAGE_RAYGEN_MASK = (1 shl ord(GLSLANG_STAGE_RAYGEN)) + GLSLANG_STAGE_INTERSECT_MASK = (1 shl ord(GLSLANG_STAGE_INTERSECT)) + GLSLANG_STAGE_ANYHIT_MASK = (1 shl ord(GLSLANG_STAGE_ANYHIT)) + GLSLANG_STAGE_CLOSESTHIT_MASK = (1 shl ord(GLSLANG_STAGE_CLOSESTHIT)) + GLSLANG_STAGE_MISS_MASK = (1 shl ord(GLSLANG_STAGE_MISS)) + GLSLANG_STAGE_CALLABLE_MASK = (1 shl ord(GLSLANG_STAGE_CALLABLE)) + GLSLANG_STAGE_TASK_MASK = (1 shl ord(GLSLANG_STAGE_TASK)) + GLSLANG_STAGE_MESH_MASK = (1 shl ord(GLSLANG_STAGE_MESH)) + GLSLANG_STAGE_MASK_COUNT + + # EShSource counterpart + glslang_source_t* {.size: sizeof(cint).} = enum + GLSLANG_SOURCE_NONE + GLSLANG_SOURCE_GLSL + GLSLANG_SOURCE_HLSL + GLSLANG_SOURCE_COUNT + + # EShClient counterpart + glslang_client_t* {.size: sizeof(cint).} = enum + GLSLANG_CLIENT_NONE + GLSLANG_CLIENT_VULKAN + GLSLANG_CLIENT_OPENGL + GLSLANG_CLIENT_COUNT + + # EShTargetLanguage counterpart + glslang_target_language_t* {.size: sizeof(cint).} = enum + GLSLANG_TARGET_NONE + GLSLANG_TARGET_SPV + GLSLANG_TARGET_COUNT + + # SH_TARGET_ClientVersion counterpart + glslang_target_client_version_t* {.size: sizeof(cint).} = enum + GLSLANG_TARGET_CLIENT_VERSION_COUNT = 5 + GLSLANG_TARGET_OPENGL_450 = 450 + GLSLANG_TARGET_VULKAN_1_0 = (1 shl 22) + GLSLANG_TARGET_VULKAN_1_1 = (1 shl 22) or (1 shl 12) + GLSLANG_TARGET_VULKAN_1_2 = (1 shl 22) or (2 shl 12) + GLSLANG_TARGET_VULKAN_1_3 = (1 shl 22) or (3 shl 12) + + # SH_TARGET_LanguageVersion counterpart + glslang_target_language_version_t* {.size: sizeof(cint).} = enum + GLSLANG_TARGET_LANGUAGE_VERSION_COUNT = 7 + GLSLANG_TARGET_SPV_1_0 = (1 shl 16) + GLSLANG_TARGET_SPV_1_1 = (1 shl 16) or (1 shl 8) + GLSLANG_TARGET_SPV_1_2 = (1 shl 16) or (2 shl 8) + GLSLANG_TARGET_SPV_1_3 = (1 shl 16) or (3 shl 8) + GLSLANG_TARGET_SPV_1_4 = (1 shl 16) or (4 shl 8) + GLSLANG_TARGET_SPV_1_5 = (1 shl 16) or (5 shl 8) + GLSLANG_TARGET_SPV_1_6 = (1 shl 16) or (6 shl 8) + + # EShExecutable counterpart + glslang_executable_t* {.size: sizeof(cint).} = enum + GLSLANG_EX_VERTEX_FRAGMENT + GLSLANG_EX_FRAGMENT + + # EShOptimizationLevel counterpart + # This enum is not used in the current C interface, but could be added at a later date. + # GLSLANG_OPT_NONE is the current default. + glslang_optimization_level_t* {.size: sizeof(cint).} = enum + GLSLANG_OPT_NO_GENERATION + GLSLANG_OPT_NONE + GLSLANG_OPT_SIMPLE + GLSLANG_OPT_FULL + GLSLANG_OPT_LEVEL_COUNT + + # EShTextureSamplerTransformMode counterpart + glslang_texture_sampler_transform_mode_t* {.size: sizeof(cint).} = enum + GLSLANG_TEX_SAMP_TRANS_KEEP + GLSLANG_TEX_SAMP_TRANS_UPGRADE_TEXTURE_REMOVE_SAMPLER + GLSLANG_TEX_SAMP_TRANS_COUNT + + # EShMessages counterpart + glslang_messages_t* {.size: sizeof(cint).} = enum + GLSLANG_MSG_DEFAULT_BIT = 0 + GLSLANG_MSG_RELAXED_ERRORS_BIT = (1 shl 0) + GLSLANG_MSG_SUPPRESS_WARNINGS_BIT = (1 shl 1) + GLSLANG_MSG_AST_BIT = (1 shl 2) + GLSLANG_MSG_SPV_RULES_BIT = (1 shl 3) + GLSLANG_MSG_VULKAN_RULES_BIT = (1 shl 4) + GLSLANG_MSG_ONLY_PREPROCESSOR_BIT = (1 shl 5) + GLSLANG_MSG_READ_HLSL_BIT = (1 shl 6) + GLSLANG_MSG_CASCADING_ERRORS_BIT = (1 shl 7) + GLSLANG_MSG_KEEP_UNCALLED_BIT = (1 shl 8) + GLSLANG_MSG_HLSL_OFFSETS_BIT = (1 shl 9) + GLSLANG_MSG_DEBUG_INFO_BIT = (1 shl 10) + GLSLANG_MSG_HLSL_ENABLE_16BIT_TYPES_BIT = (1 shl 11) + GLSLANG_MSG_HLSL_LEGALIZATION_BIT = (1 shl 12) + GLSLANG_MSG_HLSL_DX9_COMPATIBLE_BIT = (1 shl 13) + GLSLANG_MSG_BUILTIN_SYMBOL_TABLE_BIT = (1 shl 14) + GLSLANG_MSG_ENHANCED = (1 shl 15) + GLSLANG_MSG_COUNT + + # EShReflectionOptions counterpart + glslang_reflection_options_t* {.size: sizeof(cint).} = enum + GLSLANG_REFLECTION_DEFAULT_BIT = 0 + GLSLANG_REFLECTION_STRICT_ARRAY_SUFFIX_BIT = (1 shl 0) + GLSLANG_REFLECTION_BASIC_ARRAY_SUFFIX_BIT = (1 shl 1) + GLSLANG_REFLECTION_INTERMEDIATE_IOO_BIT = (1 shl 2) + GLSLANG_REFLECTION_SEPARATE_BUFFERS_BIT = (1 shl 3) + GLSLANG_REFLECTION_ALL_BLOCK_VARIABLES_BIT = (1 shl 4) + GLSLANG_REFLECTION_UNWRAP_IO_BLOCKS_BIT = (1 shl 5) + GLSLANG_REFLECTION_ALL_IO_VARIABLES_BIT = (1 shl 6) + GLSLANG_REFLECTION_SHARED_STD140_SSBO_BIT = (1 shl 7) + GLSLANG_REFLECTION_SHARED_STD140_UBO_BIT = (1 shl 8) + GLSLANG_REFLECTION_COUNT + + # EProfile counterpart (from Versions.h) + glslang_profile_t* {.size: sizeof(cint).} = enum + GLSLANG_BAD_PROFILE = 0 + GLSLANG_NO_PROFILE = (1 shl 0) + GLSLANG_CORE_PROFILE = (1 shl 1) + GLSLANG_COMPATIBILITY_PROFILE = (1 shl 2) + GLSLANG_ES_PROFILE = (1 shl 3) + GLSLANG_PROFILE_COUNT + + # Shader options + glslang_shader_options_t* {.size: sizeof(cint).} = enum + GLSLANG_SHADER_DEFAULT_BIT = 0 + GLSLANG_SHADER_AUTO_MAP_BINDINGS = (1 shl 0) + GLSLANG_SHADER_AUTO_MAP_LOCATIONS = (1 shl 1) + GLSLANG_SHADER_VULKAN_RULES_RELAXED = (1 shl 2) + GLSLANG_SHADER_COUNT + + # TResourceType counterpart + glslang_resource_type_t* {.size: sizeof(cint).} = enum + GLSLANG_RESOURCE_TYPE_SAMPLER + GLSLANG_RESOURCE_TYPE_TEXTURE + GLSLANG_RESOURCE_TYPE_IMAGE + GLSLANG_RESOURCE_TYPE_UBO + GLSLANG_RESOURCE_TYPE_SSBO + GLSLANG_RESOURCE_TYPE_UAV + GLSLANG_RESOURCE_TYPE_COUNT +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/notes Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,2 @@ +For implementation of font rendering: +https://developer.apple.com/fonts/TrueType-Reference-Manual/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/platform/linux/symkey_map.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,16 @@ +import std/tables +export tables + +import x11/keysym +import x11/x + +import ../../events + +const KeyTypeMap* = { + XK_A: A, XK_B: B, XK_C: C, XK_D: D, XK_E: E, XK_F: F, XK_G: G, XK_H: H, XK_I: I, XK_J: J, XK_K: K, XK_L: L, XK_M: M, XK_N: N, XK_O: O, XK_P: P, XK_Q: Q, XK_R: R, XK_S: S, XK_T: T, XK_U: U, XK_V: V, XK_W: W, XK_X: X, XK_Y: Y, XK_Z: Z, + XK_a: a, XK_b: b, XK_c: c, XK_d: d, XK_e: e, XK_f: f, XK_g: g, XK_h: h, XK_i: i, XK_j: j, XK_k: k, XK_l: l, XK_m: m, XK_n: n, XK_o: o, XK_p: p, XK_q: q, XK_r: r, XK_s: s, XK_t: t, XK_u: u, XK_v: v, XK_w: w, XK_x: Key.x, XK_y: y, XK_z: z, + XK_1: `1`, XK_2: `2`, XK_3: `3`, XK_4: `4`, XK_5: `5`, XK_6: `6`, XK_7: `7`, XK_8: `8`, XK_9: `9`, XK_0: `0`, + XK_minus: Minus, XK_plus: Plus, XK_underscore: Underscore, XK_equal: Equals, XK_space: Space, XK_Return: Enter, XK_BackSpace: Backspace, XK_Tab: Tab, + XK_comma: Comma, XK_period: Period, XK_semicolon: Semicolon, XK_colon: Colon, + XK_Escape: Escape, XK_Control_L: CtrlL, XK_Shift_L: ShirtL, XK_Alt_L: AltL, XK_Control_R: CtrlR, XK_Shift_R: ShirtR, XK_Alt_R: AltR +}.toTable
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/platform/linux/xlib.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,73 @@ +import + x11/xlib, + x11/xutil, + x11/keysym +import x11/x + +import ../../events + +import ./symkey_map + +export keysym + +var deleteMessage*: Atom + +type + NativeWindow* = object + display*: PDisplay + window*: Window + +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, ButtonPressMask or KeyPressMask or ExposureMask) + checkXlibResult XMapWindow(display, window) + + deleteMessage = XInternAtom(display, "WM_DELETE_WINDOW", XBool(false)) + checkXlibResult XSetWMProtocols(display, window, addr(deleteMessage), 1) + + return NativeWindow(display: display, window: window) + +proc trash*(window: NativeWindow) = + 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: KeySym = XLookupKeysym(cast[PXKeyEvent](addr(event)), 0) + result.add(Event(eventType: KeyDown, key: KeyTypeMap.getOrDefault(xkey, UNKNOWN))) + of KeyRelease: + let xkey: KeySym = XLookupKeysym(cast[PXKeyEvent](addr(event)), 0) + result.add(Event(eventType: KeyUp, key: KeyTypeMap.getOrDefault(xkey, UNKNOWN))) + of ConfigureNotify: + result.add(Event(eventType: ResizedWindow)) + else: + discard
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/platform/windows/win32.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,58 @@ +import winim + +import ../../events + +type + NativeWindow* = object + hinstance*: HINSTANCE + hwnd*: HWND + +template checkWin32Result*(call: untyped) = + let value = call + if value != 0: + raise newException(Exception, "Win32 error: " & astToStr(call) & " returned " & $value) + +proc WindowHandler(hwnd: HWND, uMsg: UINT, wParam: WPARAM, lParam: LPARAM): LRESULT {.stdcall.} = + case uMsg + of WM_DESTROY: + discard + 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 = WNDCLASS( + lpfnWndProc: WindowHandler, + hInstance: result.hInstance, + lpszClassName: windowClassName, + ) + RegisterClass(addr(windowClass)) + + 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, 0) + +proc trash*(window: NativeWindow) = + PostQuitMessage(0) + +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] = + result
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/vulkan.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,10867 @@ +# 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 +when defined(windows): + import winim + +var vkGetProc: proc(procName: cstring): pointer {.cdecl.} + +import dynlib + +when defined(windows): + {. emit: """#define VK_USE_PLATFORM_WIN32_KHR""" .} + # {.passl: gorge("pkg-config --libs vulkan").} + const vkDLL = "vulkan-1.dll" +elif defined(linux): + {.passl: gorge("pkg-config --libs vulkan").} + {. emit: """#define VK_USE_PLATFORM_X11_KHR""" .} + const vkDLL = "libvulkan.so.1" +else: + raise quit("Unsupported platform") + +let vkHandleDLL = loadLib(vkDLL) +if isNil(vkHandleDLL): + quit("could not load: " & vkDLL) + +let vkGetProcAddress = cast[proc(s: cstring): pointer {.stdcall.}](symAddr(vkHandleDLL, "vkGetInstanceProcAddr")) +if vkGetProcAddress == nil: + quit("failed to load `vkGetInstanceProcAddr` from " & vkDLL) + +vkGetProc = proc(procName: cstring): pointer {.cdecl.} = + when defined(windows): + result = vkGetProcAddress(procName) + if result != nil: + return + 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: int32.sizeof.} = enum + VK_IMAGE_LAYOUT_UNDEFINED = 0 + VK_IMAGE_LAYOUT_GENERAL = 1 + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2 + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3 + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4 + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5 + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6 + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7 + VK_IMAGE_LAYOUT_PREINITIALIZED = 8 + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VkAttachmentLoadOp* {.size: int32.sizeof.} = enum + VK_ATTACHMENT_LOAD_OP_LOAD = 0 + VK_ATTACHMENT_LOAD_OP_CLEAR = 1 + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2 + VkAttachmentStoreOp* {.size: int32.sizeof.} = enum + VK_ATTACHMENT_STORE_OP_STORE = 0 + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1 + VkImageType* {.size: int32.sizeof.} = enum + VK_IMAGE_TYPE_1D = 0 + VK_IMAGE_TYPE_2D = 1 + VK_IMAGE_TYPE_3D = 2 + VkImageTiling* {.size: int32.sizeof.} = enum + VK_IMAGE_TILING_OPTIMAL = 0 + VK_IMAGE_TILING_LINEAR = 1 + VkImageViewType* {.size: int32.sizeof.} = enum + VK_IMAGE_VIEW_TYPE_1D = 0 + VK_IMAGE_VIEW_TYPE_2D = 1 + VK_IMAGE_VIEW_TYPE_3D = 2 + VK_IMAGE_VIEW_TYPE_CUBE = 3 + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4 + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5 + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6 + VkCommandBufferLevel* {.size: int32.sizeof.} = enum + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0 + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1 + VkComponentSwizzle* {.size: int32.sizeof.} = enum + VK_COMPONENT_SWIZZLE_IDENTITY = 0 + VK_COMPONENT_SWIZZLE_ZERO = 1 + VK_COMPONENT_SWIZZLE_ONE = 2 + VK_COMPONENT_SWIZZLE_R = 3 + VK_COMPONENT_SWIZZLE_G = 4 + VK_COMPONENT_SWIZZLE_B = 5 + VK_COMPONENT_SWIZZLE_A = 6 + VkDescriptorType* {.size: int32.sizeof.} = enum + VK_DESCRIPTOR_TYPE_SAMPLER = 0 + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1 + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2 + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3 + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4 + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5 + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6 + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7 + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8 + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9 + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10 + VkQueryType* {.size: int32.sizeof.} = enum + VK_QUERY_TYPE_OCCLUSION = 0 + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1 + VK_QUERY_TYPE_TIMESTAMP = 2 + VkBorderColor* {.size: int32.sizeof.} = enum + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0 + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1 + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2 + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3 + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4 + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5 + VkPipelineBindPoint* {.size: int32.sizeof.} = enum + VK_PIPELINE_BIND_POINT_GRAPHICS = 0 + VK_PIPELINE_BIND_POINT_COMPUTE = 1 + VkPipelineCacheHeaderVersion* {.size: int32.sizeof.} = enum + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1 + VkPrimitiveTopology* {.size: int32.sizeof.} = enum + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0 + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1 + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2 + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3 + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4 + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5 + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6 + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7 + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8 + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9 + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10 + VkSharingMode* {.size: int32.sizeof.} = enum + VK_SHARING_MODE_EXCLUSIVE = 0 + VK_SHARING_MODE_CONCURRENT = 1 + VkIndexType* {.size: int32.sizeof.} = enum + VK_INDEX_TYPE_UINT16 = 0 + VK_INDEX_TYPE_UINT32 = 1 + VkFilter* {.size: int32.sizeof.} = enum + VK_FILTER_NEAREST = 0 + VK_FILTER_LINEAR = 1 + VkSamplerMipmapMode* {.size: int32.sizeof.} = enum + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0 + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1 + VkSamplerAddressMode* {.size: int32.sizeof.} = enum + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0 + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1 + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2 + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3 + VkCompareOp* {.size: int32.sizeof.} = enum + VK_COMPARE_OP_NEVER = 0 + VK_COMPARE_OP_LESS = 1 + VK_COMPARE_OP_EQUAL = 2 + VK_COMPARE_OP_LESS_OR_EQUAL = 3 + VK_COMPARE_OP_GREATER = 4 + VK_COMPARE_OP_NOT_EQUAL = 5 + VK_COMPARE_OP_GREATER_OR_EQUAL = 6 + VK_COMPARE_OP_ALWAYS = 7 + VkPolygonMode* {.size: int32.sizeof.} = enum + VK_POLYGON_MODE_FILL = 0 + VK_POLYGON_MODE_LINE = 1 + VK_POLYGON_MODE_POINT = 2 + VkCullModeFlagBits* {.size: int32.sizeof.} = enum + VK_CULL_MODE_NONE = 0 + VK_CULL_MODE_FRONT_BIT = 1 + VK_CULL_MODE_BACK_BIT = 2 + VK_CULL_MODE_FRONT_AND_BACK = 3 + VkFrontFace* {.size: int32.sizeof.} = enum + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0 + VK_FRONT_FACE_CLOCKWISE = 1 + VkBlendFactor* {.size: int32.sizeof.} = enum + VK_BLEND_FACTOR_ZERO = 0 + VK_BLEND_FACTOR_ONE = 1 + VK_BLEND_FACTOR_SRC_COLOR = 2 + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3 + VK_BLEND_FACTOR_DST_COLOR = 4 + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5 + VK_BLEND_FACTOR_SRC_ALPHA = 6 + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7 + VK_BLEND_FACTOR_DST_ALPHA = 8 + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9 + VK_BLEND_FACTOR_CONSTANT_COLOR = 10 + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11 + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12 + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13 + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14 + VK_BLEND_FACTOR_SRC1_COLOR = 15 + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16 + VK_BLEND_FACTOR_SRC1_ALPHA = 17 + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18 + VkBlendOp* {.size: int32.sizeof.} = enum + VK_BLEND_OP_ADD = 0 + VK_BLEND_OP_SUBTRACT = 1 + VK_BLEND_OP_REVERSE_SUBTRACT = 2 + VK_BLEND_OP_MIN = 3 + VK_BLEND_OP_MAX = 4 + VkStencilOp* {.size: int32.sizeof.} = enum + VK_STENCIL_OP_KEEP = 0 + VK_STENCIL_OP_ZERO = 1 + VK_STENCIL_OP_REPLACE = 2 + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3 + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4 + VK_STENCIL_OP_INVERT = 5 + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6 + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7 + VkLogicOp* {.size: int32.sizeof.} = enum + VK_LOGIC_OP_CLEAR = 0 + VK_LOGIC_OP_AND = 1 + VK_LOGIC_OP_AND_REVERSE = 2 + VK_LOGIC_OP_COPY = 3 + VK_LOGIC_OP_AND_INVERTED = 4 + VK_LOGIC_OP_NO_OP = 5 + VK_LOGIC_OP_XOR = 6 + VK_LOGIC_OP_OR = 7 + VK_LOGIC_OP_NOR = 8 + VK_LOGIC_OP_EQUIVALENT = 9 + VK_LOGIC_OP_INVERT = 10 + VK_LOGIC_OP_OR_REVERSE = 11 + VK_LOGIC_OP_COPY_INVERTED = 12 + VK_LOGIC_OP_OR_INVERTED = 13 + VK_LOGIC_OP_NAND = 14 + VK_LOGIC_OP_SET = 15 + VkInternalAllocationType* {.size: int32.sizeof.} = enum + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0 + VkSystemAllocationScope* {.size: int32.sizeof.} = enum + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0 + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1 + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2 + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3 + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4 + VkPhysicalDeviceType* {.size: int32.sizeof.} = enum + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0 + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1 + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2 + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3 + VK_PHYSICAL_DEVICE_TYPE_CPU = 4 + VkVertexInputRate* {.size: int32.sizeof.} = enum + VK_VERTEX_INPUT_RATE_VERTEX = 0 + VK_VERTEX_INPUT_RATE_INSTANCE = 1 + VkFormat* {.size: int32.sizeof.} = enum + VK_FORMAT_UNDEFINED = 0 + VK_FORMAT_R4G4_UNORM_PACK8 = 1 + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2 + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3 + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4 + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5 + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6 + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7 + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8 + VK_FORMAT_R8_UNORM = 9 + VK_FORMAT_R8_SNORM = 10 + VK_FORMAT_R8_USCALED = 11 + VK_FORMAT_R8_SSCALED = 12 + VK_FORMAT_R8_UINT = 13 + VK_FORMAT_R8_SINT = 14 + VK_FORMAT_R8_SRGB = 15 + VK_FORMAT_R8G8_UNORM = 16 + VK_FORMAT_R8G8_SNORM = 17 + VK_FORMAT_R8G8_USCALED = 18 + VK_FORMAT_R8G8_SSCALED = 19 + VK_FORMAT_R8G8_UINT = 20 + VK_FORMAT_R8G8_SINT = 21 + VK_FORMAT_R8G8_SRGB = 22 + VK_FORMAT_R8G8B8_UNORM = 23 + VK_FORMAT_R8G8B8_SNORM = 24 + VK_FORMAT_R8G8B8_USCALED = 25 + VK_FORMAT_R8G8B8_SSCALED = 26 + VK_FORMAT_R8G8B8_UINT = 27 + VK_FORMAT_R8G8B8_SINT = 28 + VK_FORMAT_R8G8B8_SRGB = 29 + VK_FORMAT_B8G8R8_UNORM = 30 + VK_FORMAT_B8G8R8_SNORM = 31 + VK_FORMAT_B8G8R8_USCALED = 32 + VK_FORMAT_B8G8R8_SSCALED = 33 + VK_FORMAT_B8G8R8_UINT = 34 + VK_FORMAT_B8G8R8_SINT = 35 + VK_FORMAT_B8G8R8_SRGB = 36 + VK_FORMAT_R8G8B8A8_UNORM = 37 + VK_FORMAT_R8G8B8A8_SNORM = 38 + VK_FORMAT_R8G8B8A8_USCALED = 39 + VK_FORMAT_R8G8B8A8_SSCALED = 40 + VK_FORMAT_R8G8B8A8_UINT = 41 + VK_FORMAT_R8G8B8A8_SINT = 42 + VK_FORMAT_R8G8B8A8_SRGB = 43 + VK_FORMAT_B8G8R8A8_UNORM = 44 + VK_FORMAT_B8G8R8A8_SNORM = 45 + VK_FORMAT_B8G8R8A8_USCALED = 46 + VK_FORMAT_B8G8R8A8_SSCALED = 47 + VK_FORMAT_B8G8R8A8_UINT = 48 + VK_FORMAT_B8G8R8A8_SINT = 49 + VK_FORMAT_B8G8R8A8_SRGB = 50 + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51 + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52 + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53 + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54 + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55 + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56 + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57 + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58 + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59 + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60 + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61 + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62 + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63 + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64 + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65 + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66 + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67 + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68 + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69 + VK_FORMAT_R16_UNORM = 70 + VK_FORMAT_R16_SNORM = 71 + VK_FORMAT_R16_USCALED = 72 + VK_FORMAT_R16_SSCALED = 73 + VK_FORMAT_R16_UINT = 74 + VK_FORMAT_R16_SINT = 75 + VK_FORMAT_R16_SFLOAT = 76 + VK_FORMAT_R16G16_UNORM = 77 + VK_FORMAT_R16G16_SNORM = 78 + VK_FORMAT_R16G16_USCALED = 79 + VK_FORMAT_R16G16_SSCALED = 80 + VK_FORMAT_R16G16_UINT = 81 + VK_FORMAT_R16G16_SINT = 82 + VK_FORMAT_R16G16_SFLOAT = 83 + VK_FORMAT_R16G16B16_UNORM = 84 + VK_FORMAT_R16G16B16_SNORM = 85 + VK_FORMAT_R16G16B16_USCALED = 86 + VK_FORMAT_R16G16B16_SSCALED = 87 + VK_FORMAT_R16G16B16_UINT = 88 + VK_FORMAT_R16G16B16_SINT = 89 + VK_FORMAT_R16G16B16_SFLOAT = 90 + VK_FORMAT_R16G16B16A16_UNORM = 91 + VK_FORMAT_R16G16B16A16_SNORM = 92 + VK_FORMAT_R16G16B16A16_USCALED = 93 + VK_FORMAT_R16G16B16A16_SSCALED = 94 + VK_FORMAT_R16G16B16A16_UINT = 95 + VK_FORMAT_R16G16B16A16_SINT = 96 + VK_FORMAT_R16G16B16A16_SFLOAT = 97 + VK_FORMAT_R32_UINT = 98 + VK_FORMAT_R32_SINT = 99 + VK_FORMAT_R32_SFLOAT = 100 + VK_FORMAT_R32G32_UINT = 101 + VK_FORMAT_R32G32_SINT = 102 + VK_FORMAT_R32G32_SFLOAT = 103 + VK_FORMAT_R32G32B32_UINT = 104 + VK_FORMAT_R32G32B32_SINT = 105 + VK_FORMAT_R32G32B32_SFLOAT = 106 + VK_FORMAT_R32G32B32A32_UINT = 107 + VK_FORMAT_R32G32B32A32_SINT = 108 + VK_FORMAT_R32G32B32A32_SFLOAT = 109 + VK_FORMAT_R64_UINT = 110 + VK_FORMAT_R64_SINT = 111 + VK_FORMAT_R64_SFLOAT = 112 + VK_FORMAT_R64G64_UINT = 113 + VK_FORMAT_R64G64_SINT = 114 + VK_FORMAT_R64G64_SFLOAT = 115 + VK_FORMAT_R64G64B64_UINT = 116 + VK_FORMAT_R64G64B64_SINT = 117 + VK_FORMAT_R64G64B64_SFLOAT = 118 + VK_FORMAT_R64G64B64A64_UINT = 119 + VK_FORMAT_R64G64B64A64_SINT = 120 + VK_FORMAT_R64G64B64A64_SFLOAT = 121 + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122 + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123 + VK_FORMAT_D16_UNORM = 124 + VK_FORMAT_X8_D24_UNORM_PACK32 = 125 + VK_FORMAT_D32_SFLOAT = 126 + VK_FORMAT_S8_UINT = 127 + VK_FORMAT_D16_UNORM_S8_UINT = 128 + VK_FORMAT_D24_UNORM_S8_UINT = 129 + VK_FORMAT_D32_SFLOAT_S8_UINT = 130 + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131 + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132 + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133 + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134 + VK_FORMAT_BC2_UNORM_BLOCK = 135 + VK_FORMAT_BC2_SRGB_BLOCK = 136 + VK_FORMAT_BC3_UNORM_BLOCK = 137 + VK_FORMAT_BC3_SRGB_BLOCK = 138 + VK_FORMAT_BC4_UNORM_BLOCK = 139 + VK_FORMAT_BC4_SNORM_BLOCK = 140 + VK_FORMAT_BC5_UNORM_BLOCK = 141 + VK_FORMAT_BC5_SNORM_BLOCK = 142 + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143 + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144 + VK_FORMAT_BC7_UNORM_BLOCK = 145 + VK_FORMAT_BC7_SRGB_BLOCK = 146 + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147 + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148 + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149 + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150 + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151 + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152 + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153 + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154 + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155 + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156 + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157 + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158 + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159 + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160 + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161 + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162 + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163 + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164 + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165 + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166 + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167 + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168 + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169 + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170 + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171 + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172 + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173 + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174 + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175 + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176 + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177 + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178 + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179 + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180 + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181 + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182 + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183 + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184 + VkStructureType* {.size: int32.sizeof.} = enum + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0 + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1 + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2 + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3 + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4 + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5 + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6 + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7 + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8 + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9 + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10 + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11 + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12 + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13 + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14 + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15 + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16 + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17 + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18 + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19 + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20 + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21 + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22 + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23 + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24 + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25 + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26 + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27 + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28 + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29 + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30 + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31 + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32 + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33 + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34 + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35 + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36 + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37 + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38 + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39 + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40 + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41 + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42 + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43 + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44 + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45 + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46 + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47 + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48 + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000 # 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: int32.sizeof.} = enum + VK_SUBPASS_CONTENTS_INLINE = 0 + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1 + VkResult* {.size: int32.sizeof.} = 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: int32.sizeof.} = enum + VK_DYNAMIC_STATE_VIEWPORT = 0 + VK_DYNAMIC_STATE_SCISSOR = 1 + VK_DYNAMIC_STATE_LINE_WIDTH = 2 + VK_DYNAMIC_STATE_DEPTH_BIAS = 3 + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4 + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5 + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6 + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7 + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8 + VkDescriptorUpdateTemplateType* {.size: int32.sizeof.} = enum + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0 + VkObjectType* {.size: int32.sizeof.} = enum + VK_OBJECT_TYPE_UNKNOWN = 0 + VK_OBJECT_TYPE_INSTANCE = 1 + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2 + VK_OBJECT_TYPE_DEVICE = 3 + VK_OBJECT_TYPE_QUEUE = 4 + VK_OBJECT_TYPE_SEMAPHORE = 5 + VK_OBJECT_TYPE_COMMAND_BUFFER = 6 + VK_OBJECT_TYPE_FENCE = 7 + VK_OBJECT_TYPE_DEVICE_MEMORY = 8 + VK_OBJECT_TYPE_BUFFER = 9 + VK_OBJECT_TYPE_IMAGE = 10 + VK_OBJECT_TYPE_EVENT = 11 + VK_OBJECT_TYPE_QUERY_POOL = 12 + VK_OBJECT_TYPE_BUFFER_VIEW = 13 + VK_OBJECT_TYPE_IMAGE_VIEW = 14 + VK_OBJECT_TYPE_SHADER_MODULE = 15 + VK_OBJECT_TYPE_PIPELINE_CACHE = 16 + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17 + VK_OBJECT_TYPE_RENDER_PASS = 18 + VK_OBJECT_TYPE_PIPELINE = 19 + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20 + VK_OBJECT_TYPE_SAMPLER = 21 + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22 + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23 + VK_OBJECT_TYPE_FRAMEBUFFER = 24 + VK_OBJECT_TYPE_COMMAND_POOL = 25 + VkQueueFlagBits* {.size: int32.sizeof.} = enum + VK_QUEUE_GRAPHICS_BIT = 1 + VK_QUEUE_COMPUTE_BIT = 2 + VK_QUEUE_TRANSFER_BIT = 4 + VK_QUEUE_SPARSE_BINDING_BIT = 8 + VkMemoryPropertyFlagBits* {.size: int32.sizeof.} = enum + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1 + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 2 + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 4 + VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 8 + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 16 + VkMemoryHeapFlagBits* {.size: int32.sizeof.} = enum + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1 + VkAccessFlagBits* {.size: int32.sizeof.} = enum + VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 1 + VK_ACCESS_INDEX_READ_BIT = 2 + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 4 + VK_ACCESS_UNIFORM_READ_BIT = 8 + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 16 + VK_ACCESS_SHADER_READ_BIT = 32 + VK_ACCESS_SHADER_WRITE_BIT = 64 + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 128 + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 256 + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 512 + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 1024 + VK_ACCESS_TRANSFER_READ_BIT = 2048 + VK_ACCESS_TRANSFER_WRITE_BIT = 4096 + VK_ACCESS_HOST_READ_BIT = 8192 + VK_ACCESS_HOST_WRITE_BIT = 16384 + VK_ACCESS_MEMORY_READ_BIT = 32768 + VK_ACCESS_MEMORY_WRITE_BIT = 65536 + VkBufferUsageFlagBits* {.size: int32.sizeof.} = enum + VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 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: int32.sizeof.} = enum + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1 + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2 + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 4 + VkShaderStageFlagBits* {.size: int32.sizeof.} = enum + VK_SHADER_STAGE_VERTEX_BIT = 1 + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 2 + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 4 + VK_SHADER_STAGE_GEOMETRY_BIT = 8 + VK_SHADER_STAGE_FRAGMENT_BIT = 16 + VK_SHADER_STAGE_ALL_GRAPHICS = 31 + VK_SHADER_STAGE_COMPUTE_BIT = 32 + VK_SHADER_STAGE_ALL = 2147483647 + VkImageUsageFlagBits* {.size: int32.sizeof.} = enum + VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 1 + VK_IMAGE_USAGE_TRANSFER_DST_BIT = 2 + VK_IMAGE_USAGE_SAMPLED_BIT = 4 + VK_IMAGE_USAGE_STORAGE_BIT = 8 + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 16 + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 32 + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 64 + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 128 + VkImageCreateFlagBits* {.size: int32.sizeof.} = enum + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 1 + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 2 + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 4 + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 8 + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 16 + VkPipelineCreateFlagBits* {.size: int32.sizeof.} = enum + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1 + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2 + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 4 + VkColorComponentFlagBits* {.size: int32.sizeof.} = enum + VK_COLOR_COMPONENT_R_BIT = 1 + VK_COLOR_COMPONENT_G_BIT = 2 + VK_COLOR_COMPONENT_B_BIT = 4 + VK_COLOR_COMPONENT_A_BIT = 8 + VkFenceCreateFlagBits* {.size: int32.sizeof.} = enum + VK_FENCE_CREATE_SIGNALED_BIT = 1 + VkFormatFeatureFlagBits* {.size: int32.sizeof.} = enum + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1 + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 2 + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 4 + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 8 + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 16 + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 32 + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 64 + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 128 + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 256 + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 512 + VK_FORMAT_FEATURE_BLIT_SRC_BIT = 1024 + VK_FORMAT_FEATURE_BLIT_DST_BIT = 2048 + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4096 + VkQueryControlFlagBits* {.size: int32.sizeof.} = enum + VK_QUERY_CONTROL_PRECISE_BIT = 1 + VkQueryResultFlagBits* {.size: int32.sizeof.} = enum + VK_QUERY_RESULT_64_BIT = 1 + VK_QUERY_RESULT_WAIT_BIT = 2 + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 4 + VK_QUERY_RESULT_PARTIAL_BIT = 8 + VkCommandBufferUsageFlagBits* {.size: int32.sizeof.} = enum + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1 + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 2 + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 4 + VkQueryPipelineStatisticFlagBits* {.size: int32.sizeof.} = enum + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1 + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 2 + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 4 + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 8 + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 16 + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 32 + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 64 + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 128 + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 256 + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 512 + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1024 + VkImageAspectFlagBits* {.size: int32.sizeof.} = enum + VK_IMAGE_ASPECT_COLOR_BIT = 1 + VK_IMAGE_ASPECT_DEPTH_BIT = 2 + VK_IMAGE_ASPECT_STENCIL_BIT = 4 + VK_IMAGE_ASPECT_METADATA_BIT = 8 + VkSparseImageFormatFlagBits* {.size: int32.sizeof.} = enum + VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1 + VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 2 + VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 4 + VkSparseMemoryBindFlagBits* {.size: int32.sizeof.} = enum + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1 + VkPipelineStageFlagBits* {.size: int32.sizeof.} = enum + VK_PIPELINE_STAGE_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: int32.sizeof.} = enum + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1 + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2 + VkCommandPoolResetFlagBits* {.size: int32.sizeof.} = enum + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1 + VkCommandBufferResetFlagBits* {.size: int32.sizeof.} = enum + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1 + VkSampleCountFlagBits* {.size: int32.sizeof.} = enum + VK_SAMPLE_COUNT_1_BIT = 1 + VK_SAMPLE_COUNT_2_BIT = 2 + VK_SAMPLE_COUNT_4_BIT = 4 + VK_SAMPLE_COUNT_8_BIT = 8 + VK_SAMPLE_COUNT_16_BIT = 16 + VK_SAMPLE_COUNT_32_BIT = 32 + VK_SAMPLE_COUNT_64_BIT = 64 + VkAttachmentDescriptionFlagBits* {.size: int32.sizeof.} = enum + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1 + VkStencilFaceFlagBits* {.size: int32.sizeof.} = enum + VK_STENCIL_FACE_FRONT_BIT = 1 + VK_STENCIL_FACE_BACK_BIT = 2 + VK_STENCIL_FACE_FRONT_AND_BACK = 3 + VkDescriptorPoolCreateFlagBits* {.size: int32.sizeof.} = enum + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1 + VkDependencyFlagBits* {.size: int32.sizeof.} = enum + VK_DEPENDENCY_BY_REGION_BIT = 1 + VkSemaphoreType* {.size: int32.sizeof.} = enum + VK_SEMAPHORE_TYPE_BINARY = 0 + VK_SEMAPHORE_TYPE_TIMELINE = 1 + VkSemaphoreWaitFlagBits* {.size: int32.sizeof.} = enum + VK_SEMAPHORE_WAIT_ANY_BIT = 1 + VkPresentModeKHR* {.size: int32.sizeof.} = enum + VK_PRESENT_MODE_IMMEDIATE_KHR = 0 + VK_PRESENT_MODE_MAILBOX_KHR = 1 + VK_PRESENT_MODE_FIFO_KHR = 2 + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3 + VkColorSpaceKHR* {.size: int32.sizeof.} = enum + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0 + VkDisplayPlaneAlphaFlagBitsKHR* {.size: int32.sizeof.} = enum + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 1 + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 2 + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 4 + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 8 + VkCompositeAlphaFlagBitsKHR* {.size: int32.sizeof.} = enum + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 1 + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 2 + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 4 + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 8 + VkSurfaceTransformFlagBitsKHR* {.size: int32.sizeof.} = enum + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 1 + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 2 + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 4 + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 8 + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 16 + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 32 + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 64 + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 128 + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 256 + VkSwapchainImageUsageFlagBitsANDROID* {.size: int32.sizeof.} = enum + VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 1 + VkTimeDomainEXT* {.size: int32.sizeof.} = enum + VK_TIME_DOMAIN_DEVICE_EXT = 0 + VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1 + VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2 + VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3 + VkDebugReportFlagBitsEXT* {.size: int32.sizeof.} = enum + VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 1 + VK_DEBUG_REPORT_WARNING_BIT_EXT = 2 + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 4 + VK_DEBUG_REPORT_ERROR_BIT_EXT = 8 + VK_DEBUG_REPORT_DEBUG_BIT_EXT = 16 + VkDebugReportObjectTypeEXT* {.size: int32.sizeof.} = enum + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0 + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1 + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2 + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3 + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4 + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5 + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6 + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7 + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8 + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9 + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10 + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11 + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12 + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13 + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14 + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15 + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16 + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17 + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18 + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19 + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20 + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21 + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22 + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23 + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24 + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25 + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26 + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27 + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28 + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29 + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30 + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33 + VkRasterizationOrderAMD* {.size: int32.sizeof.} = enum + VK_RASTERIZATION_ORDER_STRICT_AMD = 0 + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1 + VkExternalMemoryHandleTypeFlagBitsNV* {.size: int32.sizeof.} = enum + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 1 + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 2 + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 4 + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 8 + VkExternalMemoryFeatureFlagBitsNV* {.size: int32.sizeof.} = enum + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 1 + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 2 + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 4 + VkValidationCheckEXT* {.size: int32.sizeof.} = enum + VK_VALIDATION_CHECK_ALL_EXT = 0 + VK_VALIDATION_CHECK_SHADERS_EXT = 1 + VkValidationFeatureEnableEXT* {.size: int32.sizeof.} = enum + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0 + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1 + VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2 + VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3 + VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4 + VkValidationFeatureDisableEXT* {.size: int32.sizeof.} = enum + VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0 + VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1 + VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2 + VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3 + VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4 + VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5 + VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6 + VkSubgroupFeatureFlagBits* {.size: int32.sizeof.} = enum + VK_SUBGROUP_FEATURE_BASIC_BIT = 1 + VK_SUBGROUP_FEATURE_VOTE_BIT = 2 + VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 4 + VK_SUBGROUP_FEATURE_BALLOT_BIT = 8 + VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 16 + VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 32 + VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 64 + VK_SUBGROUP_FEATURE_QUAD_BIT = 128 + VkIndirectCommandsLayoutUsageFlagBitsNV* {.size: int32.sizeof.} = enum + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 1 + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 2 + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 4 + VkIndirectStateFlagBitsNV* {.size: int32.sizeof.} = enum + VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 1 + VkIndirectCommandsTokenTypeNV* {.size: int32.sizeof.} = enum + VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0 + VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1 + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2 + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3 + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4 + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5 + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6 + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7 + VkExternalMemoryHandleTypeFlagBits* {.size: int32.sizeof.} = enum + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 1 + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2 + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4 + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 8 + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 16 + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 32 + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 64 + VkExternalMemoryFeatureFlagBits* {.size: int32.sizeof.} = enum + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1 + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2 + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4 + VkExternalSemaphoreHandleTypeFlagBits* {.size: int32.sizeof.} = enum + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 1 + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2 + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4 + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 8 + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 16 + VkExternalSemaphoreFeatureFlagBits* {.size: int32.sizeof.} = enum + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1 + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2 + VkSemaphoreImportFlagBits* {.size: int32.sizeof.} = enum + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1 + VkExternalFenceHandleTypeFlagBits* {.size: int32.sizeof.} = enum + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 1 + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2 + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 4 + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 8 + VkExternalFenceFeatureFlagBits* {.size: int32.sizeof.} = enum + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1 + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2 + VkFenceImportFlagBits* {.size: int32.sizeof.} = enum + VK_FENCE_IMPORT_TEMPORARY_BIT = 1 + VkSurfaceCounterFlagBitsEXT* {.size: int32.sizeof.} = enum + VK_SURFACE_COUNTER_VBLANK_EXT = 1 + VkDisplayPowerStateEXT* {.size: int32.sizeof.} = enum + VK_DISPLAY_POWER_STATE_OFF_EXT = 0 + VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1 + VK_DISPLAY_POWER_STATE_ON_EXT = 2 + VkDeviceEventTypeEXT* {.size: int32.sizeof.} = enum + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0 + VkDisplayEventTypeEXT* {.size: int32.sizeof.} = enum + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0 + VkPeerMemoryFeatureFlagBits* {.size: int32.sizeof.} = enum + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 1 + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 2 + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 4 + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 8 + VkMemoryAllocateFlagBits* {.size: int32.sizeof.} = enum + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1 + VkDeviceGroupPresentModeFlagBitsKHR* {.size: int32.sizeof.} = enum + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 1 + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 2 + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 4 + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 8 + VkViewportCoordinateSwizzleNV* {.size: int32.sizeof.} = enum + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0 + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1 + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2 + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3 + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4 + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5 + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6 + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7 + VkDiscardRectangleModeEXT* {.size: int32.sizeof.} = enum + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0 + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1 + VkPointClippingBehavior* {.size: int32.sizeof.} = enum + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0 + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1 + VkSamplerReductionMode* {.size: int32.sizeof.} = enum + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0 + VK_SAMPLER_REDUCTION_MODE_MIN = 1 + VK_SAMPLER_REDUCTION_MODE_MAX = 2 + VkTessellationDomainOrigin* {.size: int32.sizeof.} = enum + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0 + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1 + VkSamplerYcbcrModelConversion* {.size: int32.sizeof.} = enum + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0 + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1 + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2 + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3 + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4 + VkSamplerYcbcrRange* {.size: int32.sizeof.} = enum + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0 + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1 + VkChromaLocation* {.size: int32.sizeof.} = enum + VK_CHROMA_LOCATION_COSITED_EVEN = 0 + VK_CHROMA_LOCATION_MIDPOINT = 1 + VkBlendOverlapEXT* {.size: int32.sizeof.} = enum + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0 + VK_BLEND_OVERLAP_DISJOINT_EXT = 1 + VK_BLEND_OVERLAP_CONJOINT_EXT = 2 + VkCoverageModulationModeNV* {.size: int32.sizeof.} = enum + VK_COVERAGE_MODULATION_MODE_NONE_NV = 0 + VK_COVERAGE_MODULATION_MODE_RGB_NV = 1 + VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2 + VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3 + VkCoverageReductionModeNV* {.size: int32.sizeof.} = enum + VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0 + VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1 + VkValidationCacheHeaderVersionEXT* {.size: int32.sizeof.} = enum + VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1 + VkShaderInfoTypeAMD* {.size: int32.sizeof.} = enum + VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0 + VK_SHADER_INFO_TYPE_BINARY_AMD = 1 + VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2 + VkQueueGlobalPriorityEXT* {.size: int32.sizeof.} = enum + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128 + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256 + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512 + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024 + VkDebugUtilsMessageSeverityFlagBitsEXT* {.size: int32.sizeof.} = enum + VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 1 + VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 16 + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 256 + VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 4096 + VkDebugUtilsMessageTypeFlagBitsEXT* {.size: int32.sizeof.} = enum + VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 1 + VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 2 + VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 4 + VkConservativeRasterizationModeEXT* {.size: int32.sizeof.} = enum + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0 + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1 + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2 + VkDescriptorBindingFlagBits* {.size: int32.sizeof.} = enum + VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 1 + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 2 + VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 4 + VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 8 + VkVendorId* {.size: int32.sizeof.} = enum + VK_VENDOR_ID_VIV = 65537 + VK_VENDOR_ID_VSI = 65538 + VK_VENDOR_ID_KAZAN = 65539 + VK_VENDOR_ID_CODEPLAY = 65540 + VK_VENDOR_ID_MESA = 65541 + VkDriverId* {.size: int32.sizeof.} = enum + VK_DRIVER_ID_AMD_PROPRIETARY = 1 + VK_DRIVER_ID_AMD_OPEN_SOURCE = 2 + VK_DRIVER_ID_MESA_RADV = 3 + VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4 + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5 + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6 + VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7 + VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8 + VK_DRIVER_ID_ARM_PROPRIETARY = 9 + VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10 + VK_DRIVER_ID_GGP_PROPRIETARY = 11 + VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12 + VK_DRIVER_ID_MESA_LLVMPIPE = 13 + VK_DRIVER_ID_MOLTENVK = 14 + VkConditionalRenderingFlagBitsEXT* {.size: int32.sizeof.} = enum + VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 1 + VkResolveModeFlagBits* {.size: int32.sizeof.} = enum + VK_RESOLVE_MODE_NONE = 0 + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 1 + VK_RESOLVE_MODE_AVERAGE_BIT = 2 + VK_RESOLVE_MODE_MIN_BIT = 4 + VK_RESOLVE_MODE_MAX_BIT = 8 + VkShadingRatePaletteEntryNV* {.size: int32.sizeof.} = enum + VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0 + VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1 + VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2 + VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3 + VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4 + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5 + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6 + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7 + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8 + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9 + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10 + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11 + VkCoarseSampleOrderTypeNV* {.size: int32.sizeof.} = enum + VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0 + VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1 + VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2 + VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3 + VkGeometryInstanceFlagBitsKHR* {.size: int32.sizeof.} = enum + VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 1 + VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = 2 + VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 4 + VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 8 + VkGeometryFlagBitsKHR* {.size: int32.sizeof.} = enum + VK_GEOMETRY_OPAQUE_BIT_KHR = 1 + VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 2 + VkBuildAccelerationStructureFlagBitsKHR* {.size: int32.sizeof.} = enum + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 1 + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 2 + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 4 + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 8 + VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 16 + VkCopyAccelerationStructureModeKHR* {.size: int32.sizeof.} = enum + VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0 + VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1 + VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2 + VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3 + VkAccelerationStructureTypeKHR* {.size: int32.sizeof.} = enum + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0 + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1 + VkGeometryTypeKHR* {.size: int32.sizeof.} = enum + VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0 + VK_GEOMETRY_TYPE_AABBS_KHR = 1 + VkAccelerationStructureMemoryRequirementsTypeKHR* {.size: int32.sizeof.} = enum + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_KHR = 0 + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_KHR = 1 + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_KHR = 2 + VkAccelerationStructureBuildTypeKHR* {.size: int32.sizeof.} = enum + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0 + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1 + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2 + VkRayTracingShaderGroupTypeKHR* {.size: int32.sizeof.} = enum + VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0 + VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1 + VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2 + VkMemoryOverallocationBehaviorAMD* {.size: int32.sizeof.} = enum + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0 + VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1 + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2 + VkScopeNV* {.size: int32.sizeof.} = enum + VK_SCOPE_DEVICE_NV = 1 + VK_SCOPE_WORKGROUP_NV = 2 + VK_SCOPE_SUBGROUP_NV = 3 + VK_SCOPE_QUEUE_FAMILY_NV = 5 + VkComponentTypeNV* {.size: int32.sizeof.} = enum + VK_COMPONENT_TYPE_FLOAT16_NV = 0 + VK_COMPONENT_TYPE_FLOAT32_NV = 1 + VK_COMPONENT_TYPE_FLOAT64_NV = 2 + VK_COMPONENT_TYPE_SINT8_NV = 3 + VK_COMPONENT_TYPE_SINT16_NV = 4 + VK_COMPONENT_TYPE_SINT32_NV = 5 + VK_COMPONENT_TYPE_SINT64_NV = 6 + VK_COMPONENT_TYPE_UINT8_NV = 7 + VK_COMPONENT_TYPE_UINT16_NV = 8 + VK_COMPONENT_TYPE_UINT32_NV = 9 + VK_COMPONENT_TYPE_UINT64_NV = 10 + VkDeviceDiagnosticsConfigFlagBitsNV* {.size: int32.sizeof.} = enum + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 1 + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 2 + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 4 + VkPipelineCreationFeedbackFlagBitsEXT* {.size: int32.sizeof.} = enum + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 1 + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 2 + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 4 + VkFullScreenExclusiveEXT* {.size: int32.sizeof.} = enum + VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0 + VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1 + VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2 + VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3 + VkPerformanceCounterScopeKHR* {.size: int32.sizeof.} = enum + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0 + VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1 + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2 + VkPerformanceCounterUnitKHR* {.size: int32.sizeof.} = enum + VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0 + VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1 + VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2 + VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3 + VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4 + VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5 + VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6 + VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7 + VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8 + VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9 + VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10 + VkPerformanceCounterStorageKHR* {.size: int32.sizeof.} = enum + VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0 + VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1 + VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2 + VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3 + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4 + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5 + VkPerformanceCounterDescriptionFlagBitsKHR* {.size: int32.sizeof.} = enum + VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 1 + VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 2 + VkPerformanceConfigurationTypeINTEL* {.size: int32.sizeof.} = enum + VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0 + VkQueryPoolSamplingModeINTEL* {.size: int32.sizeof.} = enum + VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0 + VkPerformanceOverrideTypeINTEL* {.size: int32.sizeof.} = enum + VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0 + VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1 + VkPerformanceParameterTypeINTEL* {.size: int32.sizeof.} = enum + VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0 + VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1 + VkPerformanceValueTypeINTEL* {.size: int32.sizeof.} = enum + VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0 + VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1 + VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2 + VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3 + VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4 + VkShaderFloatControlsIndependence* {.size: int32.sizeof.} = enum + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0 + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1 + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2 + VkPipelineExecutableStatisticFormatKHR* {.size: int32.sizeof.} = enum + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0 + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1 + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2 + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3 + VkLineRasterizationModeEXT* {.size: int32.sizeof.} = enum + VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0 + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1 + VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2 + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3 + VkToolPurposeFlagBitsEXT* {.size: int32.sizeof.} = enum + VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = 1 + VK_TOOL_PURPOSE_PROFILING_BIT_EXT = 2 + VK_TOOL_PURPOSE_TRACING_BIT_EXT = 4 + VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = 8 + VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = 16 + +# Types + +# stub types if we are on the wrong platform, so we don't need to "when" all platform functions +when not defined(linux): + type + Display* = ptr object + VisualID* = ptr object + Window* = ptr object +when not defined(windows): + type + HINSTANCE* = ptr object + HWND* = ptr object + HMONITOR* = ptr object + HANDLE* = ptr object + SECURITY_ATTRIBUTES* = ptr object + DWORD* = ptr object + LPCWSTR* = ptr object + +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
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/vulkan_helpers.nim Thu Dec 22 19:33:00 2022 +0700 @@ -0,0 +1,259 @@ +import std/tables +import std/strutils +import std/strformat +import std/logging + +import ./glslang/glslang +import ./vulkan +import ./window + +when defined(release): + const ENABLEVULKANVALIDATIONLAYERS* = false +else: + const ENABLEVULKANVALIDATIONLAYERS* = true + + +template checkVkResult*(call: untyped) = + when defined(release): + discard call + else: + debug(&"CALLING vulkan: {astToStr(call)}") + let value = call + if value != VK_SUCCESS: + raise newException(Exception, "Vulkan error: " & astToStr(call) & " returned " & $value) + +func addrOrNil[T](obj: var openArray[T]): ptr T = + if obj.len > 0: addr(obj[0]) else: nil + +proc VK_MAKE_API_VERSION*(variant: uint32, major: uint32, minor: uint32, patch: uint32): uint32 {.compileTime.} = + (variant shl 29) or (major shl 22) or (minor shl 12) or patch + + +proc filterForSurfaceFormat*(formats: seq[VkSurfaceFormatKHR]): seq[VkSurfaceFormatKHR] = + for format in formats: + if format.format == VK_FORMAT_B8G8R8A8_SRGB and format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: + result.add(format) + +proc getSuitableSurfaceFormat*(formats: seq[VkSurfaceFormatKHR]): VkSurfaceFormatKHR = + let usableSurfaceFormats = filterForSurfaceFormat(formats) + if len(usableSurfaceFormats) == 0: + raise newException(Exception, "No suitable surface formats found") + return usableSurfaceFormats[0] + + +proc cleanString*(str: openArray[char]): string = + for i in 0 ..< len(str): + if str[i] == char(0): + result = join(str[0 ..< i]) + break + +proc getInstanceExtensions*(): seq[string] = + var extensionCount: uint32 + checkVkResult vkEnumerateInstanceExtensionProperties(nil, addr(extensionCount), nil) + var extensions = newSeq[VkExtensionProperties](extensionCount) + checkVkResult vkEnumerateInstanceExtensionProperties(nil, addr(extensionCount), addrOrNil(extensions)) + + for extension in extensions: + result.add(cleanString(extension.extensionName)) + + +proc getDeviceExtensions*(device: VkPhysicalDevice): seq[string] = + var extensionCount: uint32 + checkVkResult vkEnumerateDeviceExtensionProperties(device, nil, addr(extensionCount), nil) + var extensions = newSeq[VkExtensionProperties](extensionCount) + checkVkResult vkEnumerateDeviceExtensionProperties(device, nil, addr(extensionCount), addrOrNil(extensions)) + + for extension in extensions: + result.add(cleanString(extension.extensionName)) + + +proc getValidationLayers*(): seq[string] = + var n_layers: uint32 + checkVkResult vkEnumerateInstanceLayerProperties(addr(n_layers), nil) + var layers = newSeq[VkLayerProperties](n_layers) + checkVkResult vkEnumerateInstanceLayerProperties(addr(n_layers), addrOrNil(layers)) + + for layer in layers: + result.add(cleanString(layer.layerName)) + + +proc getVulkanPhysicalDevices*(instance: VkInstance): seq[VkPhysicalDevice] = + var n_devices: uint32 + checkVkResult vkEnumeratePhysicalDevices(instance, addr(n_devices), nil) + result = newSeq[VkPhysicalDevice](n_devices) + checkVkResult vkEnumeratePhysicalDevices(instance, addr(n_devices), addrOrNil(result)) + + +proc getQueueFamilies*(device: VkPhysicalDevice): seq[VkQueueFamilyProperties] = + var n_queuefamilies: uint32 + vkGetPhysicalDeviceQueueFamilyProperties(device, addr(n_queuefamilies), nil) + result = newSeq[VkQueueFamilyProperties](n_queuefamilies) + vkGetPhysicalDeviceQueueFamilyProperties(device, addr(n_queuefamilies), addrOrNil(result)) + + +proc getDeviceSurfaceFormats*(device: VkPhysicalDevice, surface: VkSurfaceKHR): seq[VkSurfaceFormatKHR] = + var n_formats: uint32 + checkVkResult vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, addr(n_formats), nil); + result = newSeq[VkSurfaceFormatKHR](n_formats) + checkVkResult vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, addr(n_formats), addrOrNil(result)) + + +proc getDeviceSurfacePresentModes*(device: VkPhysicalDevice, surface: VkSurfaceKHR): seq[VkPresentModeKHR] = + var n_modes: uint32 + checkVkResult vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, addr(n_modes), nil); + result = newSeq[VkPresentModeKHR](n_modes) + checkVkResult vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, addr(n_modes), addrOrNil(result)) + + +proc getSwapChainImages*(device: VkDevice, swapChain: VkSwapchainKHR): seq[VkImage] = + var n_images: uint32 + checkVkResult vkGetSwapchainImagesKHR(device, swapChain, addr(n_images), nil); + result = newSeq[VkImage](n_images) + checkVkResult vkGetSwapchainImagesKHR(device, swapChain, addr(n_images), addrOrNil(result)); + + +proc getPresentMode*(modes: seq[VkPresentModeKHR]): VkPresentModeKHR = + let preferredModes = [ + VK_PRESENT_MODE_MAILBOX_KHR, # triple buffering + VK_PRESENT_MODE_FIFO_RELAXED_KHR, # double duffering + VK_PRESENT_MODE_FIFO_KHR, # double duffering + VK_PRESENT_MODE_IMMEDIATE_KHR, # single buffering + ] + for preferredMode in preferredModes: + for mode in modes: + if preferredMode == mode: + return mode + # should never be reached, but seems to be garuanteed by vulkan specs to always be available + return VK_PRESENT_MODE_FIFO_KHR + + +proc createVulkanInstance*(vulkanVersion: uint32): VkInstance = + var requiredExtensions = [ + "VK_EXT_acquire_xlib_display".cstring, + "VK_EXT_direct_mode_display".cstring, + "VK_KHR_display".cstring, + "VK_KHR_surface".cstring, + "VK_KHR_xlib_surface".cstring, + "VK_EXT_debug_utils".cstring, + ] + let availableExtensions = getInstanceExtensions() + for extension in requiredExtensions: + assert $extension in availableExtensions + + let desiredLayers = ["VK_LAYER_KHRONOS_validation".cstring, "VK_LAYER_MESA_overlay".cstring] + let availableLayers = getValidationLayers() + var usableLayers = newSeq[cstring]() + + when ENABLEVULKANVALIDATIONLAYERS: + for layer in desiredLayers: + if $layer in availableLayers: + usableLayers.add(layer) + + echo "Available validation layers: ", availableLayers + echo "Using validation layers: ", usableLayers + echo "Available extensions: ", availableExtensions + echo "Using extensions: ", requiredExtensions + + var appinfo = VkApplicationInfo( + sType: VK_STRUCTURE_TYPE_APPLICATION_INFO, + pApplicationName: "Hello Triangle", + pEngineName: "Custom engine", + apiVersion: vulkanVersion, + ) + var createinfo = VkInstanceCreateInfo( + sType: VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + pApplicationInfo: addr(appinfo), + enabledLayerCount: usableLayers.len.uint32, + ppEnabledLayerNames: cast[ptr UncheckedArray[cstring]](addrOrNil(usableLayers)), + enabledExtensionCount: requiredExtensions.len.uint32, + ppEnabledExtensionNames: cast[ptr UncheckedArray[cstring]](addr(requiredExtensions)) + ) + checkVkResult vkCreateInstance(addr(createinfo), nil, addr(result)) + + loadVK_KHR_surface() + loadVK_KHR_xlib_surface() + loadVK_KHR_swapchain() + when ENABLEVULKANVALIDATIONLAYERS: + loadVK_EXT_debug_utils(result) + + +proc getVulcanDevice*( + physicalDevice: var VkPhysicalDevice, + features: var VkPhysicalDeviceFeatures, + graphicsQueueFamily: uint32, + presentationQueueFamily: uint32, +): (VkDevice, VkQueue, VkQueue) = + # setup queue and device + # TODO: need check this, possibly wrong logic, see Vulkan tutorial + var priority = 1.0'f32 + var queueCreateInfo = [ + VkDeviceQueueCreateInfo( + sType: VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, + queueFamilyIndex: graphicsQueueFamily, + queueCount: 1, + pQueuePriorities: addr(priority), + ), + ] + + var requiredExtensions = ["VK_KHR_swapchain".cstring] + var deviceCreateInfo = VkDeviceCreateInfo( + sType: VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, + queueCreateInfoCount: uint32(queueCreateInfo.len), + pQueueCreateInfos: addrOrNil(queueCreateInfo), + pEnabledFeatures: addr(features), + enabledExtensionCount: requiredExtensions.len.uint32, + ppEnabledExtensionNames: cast[ptr UncheckedArray[cstring]](addr(requiredExtensions)) + ) + checkVkResult vkCreateDevice(physicalDevice, addr(deviceCreateInfo), nil, addr(result[0])) + vkGetDeviceQueue(result[0], graphicsQueueFamily, 0'u32, addr(result[1])); + vkGetDeviceQueue(result[0], presentationQueueFamily, 0'u32, addr(result[2])); + +proc createShaderStage*(device: VkDevice, stage: VkShaderStageFlagBits, shader: string): VkPipelineShaderStageCreateInfo = + const VK_GLSL_MAP = { + VK_SHADER_STAGE_VERTEX_BIT: GLSLANG_STAGE_VERTEX, + VK_SHADER_STAGE_FRAGMENT_BIT: GLSLANG_STAGE_FRAGMENT, + }.toTable() + var code = compileGLSLToSPIRV(VK_GLSL_MAP[stage], shader, "<memory-shader>") + var createInfo = VkShaderModuleCreateInfo( + sType: VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + codeSize: uint(code.len * sizeof(uint32)), + pCode: addrOrNil(code), + ) + var shaderModule: VkShaderModule + checkVkResult vkCreateShaderModule(device, addr(createInfo), nil, addr(shaderModule)) + + return VkPipelineShaderStageCreateInfo( + sType: VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + stage: stage, + module: shaderModule, + pName: "main", # entry point for shader + ) + +proc debugCallback*( + messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, + messageTypes: VkDebugUtilsMessageTypeFlagsEXT, + pCallbackData: VkDebugUtilsMessengerCallbackDataEXT, + userData: pointer +): VkBool32 {.cdecl.} = + echo &"{messageSeverity}: {VkDebugUtilsMessageTypeFlagBitsEXT(messageTypes)}: {pCallbackData.pMessage}" + return VK_FALSE + +proc getSurfaceCapabilities*(device: VkPhysicalDevice, surface: VkSurfaceKHR): VkSurfaceCapabilitiesKHR = + checkVkResult device.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(surface, addr(result)) + +when defined(linux): + 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)) +when defined(windows): + 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))