From 4e9b83e993901a9f1532ff47208baf7cda0c1b18 Mon Sep 17 00:00:00 2001 From: Vlad-Stefan Harbuz Date: Sat, 4 Jun 2022 20:07:30 +0100 Subject: [PATCH] initial commit --- LICENSE | 9 + Makefile | 15 + README.md | 11 + cmd/demo/main.ha | 53 + vendor/vk-v1.3/vk/vk.ha | 8027 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 8115 insertions(+) create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 README.md create mode 100644 cmd/demo/main.ha create mode 100644 vendor/vk-v1.3/vk/vk.ha diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..47336bb --- /dev/null +++ b/LICENSE @@ -0,0 +1,9 @@ +Copyright (c) 2022 Christopher W. Nicholson +Copyright (c) 2022 Vlad-Stefan Harbuz + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +The software is provided "as is" and the author disclaims all warranties +with regard to this software. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..2a76ed1 --- /dev/null +++ b/Makefile @@ -0,0 +1,15 @@ +.POSIX: +.SUFFIXES: + +LIBS=-lvulkan +VARS=LD_LIBRARY_PATH=/usr/lib:${LD_LIBRARY_PATH} \ + HAREPATH=vendor/vk-v1.3:${HAREPATH} + +demo: + $(VARS) hare build $(LIBS) cmd/demo + +run: + @ # Bug https://todo.sr.ht/~sircmpwn/hare/569 + $(VARS) hare run $(LIBS) cmd/demo + +.PHONY: demo run diff --git a/README.md b/README.md new file mode 100644 index 0000000..1e1d6f3 --- /dev/null +++ b/README.md @@ -0,0 +1,11 @@ +# Hare Vulkan Hello World + +This is a simple Hello World, showing how to use Vulkan with Hare. + +It is based on work done by Christopher W. Nicholson to add Vulkan support to +[glad](https://git.sr.ht/~vladh/glad) (thank you!). + +## Usage + +* Install Vulkan +* Run `make run` to run the demo diff --git a/cmd/demo/main.ha b/cmd/demo/main.ha new file mode 100644 index 0000000..c03a09e --- /dev/null +++ b/cmd/demo/main.ha @@ -0,0 +1,53 @@ +use fmt; +use types; +use vk; + +fn str_to_cstr(in: const str) *const char = { + return ((&in): *const types::string).data: *const char; +}; + +fn create_instance( + program_name: str, + engine_name: str, + use_validations: bool +) (vk::VkInstance | vk::VkResult) = { + vk::load_loader(); + + const appInfo = vk::VkApplicationInfo { + sType = vk::VkStructureType::VK_STRUCTURE_TYPE_APPLICATION_INFO, + pNext = null, + pApplicationName = str_to_cstr(program_name), + applicationVersion = vk::VK_MAKE_API_VERSION(0, 0, 0, 1), + pEngineName = str_to_cstr(engine_name), + engineVersion = vk::VK_MAKE_API_VERSION(0, 0, 0, 1), + apiVersion = vk::VK_API_VERSION_1_0, + }; + const ci = vk::VkInstanceCreateInfo { + sType = vk::VkStructureType::VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + pNext = null, + flags = 0, + enabledLayerCount = 0, + pApplicationInfo = &appInfo, + ppEnabledLayerNames = null, + enabledExtensionCount = 0, + ppEnabledExtensionNames = null, + }; + + let instance: vk::VkInstance = null; + const res: vk::VkResult = vk::vkCreateInstance(&ci, null, &instance); + if (res == vk::VkResult::VK_SUCCESS) { + vk::load_instance(instance); + return instance; + } else { + return res; + }; +}; + +export fn main() void = { + match (create_instance("sample program\0", "No Engine\0", true)) { + case let instance: vk::VkInstance => + fmt::printfln("create_instance returned an instance: {}", instance)!; + case let status: vk::VkResult => + fmt::printfln("create_instance returned status {}", vk::StrVkResult(status))!; + }; +}; diff --git a/vendor/vk-v1.3/vk/vk.ha b/vendor/vk-v1.3/vk/vk.ha new file mode 100644 index 0000000..ad6d4ff --- /dev/null +++ b/vendor/vk-v1.3/vk/vk.ha @@ -0,0 +1,8027 @@ +use types; + +// Built-in loader +@symbol("vkGetInstanceProcAddr") fn _vkGetInstanceProcAddr(instance: nullable *void, procName: *const char) *void; +@symbol("vkGetDeviceProcAddr") fn _vkGetDeviceProcAddr(device: nullable *void, procName: *const char) *void; + +fn get_instance_proc_address(instance: nullable *void, proc_name: *const char) *void = { + let cstr = ((proc_name): *types::string).data: *const char; + return _vkGetInstanceProcAddr(instance, cstr); +}; +fn get_device_proc_address(device: nullable *void, proc_name: *const char) *void = { + let cstr = ((proc_name): *types::string).data: *const char; + return _vkGetDeviceProcAddr(device, cstr); +}; + +// Types + +// XCB +export type xcb_connection_t = nullable *void; +export type xcb_window_t = u32; +export type xcb_visualid_t = u32; +export type zx_handle_t = u32; + +// Android (somehow already defined) +// export type ANativeWindow = nullable *void; +// export type AHardwareBuffer = nullable *void; + +// iOS / macOS (some are somehow already defined) +// export type CAMetalLayer = nullable *void; +export type GgpFrameToken = u32; +export type GgpStreamDescriptor = u32; + +// DirectFB +export type IDirectFB = nullable *void; +export type IDirectFBSurface = nullable *void; + +// xlib (_xrandr) +export type Display = nullable *void; +export type RROutput = u32; +export type Window = u32; +export type VisualID = u32; + +// Win32 +export type BOOL = i32; +export type DWORD = u32; +export type LPVOID = nullable *void; +export type HANDLE = nullable *void; +export type HMONITOR = nullable *void; +export type WCHAR = u16; +export type LPCWSTR = *const void; // hare doesn't have wide chars +export type HINSTANCE = nullable *void; +export type HWND = nullable *void; +export type SECURITY_ATTRIBUTES = struct { + nLength: DWORD, + lpSecurityDescriptor: LPVOID, + bInheritHandle: BOOL, +}; + +// Wayland +export type wl_display = nullable *void; +export type wl_surface = nullable *void; + +// Mir +export type MirConnection = nullable *void; +export type MirSurface = nullable *void; + +export fn VK_MAKE_VERSION(major: uint, minor: uint, patch: uint) uint = { + return (major << 22) | (minor << 12) | patch; +}; +export fn VK_MAKE_API_VERSION(variant: uint, major: uint, minor: uint, patch: uint) uint = { + return (variant << 29) | (major << 22) | (minor << 12) | patch; +}; + +export const VK_API_VERSION_1_0: uint = (0 << 29) | (1 << 22) | (0 << 12) | 0; +export const VK_API_VERSION_1_1: uint = (0 << 29) | (1 << 22) | (1 << 12) | 0; +export const VK_API_VERSION_1_2: uint = (0 << 29) | (1 << 22) | (2 << 12) | 0; +export const VK_API_VERSION_1_3: uint = (0 << 29) | (1 << 22) | (3 << 12) | 0; + +export fn VK_VERSION_MAJOR(version: uint) uint = { + return version >> 22; +}; +export fn VK_VERSION_MINOR(version: uint) uint = { + return (version >> 12) & 0x3ff; +}; +export fn VK_VERSION_PATCH(version: uint) uint = { + return version & 0xfff; +}; + +export type VkInstance = nullable *void; +export type VkPhysicalDevice = nullable *void; +export type VkDevice = nullable *void; +export type VkQueue = nullable *void; +export type VkCommandBuffer = nullable *void; +export type VkDeviceMemory = nullable *void; +export type VkCommandPool = nullable *void; +export type VkBuffer = nullable *void; +export type VkBufferView = nullable *void; +export type VkImage = nullable *void; +export type VkImageView = nullable *void; +export type VkShaderModule = nullable *void; +export type VkPipeline = nullable *void; +export type VkPipelineLayout = nullable *void; +export type VkSampler = nullable *void; +export type VkDescriptorSet = nullable *void; +export type VkDescriptorSetLayout = nullable *void; +export type VkDescriptorPool = nullable *void; +export type VkFence = nullable *void; +export type VkSemaphore = nullable *void; +export type VkEvent = nullable *void; +export type VkQueryPool = nullable *void; +export type VkFramebuffer = nullable *void; +export type VkRenderPass = nullable *void; +export type VkPipelineCache = nullable *void; +export type VkDescriptorUpdateTemplate = nullable *void; +export type VkSamplerYcbcrConversion = nullable *void; +export type VkPrivateDataSlot = nullable *void; +export type VkAttachmentLoadOp = enum u32 { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, +}; + +export fn StrVkAttachmentLoadOp(value: VkAttachmentLoadOp) str = { + switch (value) { + case VkAttachmentLoadOp::VK_ATTACHMENT_LOAD_OP_LOAD => + return "VK_ATTACHMENT_LOAD_OP_LOAD"; + case VkAttachmentLoadOp::VK_ATTACHMENT_LOAD_OP_CLEAR => + return "VK_ATTACHMENT_LOAD_OP_CLEAR"; + case VkAttachmentLoadOp::VK_ATTACHMENT_LOAD_OP_DONT_CARE => + return "VK_ATTACHMENT_LOAD_OP_DONT_CARE"; + }; +}; +export type VkAttachmentStoreOp = enum u32 { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_NONE = 1000301000, +}; + +export fn StrVkAttachmentStoreOp(value: VkAttachmentStoreOp) str = { + switch (value) { + case VkAttachmentStoreOp::VK_ATTACHMENT_STORE_OP_STORE => + return "VK_ATTACHMENT_STORE_OP_STORE"; + case VkAttachmentStoreOp::VK_ATTACHMENT_STORE_OP_DONT_CARE => + return "VK_ATTACHMENT_STORE_OP_DONT_CARE"; + case VkAttachmentStoreOp::VK_ATTACHMENT_STORE_OP_NONE => + return "VK_ATTACHMENT_STORE_OP_NONE"; + }; +}; +export type VkBlendFactor = enum u32 { + 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, +}; + +export fn StrVkBlendFactor(value: VkBlendFactor) str = { + switch (value) { + case VkBlendFactor::VK_BLEND_FACTOR_ZERO => + return "VK_BLEND_FACTOR_ZERO"; + case VkBlendFactor::VK_BLEND_FACTOR_ONE => + return "VK_BLEND_FACTOR_ONE"; + case VkBlendFactor::VK_BLEND_FACTOR_SRC_COLOR => + return "VK_BLEND_FACTOR_SRC_COLOR"; + case VkBlendFactor::VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR => + return "VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR"; + case VkBlendFactor::VK_BLEND_FACTOR_DST_COLOR => + return "VK_BLEND_FACTOR_DST_COLOR"; + case VkBlendFactor::VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR => + return "VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR"; + case VkBlendFactor::VK_BLEND_FACTOR_SRC_ALPHA => + return "VK_BLEND_FACTOR_SRC_ALPHA"; + case VkBlendFactor::VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA => + return "VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA"; + case VkBlendFactor::VK_BLEND_FACTOR_DST_ALPHA => + return "VK_BLEND_FACTOR_DST_ALPHA"; + case VkBlendFactor::VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA => + return "VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA"; + case VkBlendFactor::VK_BLEND_FACTOR_CONSTANT_COLOR => + return "VK_BLEND_FACTOR_CONSTANT_COLOR"; + case VkBlendFactor::VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR => + return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR"; + case VkBlendFactor::VK_BLEND_FACTOR_CONSTANT_ALPHA => + return "VK_BLEND_FACTOR_CONSTANT_ALPHA"; + case VkBlendFactor::VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA => + return "VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA"; + case VkBlendFactor::VK_BLEND_FACTOR_SRC_ALPHA_SATURATE => + return "VK_BLEND_FACTOR_SRC_ALPHA_SATURATE"; + case VkBlendFactor::VK_BLEND_FACTOR_SRC1_COLOR => + return "VK_BLEND_FACTOR_SRC1_COLOR"; + case VkBlendFactor::VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR => + return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR"; + case VkBlendFactor::VK_BLEND_FACTOR_SRC1_ALPHA => + return "VK_BLEND_FACTOR_SRC1_ALPHA"; + case VkBlendFactor::VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA => + return "VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA"; + }; +}; +export type VkBlendOp = enum u32 { + 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, +}; + +export fn StrVkBlendOp(value: VkBlendOp) str = { + switch (value) { + case VkBlendOp::VK_BLEND_OP_ADD => + return "VK_BLEND_OP_ADD"; + case VkBlendOp::VK_BLEND_OP_SUBTRACT => + return "VK_BLEND_OP_SUBTRACT"; + case VkBlendOp::VK_BLEND_OP_REVERSE_SUBTRACT => + return "VK_BLEND_OP_REVERSE_SUBTRACT"; + case VkBlendOp::VK_BLEND_OP_MIN => + return "VK_BLEND_OP_MIN"; + case VkBlendOp::VK_BLEND_OP_MAX => + return "VK_BLEND_OP_MAX"; + }; +}; +export type VkBorderColor = enum u32 { + 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, +}; + +export fn StrVkBorderColor(value: VkBorderColor) str = { + switch (value) { + case VkBorderColor::VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK => + return "VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK"; + case VkBorderColor::VK_BORDER_COLOR_INT_TRANSPARENT_BLACK => + return "VK_BORDER_COLOR_INT_TRANSPARENT_BLACK"; + case VkBorderColor::VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK => + return "VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK"; + case VkBorderColor::VK_BORDER_COLOR_INT_OPAQUE_BLACK => + return "VK_BORDER_COLOR_INT_OPAQUE_BLACK"; + case VkBorderColor::VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE => + return "VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE"; + case VkBorderColor::VK_BORDER_COLOR_INT_OPAQUE_WHITE => + return "VK_BORDER_COLOR_INT_OPAQUE_WHITE"; + }; +}; +export type VkFramebufferCreateFlagBits = enum u32 { + VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 1, +}; + +export fn StrVkFramebufferCreateFlagBits(value: VkFramebufferCreateFlagBits) str = { + switch (value) { + case VkFramebufferCreateFlagBits::VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT => + return "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT"; + }; +}; +export type VkPipelineCacheHeaderVersion = enum u32 { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, +}; + +export fn StrVkPipelineCacheHeaderVersion(value: VkPipelineCacheHeaderVersion) str = { + switch (value) { + case VkPipelineCacheHeaderVersion::VK_PIPELINE_CACHE_HEADER_VERSION_ONE => + return "VK_PIPELINE_CACHE_HEADER_VERSION_ONE"; + }; +}; +export type VkPipelineCacheCreateFlagBits = enum u32 { + VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 1, +}; + +export fn StrVkPipelineCacheCreateFlagBits(value: VkPipelineCacheCreateFlagBits) str = { + switch (value) { + case VkPipelineCacheCreateFlagBits::VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT => + return "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT"; + }; +}; +export type VkPipelineShaderStageCreateFlagBits = enum u32 { + VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 1, + VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 2, +}; + +export fn StrVkPipelineShaderStageCreateFlagBits(value: VkPipelineShaderStageCreateFlagBits) str = { + switch (value) { + case VkPipelineShaderStageCreateFlagBits::VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT => + return "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT"; + case VkPipelineShaderStageCreateFlagBits::VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT => + return "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT"; + }; +}; +export type VkDescriptorSetLayoutCreateFlagBits = enum u32 { + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 2, +}; + +export fn StrVkDescriptorSetLayoutCreateFlagBits(value: VkDescriptorSetLayoutCreateFlagBits) str = { + switch (value) { + case VkDescriptorSetLayoutCreateFlagBits::VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT => + return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT"; + }; +}; +export type VkDeviceQueueCreateFlagBits = enum u32 { + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 1, +}; + +export fn StrVkDeviceQueueCreateFlagBits(value: VkDeviceQueueCreateFlagBits) str = { + switch (value) { + case VkDeviceQueueCreateFlagBits::VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT => + return "VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT"; + }; +}; +export type VkBufferCreateFlagBits = enum u32 { + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 4, + VK_BUFFER_CREATE_PROTECTED_BIT = 8, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 16, +}; + +export fn StrVkBufferCreateFlagBits(value: VkBufferCreateFlagBits) str = { + switch (value) { + case VkBufferCreateFlagBits::VK_BUFFER_CREATE_SPARSE_BINDING_BIT => + return "VK_BUFFER_CREATE_SPARSE_BINDING_BIT"; + case VkBufferCreateFlagBits::VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT => + return "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"; + case VkBufferCreateFlagBits::VK_BUFFER_CREATE_SPARSE_ALIASED_BIT => + return "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"; + case VkBufferCreateFlagBits::VK_BUFFER_CREATE_PROTECTED_BIT => + return "VK_BUFFER_CREATE_PROTECTED_BIT"; + case VkBufferCreateFlagBits::VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT => + return "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"; + }; +}; +export type VkBufferUsageFlagBits = enum u32 { + 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, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 131072, +}; + +export fn StrVkBufferUsageFlagBits(value: VkBufferUsageFlagBits) str = { + switch (value) { + case VkBufferUsageFlagBits::VK_BUFFER_USAGE_TRANSFER_SRC_BIT => + return "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"; + case VkBufferUsageFlagBits::VK_BUFFER_USAGE_TRANSFER_DST_BIT => + return "VK_BUFFER_USAGE_TRANSFER_DST_BIT"; + case VkBufferUsageFlagBits::VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT => + return "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"; + case VkBufferUsageFlagBits::VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT => + return "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"; + case VkBufferUsageFlagBits::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT => + return "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"; + case VkBufferUsageFlagBits::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT => + return "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"; + case VkBufferUsageFlagBits::VK_BUFFER_USAGE_INDEX_BUFFER_BIT => + return "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"; + case VkBufferUsageFlagBits::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT => + return "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"; + case VkBufferUsageFlagBits::VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT => + return "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"; + case VkBufferUsageFlagBits::VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT => + return "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"; + }; +}; +export type VkColorComponentFlagBits = enum u32 { + VK_COLOR_COMPONENT_R_BIT = 1, + VK_COLOR_COMPONENT_G_BIT = 2, + VK_COLOR_COMPONENT_B_BIT = 4, + VK_COLOR_COMPONENT_A_BIT = 8, +}; + +export fn StrVkColorComponentFlagBits(value: VkColorComponentFlagBits) str = { + switch (value) { + case VkColorComponentFlagBits::VK_COLOR_COMPONENT_R_BIT => + return "VK_COLOR_COMPONENT_R_BIT"; + case VkColorComponentFlagBits::VK_COLOR_COMPONENT_G_BIT => + return "VK_COLOR_COMPONENT_G_BIT"; + case VkColorComponentFlagBits::VK_COLOR_COMPONENT_B_BIT => + return "VK_COLOR_COMPONENT_B_BIT"; + case VkColorComponentFlagBits::VK_COLOR_COMPONENT_A_BIT => + return "VK_COLOR_COMPONENT_A_BIT"; + }; +}; +export type VkComponentSwizzle = enum u32 { + 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, +}; + +export fn StrVkComponentSwizzle(value: VkComponentSwizzle) str = { + switch (value) { + case VkComponentSwizzle::VK_COMPONENT_SWIZZLE_IDENTITY => + return "VK_COMPONENT_SWIZZLE_IDENTITY"; + case VkComponentSwizzle::VK_COMPONENT_SWIZZLE_ZERO => + return "VK_COMPONENT_SWIZZLE_ZERO"; + case VkComponentSwizzle::VK_COMPONENT_SWIZZLE_ONE => + return "VK_COMPONENT_SWIZZLE_ONE"; + case VkComponentSwizzle::VK_COMPONENT_SWIZZLE_R => + return "VK_COMPONENT_SWIZZLE_R"; + case VkComponentSwizzle::VK_COMPONENT_SWIZZLE_G => + return "VK_COMPONENT_SWIZZLE_G"; + case VkComponentSwizzle::VK_COMPONENT_SWIZZLE_B => + return "VK_COMPONENT_SWIZZLE_B"; + case VkComponentSwizzle::VK_COMPONENT_SWIZZLE_A => + return "VK_COMPONENT_SWIZZLE_A"; + }; +}; +export type VkCommandPoolCreateFlagBits = enum u32 { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 4, +}; + +export fn StrVkCommandPoolCreateFlagBits(value: VkCommandPoolCreateFlagBits) str = { + switch (value) { + case VkCommandPoolCreateFlagBits::VK_COMMAND_POOL_CREATE_TRANSIENT_BIT => + return "VK_COMMAND_POOL_CREATE_TRANSIENT_BIT"; + case VkCommandPoolCreateFlagBits::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT => + return "VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"; + case VkCommandPoolCreateFlagBits::VK_COMMAND_POOL_CREATE_PROTECTED_BIT => + return "VK_COMMAND_POOL_CREATE_PROTECTED_BIT"; + }; +}; +export type VkCommandPoolResetFlagBits = enum u32 { + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1, +}; + +export fn StrVkCommandPoolResetFlagBits(value: VkCommandPoolResetFlagBits) str = { + switch (value) { + case VkCommandPoolResetFlagBits::VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT => + return "VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT"; + }; +}; +export type VkCommandBufferResetFlagBits = enum u32 { + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1, +}; + +export fn StrVkCommandBufferResetFlagBits(value: VkCommandBufferResetFlagBits) str = { + switch (value) { + case VkCommandBufferResetFlagBits::VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT => + return "VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT"; + }; +}; +export type VkCommandBufferLevel = enum u32 { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, +}; + +export fn StrVkCommandBufferLevel(value: VkCommandBufferLevel) str = { + switch (value) { + case VkCommandBufferLevel::VK_COMMAND_BUFFER_LEVEL_PRIMARY => + return "VK_COMMAND_BUFFER_LEVEL_PRIMARY"; + case VkCommandBufferLevel::VK_COMMAND_BUFFER_LEVEL_SECONDARY => + return "VK_COMMAND_BUFFER_LEVEL_SECONDARY"; + }; +}; +export type VkCommandBufferUsageFlagBits = enum u32 { + 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, +}; + +export fn StrVkCommandBufferUsageFlagBits(value: VkCommandBufferUsageFlagBits) str = { + switch (value) { + case VkCommandBufferUsageFlagBits::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT => + return "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"; + case VkCommandBufferUsageFlagBits::VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT => + return "VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"; + case VkCommandBufferUsageFlagBits::VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT => + return "VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT"; + }; +}; +export type VkCompareOp = enum u32 { + 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, +}; + +export fn StrVkCompareOp(value: VkCompareOp) str = { + switch (value) { + case VkCompareOp::VK_COMPARE_OP_NEVER => + return "VK_COMPARE_OP_NEVER"; + case VkCompareOp::VK_COMPARE_OP_LESS => + return "VK_COMPARE_OP_LESS"; + case VkCompareOp::VK_COMPARE_OP_EQUAL => + return "VK_COMPARE_OP_EQUAL"; + case VkCompareOp::VK_COMPARE_OP_LESS_OR_EQUAL => + return "VK_COMPARE_OP_LESS_OR_EQUAL"; + case VkCompareOp::VK_COMPARE_OP_GREATER => + return "VK_COMPARE_OP_GREATER"; + case VkCompareOp::VK_COMPARE_OP_NOT_EQUAL => + return "VK_COMPARE_OP_NOT_EQUAL"; + case VkCompareOp::VK_COMPARE_OP_GREATER_OR_EQUAL => + return "VK_COMPARE_OP_GREATER_OR_EQUAL"; + case VkCompareOp::VK_COMPARE_OP_ALWAYS => + return "VK_COMPARE_OP_ALWAYS"; + }; +}; +export type VkCullModeFlagBits = enum u32 { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 1, + VK_CULL_MODE_BACK_BIT = 2, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, +}; + +export fn StrVkCullModeFlagBits(value: VkCullModeFlagBits) str = { + switch (value) { + case VkCullModeFlagBits::VK_CULL_MODE_NONE => + return "VK_CULL_MODE_NONE"; + case VkCullModeFlagBits::VK_CULL_MODE_FRONT_BIT => + return "VK_CULL_MODE_FRONT_BIT"; + case VkCullModeFlagBits::VK_CULL_MODE_BACK_BIT => + return "VK_CULL_MODE_BACK_BIT"; + case VkCullModeFlagBits::VK_CULL_MODE_FRONT_AND_BACK => + return "VK_CULL_MODE_FRONT_AND_BACK"; + }; +}; +export type VkDescriptorType = enum u32 { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000, +}; + +export fn StrVkDescriptorType(value: VkDescriptorType) str = { + switch (value) { + case VkDescriptorType::VK_DESCRIPTOR_TYPE_SAMPLER => + return "VK_DESCRIPTOR_TYPE_SAMPLER"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER => + return "VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE => + return "VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE => + return "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER => + return "VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER => + return "VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER => + return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER => + return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC => + return "VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC => + return "VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT => + return "VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT"; + case VkDescriptorType::VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK => + return "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK"; + }; +}; +export type VkDynamicState = enum u32 { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_CULL_MODE = 1000267000, + VK_DYNAMIC_STATE_FRONT_FACE = 1000267001, + VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002, + VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003, + VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004, + VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005, + VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006, + VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007, + VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008, + VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009, + VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010, + VK_DYNAMIC_STATE_STENCIL_OP = 1000267011, + VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001, + VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002, + VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004, +}; + +export fn StrVkDynamicState(value: VkDynamicState) str = { + switch (value) { + case VkDynamicState::VK_DYNAMIC_STATE_VIEWPORT => + return "VK_DYNAMIC_STATE_VIEWPORT"; + case VkDynamicState::VK_DYNAMIC_STATE_SCISSOR => + return "VK_DYNAMIC_STATE_SCISSOR"; + case VkDynamicState::VK_DYNAMIC_STATE_LINE_WIDTH => + return "VK_DYNAMIC_STATE_LINE_WIDTH"; + case VkDynamicState::VK_DYNAMIC_STATE_DEPTH_BIAS => + return "VK_DYNAMIC_STATE_DEPTH_BIAS"; + case VkDynamicState::VK_DYNAMIC_STATE_BLEND_CONSTANTS => + return "VK_DYNAMIC_STATE_BLEND_CONSTANTS"; + case VkDynamicState::VK_DYNAMIC_STATE_DEPTH_BOUNDS => + return "VK_DYNAMIC_STATE_DEPTH_BOUNDS"; + case VkDynamicState::VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK => + return "VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK"; + case VkDynamicState::VK_DYNAMIC_STATE_STENCIL_WRITE_MASK => + return "VK_DYNAMIC_STATE_STENCIL_WRITE_MASK"; + case VkDynamicState::VK_DYNAMIC_STATE_STENCIL_REFERENCE => + return "VK_DYNAMIC_STATE_STENCIL_REFERENCE"; + case VkDynamicState::VK_DYNAMIC_STATE_CULL_MODE => + return "VK_DYNAMIC_STATE_CULL_MODE"; + case VkDynamicState::VK_DYNAMIC_STATE_FRONT_FACE => + return "VK_DYNAMIC_STATE_FRONT_FACE"; + case VkDynamicState::VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY => + return "VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY"; + case VkDynamicState::VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT => + return "VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT"; + case VkDynamicState::VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT => + return "VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT"; + case VkDynamicState::VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE => + return "VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE"; + case VkDynamicState::VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE => + return "VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE"; + case VkDynamicState::VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE => + return "VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE"; + case VkDynamicState::VK_DYNAMIC_STATE_DEPTH_COMPARE_OP => + return "VK_DYNAMIC_STATE_DEPTH_COMPARE_OP"; + case VkDynamicState::VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE => + return "VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE"; + case VkDynamicState::VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE => + return "VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE"; + case VkDynamicState::VK_DYNAMIC_STATE_STENCIL_OP => + return "VK_DYNAMIC_STATE_STENCIL_OP"; + case VkDynamicState::VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE => + return "VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE"; + case VkDynamicState::VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE => + return "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE"; + case VkDynamicState::VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE => + return "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE"; + }; +}; +export type VkFenceCreateFlagBits = enum u32 { + VK_FENCE_CREATE_SIGNALED_BIT = 1, +}; + +export fn StrVkFenceCreateFlagBits(value: VkFenceCreateFlagBits) str = { + switch (value) { + case VkFenceCreateFlagBits::VK_FENCE_CREATE_SIGNALED_BIT => + return "VK_FENCE_CREATE_SIGNALED_BIT"; + }; +}; +export type VkPolygonMode = enum u32 { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, +}; + +export fn StrVkPolygonMode(value: VkPolygonMode) str = { + switch (value) { + case VkPolygonMode::VK_POLYGON_MODE_FILL => + return "VK_POLYGON_MODE_FILL"; + case VkPolygonMode::VK_POLYGON_MODE_LINE => + return "VK_POLYGON_MODE_LINE"; + case VkPolygonMode::VK_POLYGON_MODE_POINT => + return "VK_POLYGON_MODE_POINT"; + }; +}; +export type VkFormat = enum u32 { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002, + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003, + VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000, + VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001, + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000, + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001, + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002, + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003, + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004, + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005, + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006, + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007, + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008, + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009, + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010, + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011, + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012, + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013, +}; + +export fn StrVkFormat(value: VkFormat) str = { + switch (value) { + case VkFormat::VK_FORMAT_UNDEFINED => + return "VK_FORMAT_UNDEFINED"; + case VkFormat::VK_FORMAT_R4G4_UNORM_PACK8 => + return "VK_FORMAT_R4G4_UNORM_PACK8"; + case VkFormat::VK_FORMAT_R4G4B4A4_UNORM_PACK16 => + return "VK_FORMAT_R4G4B4A4_UNORM_PACK16"; + case VkFormat::VK_FORMAT_B4G4R4A4_UNORM_PACK16 => + return "VK_FORMAT_B4G4R4A4_UNORM_PACK16"; + case VkFormat::VK_FORMAT_R5G6B5_UNORM_PACK16 => + return "VK_FORMAT_R5G6B5_UNORM_PACK16"; + case VkFormat::VK_FORMAT_B5G6R5_UNORM_PACK16 => + return "VK_FORMAT_B5G6R5_UNORM_PACK16"; + case VkFormat::VK_FORMAT_R5G5B5A1_UNORM_PACK16 => + return "VK_FORMAT_R5G5B5A1_UNORM_PACK16"; + case VkFormat::VK_FORMAT_B5G5R5A1_UNORM_PACK16 => + return "VK_FORMAT_B5G5R5A1_UNORM_PACK16"; + case VkFormat::VK_FORMAT_A1R5G5B5_UNORM_PACK16 => + return "VK_FORMAT_A1R5G5B5_UNORM_PACK16"; + case VkFormat::VK_FORMAT_R8_UNORM => + return "VK_FORMAT_R8_UNORM"; + case VkFormat::VK_FORMAT_R8_SNORM => + return "VK_FORMAT_R8_SNORM"; + case VkFormat::VK_FORMAT_R8_USCALED => + return "VK_FORMAT_R8_USCALED"; + case VkFormat::VK_FORMAT_R8_SSCALED => + return "VK_FORMAT_R8_SSCALED"; + case VkFormat::VK_FORMAT_R8_UINT => + return "VK_FORMAT_R8_UINT"; + case VkFormat::VK_FORMAT_R8_SINT => + return "VK_FORMAT_R8_SINT"; + case VkFormat::VK_FORMAT_R8_SRGB => + return "VK_FORMAT_R8_SRGB"; + case VkFormat::VK_FORMAT_R8G8_UNORM => + return "VK_FORMAT_R8G8_UNORM"; + case VkFormat::VK_FORMAT_R8G8_SNORM => + return "VK_FORMAT_R8G8_SNORM"; + case VkFormat::VK_FORMAT_R8G8_USCALED => + return "VK_FORMAT_R8G8_USCALED"; + case VkFormat::VK_FORMAT_R8G8_SSCALED => + return "VK_FORMAT_R8G8_SSCALED"; + case VkFormat::VK_FORMAT_R8G8_UINT => + return "VK_FORMAT_R8G8_UINT"; + case VkFormat::VK_FORMAT_R8G8_SINT => + return "VK_FORMAT_R8G8_SINT"; + case VkFormat::VK_FORMAT_R8G8_SRGB => + return "VK_FORMAT_R8G8_SRGB"; + case VkFormat::VK_FORMAT_R8G8B8_UNORM => + return "VK_FORMAT_R8G8B8_UNORM"; + case VkFormat::VK_FORMAT_R8G8B8_SNORM => + return "VK_FORMAT_R8G8B8_SNORM"; + case VkFormat::VK_FORMAT_R8G8B8_USCALED => + return "VK_FORMAT_R8G8B8_USCALED"; + case VkFormat::VK_FORMAT_R8G8B8_SSCALED => + return "VK_FORMAT_R8G8B8_SSCALED"; + case VkFormat::VK_FORMAT_R8G8B8_UINT => + return "VK_FORMAT_R8G8B8_UINT"; + case VkFormat::VK_FORMAT_R8G8B8_SINT => + return "VK_FORMAT_R8G8B8_SINT"; + case VkFormat::VK_FORMAT_R8G8B8_SRGB => + return "VK_FORMAT_R8G8B8_SRGB"; + case VkFormat::VK_FORMAT_B8G8R8_UNORM => + return "VK_FORMAT_B8G8R8_UNORM"; + case VkFormat::VK_FORMAT_B8G8R8_SNORM => + return "VK_FORMAT_B8G8R8_SNORM"; + case VkFormat::VK_FORMAT_B8G8R8_USCALED => + return "VK_FORMAT_B8G8R8_USCALED"; + case VkFormat::VK_FORMAT_B8G8R8_SSCALED => + return "VK_FORMAT_B8G8R8_SSCALED"; + case VkFormat::VK_FORMAT_B8G8R8_UINT => + return "VK_FORMAT_B8G8R8_UINT"; + case VkFormat::VK_FORMAT_B8G8R8_SINT => + return "VK_FORMAT_B8G8R8_SINT"; + case VkFormat::VK_FORMAT_B8G8R8_SRGB => + return "VK_FORMAT_B8G8R8_SRGB"; + case VkFormat::VK_FORMAT_R8G8B8A8_UNORM => + return "VK_FORMAT_R8G8B8A8_UNORM"; + case VkFormat::VK_FORMAT_R8G8B8A8_SNORM => + return "VK_FORMAT_R8G8B8A8_SNORM"; + case VkFormat::VK_FORMAT_R8G8B8A8_USCALED => + return "VK_FORMAT_R8G8B8A8_USCALED"; + case VkFormat::VK_FORMAT_R8G8B8A8_SSCALED => + return "VK_FORMAT_R8G8B8A8_SSCALED"; + case VkFormat::VK_FORMAT_R8G8B8A8_UINT => + return "VK_FORMAT_R8G8B8A8_UINT"; + case VkFormat::VK_FORMAT_R8G8B8A8_SINT => + return "VK_FORMAT_R8G8B8A8_SINT"; + case VkFormat::VK_FORMAT_R8G8B8A8_SRGB => + return "VK_FORMAT_R8G8B8A8_SRGB"; + case VkFormat::VK_FORMAT_B8G8R8A8_UNORM => + return "VK_FORMAT_B8G8R8A8_UNORM"; + case VkFormat::VK_FORMAT_B8G8R8A8_SNORM => + return "VK_FORMAT_B8G8R8A8_SNORM"; + case VkFormat::VK_FORMAT_B8G8R8A8_USCALED => + return "VK_FORMAT_B8G8R8A8_USCALED"; + case VkFormat::VK_FORMAT_B8G8R8A8_SSCALED => + return "VK_FORMAT_B8G8R8A8_SSCALED"; + case VkFormat::VK_FORMAT_B8G8R8A8_UINT => + return "VK_FORMAT_B8G8R8A8_UINT"; + case VkFormat::VK_FORMAT_B8G8R8A8_SINT => + return "VK_FORMAT_B8G8R8A8_SINT"; + case VkFormat::VK_FORMAT_B8G8R8A8_SRGB => + return "VK_FORMAT_B8G8R8A8_SRGB"; + case VkFormat::VK_FORMAT_A8B8G8R8_UNORM_PACK32 => + return "VK_FORMAT_A8B8G8R8_UNORM_PACK32"; + case VkFormat::VK_FORMAT_A8B8G8R8_SNORM_PACK32 => + return "VK_FORMAT_A8B8G8R8_SNORM_PACK32"; + case VkFormat::VK_FORMAT_A8B8G8R8_USCALED_PACK32 => + return "VK_FORMAT_A8B8G8R8_USCALED_PACK32"; + case VkFormat::VK_FORMAT_A8B8G8R8_SSCALED_PACK32 => + return "VK_FORMAT_A8B8G8R8_SSCALED_PACK32"; + case VkFormat::VK_FORMAT_A8B8G8R8_UINT_PACK32 => + return "VK_FORMAT_A8B8G8R8_UINT_PACK32"; + case VkFormat::VK_FORMAT_A8B8G8R8_SINT_PACK32 => + return "VK_FORMAT_A8B8G8R8_SINT_PACK32"; + case VkFormat::VK_FORMAT_A8B8G8R8_SRGB_PACK32 => + return "VK_FORMAT_A8B8G8R8_SRGB_PACK32"; + case VkFormat::VK_FORMAT_A2R10G10B10_UNORM_PACK32 => + return "VK_FORMAT_A2R10G10B10_UNORM_PACK32"; + case VkFormat::VK_FORMAT_A2R10G10B10_SNORM_PACK32 => + return "VK_FORMAT_A2R10G10B10_SNORM_PACK32"; + case VkFormat::VK_FORMAT_A2R10G10B10_USCALED_PACK32 => + return "VK_FORMAT_A2R10G10B10_USCALED_PACK32"; + case VkFormat::VK_FORMAT_A2R10G10B10_SSCALED_PACK32 => + return "VK_FORMAT_A2R10G10B10_SSCALED_PACK32"; + case VkFormat::VK_FORMAT_A2R10G10B10_UINT_PACK32 => + return "VK_FORMAT_A2R10G10B10_UINT_PACK32"; + case VkFormat::VK_FORMAT_A2R10G10B10_SINT_PACK32 => + return "VK_FORMAT_A2R10G10B10_SINT_PACK32"; + case VkFormat::VK_FORMAT_A2B10G10R10_UNORM_PACK32 => + return "VK_FORMAT_A2B10G10R10_UNORM_PACK32"; + case VkFormat::VK_FORMAT_A2B10G10R10_SNORM_PACK32 => + return "VK_FORMAT_A2B10G10R10_SNORM_PACK32"; + case VkFormat::VK_FORMAT_A2B10G10R10_USCALED_PACK32 => + return "VK_FORMAT_A2B10G10R10_USCALED_PACK32"; + case VkFormat::VK_FORMAT_A2B10G10R10_SSCALED_PACK32 => + return "VK_FORMAT_A2B10G10R10_SSCALED_PACK32"; + case VkFormat::VK_FORMAT_A2B10G10R10_UINT_PACK32 => + return "VK_FORMAT_A2B10G10R10_UINT_PACK32"; + case VkFormat::VK_FORMAT_A2B10G10R10_SINT_PACK32 => + return "VK_FORMAT_A2B10G10R10_SINT_PACK32"; + case VkFormat::VK_FORMAT_R16_UNORM => + return "VK_FORMAT_R16_UNORM"; + case VkFormat::VK_FORMAT_R16_SNORM => + return "VK_FORMAT_R16_SNORM"; + case VkFormat::VK_FORMAT_R16_USCALED => + return "VK_FORMAT_R16_USCALED"; + case VkFormat::VK_FORMAT_R16_SSCALED => + return "VK_FORMAT_R16_SSCALED"; + case VkFormat::VK_FORMAT_R16_UINT => + return "VK_FORMAT_R16_UINT"; + case VkFormat::VK_FORMAT_R16_SINT => + return "VK_FORMAT_R16_SINT"; + case VkFormat::VK_FORMAT_R16_SFLOAT => + return "VK_FORMAT_R16_SFLOAT"; + case VkFormat::VK_FORMAT_R16G16_UNORM => + return "VK_FORMAT_R16G16_UNORM"; + case VkFormat::VK_FORMAT_R16G16_SNORM => + return "VK_FORMAT_R16G16_SNORM"; + case VkFormat::VK_FORMAT_R16G16_USCALED => + return "VK_FORMAT_R16G16_USCALED"; + case VkFormat::VK_FORMAT_R16G16_SSCALED => + return "VK_FORMAT_R16G16_SSCALED"; + case VkFormat::VK_FORMAT_R16G16_UINT => + return "VK_FORMAT_R16G16_UINT"; + case VkFormat::VK_FORMAT_R16G16_SINT => + return "VK_FORMAT_R16G16_SINT"; + case VkFormat::VK_FORMAT_R16G16_SFLOAT => + return "VK_FORMAT_R16G16_SFLOAT"; + case VkFormat::VK_FORMAT_R16G16B16_UNORM => + return "VK_FORMAT_R16G16B16_UNORM"; + case VkFormat::VK_FORMAT_R16G16B16_SNORM => + return "VK_FORMAT_R16G16B16_SNORM"; + case VkFormat::VK_FORMAT_R16G16B16_USCALED => + return "VK_FORMAT_R16G16B16_USCALED"; + case VkFormat::VK_FORMAT_R16G16B16_SSCALED => + return "VK_FORMAT_R16G16B16_SSCALED"; + case VkFormat::VK_FORMAT_R16G16B16_UINT => + return "VK_FORMAT_R16G16B16_UINT"; + case VkFormat::VK_FORMAT_R16G16B16_SINT => + return "VK_FORMAT_R16G16B16_SINT"; + case VkFormat::VK_FORMAT_R16G16B16_SFLOAT => + return "VK_FORMAT_R16G16B16_SFLOAT"; + case VkFormat::VK_FORMAT_R16G16B16A16_UNORM => + return "VK_FORMAT_R16G16B16A16_UNORM"; + case VkFormat::VK_FORMAT_R16G16B16A16_SNORM => + return "VK_FORMAT_R16G16B16A16_SNORM"; + case VkFormat::VK_FORMAT_R16G16B16A16_USCALED => + return "VK_FORMAT_R16G16B16A16_USCALED"; + case VkFormat::VK_FORMAT_R16G16B16A16_SSCALED => + return "VK_FORMAT_R16G16B16A16_SSCALED"; + case VkFormat::VK_FORMAT_R16G16B16A16_UINT => + return "VK_FORMAT_R16G16B16A16_UINT"; + case VkFormat::VK_FORMAT_R16G16B16A16_SINT => + return "VK_FORMAT_R16G16B16A16_SINT"; + case VkFormat::VK_FORMAT_R16G16B16A16_SFLOAT => + return "VK_FORMAT_R16G16B16A16_SFLOAT"; + case VkFormat::VK_FORMAT_R32_UINT => + return "VK_FORMAT_R32_UINT"; + case VkFormat::VK_FORMAT_R32_SINT => + return "VK_FORMAT_R32_SINT"; + case VkFormat::VK_FORMAT_R32_SFLOAT => + return "VK_FORMAT_R32_SFLOAT"; + case VkFormat::VK_FORMAT_R32G32_UINT => + return "VK_FORMAT_R32G32_UINT"; + case VkFormat::VK_FORMAT_R32G32_SINT => + return "VK_FORMAT_R32G32_SINT"; + case VkFormat::VK_FORMAT_R32G32_SFLOAT => + return "VK_FORMAT_R32G32_SFLOAT"; + case VkFormat::VK_FORMAT_R32G32B32_UINT => + return "VK_FORMAT_R32G32B32_UINT"; + case VkFormat::VK_FORMAT_R32G32B32_SINT => + return "VK_FORMAT_R32G32B32_SINT"; + case VkFormat::VK_FORMAT_R32G32B32_SFLOAT => + return "VK_FORMAT_R32G32B32_SFLOAT"; + case VkFormat::VK_FORMAT_R32G32B32A32_UINT => + return "VK_FORMAT_R32G32B32A32_UINT"; + case VkFormat::VK_FORMAT_R32G32B32A32_SINT => + return "VK_FORMAT_R32G32B32A32_SINT"; + case VkFormat::VK_FORMAT_R32G32B32A32_SFLOAT => + return "VK_FORMAT_R32G32B32A32_SFLOAT"; + case VkFormat::VK_FORMAT_R64_UINT => + return "VK_FORMAT_R64_UINT"; + case VkFormat::VK_FORMAT_R64_SINT => + return "VK_FORMAT_R64_SINT"; + case VkFormat::VK_FORMAT_R64_SFLOAT => + return "VK_FORMAT_R64_SFLOAT"; + case VkFormat::VK_FORMAT_R64G64_UINT => + return "VK_FORMAT_R64G64_UINT"; + case VkFormat::VK_FORMAT_R64G64_SINT => + return "VK_FORMAT_R64G64_SINT"; + case VkFormat::VK_FORMAT_R64G64_SFLOAT => + return "VK_FORMAT_R64G64_SFLOAT"; + case VkFormat::VK_FORMAT_R64G64B64_UINT => + return "VK_FORMAT_R64G64B64_UINT"; + case VkFormat::VK_FORMAT_R64G64B64_SINT => + return "VK_FORMAT_R64G64B64_SINT"; + case VkFormat::VK_FORMAT_R64G64B64_SFLOAT => + return "VK_FORMAT_R64G64B64_SFLOAT"; + case VkFormat::VK_FORMAT_R64G64B64A64_UINT => + return "VK_FORMAT_R64G64B64A64_UINT"; + case VkFormat::VK_FORMAT_R64G64B64A64_SINT => + return "VK_FORMAT_R64G64B64A64_SINT"; + case VkFormat::VK_FORMAT_R64G64B64A64_SFLOAT => + return "VK_FORMAT_R64G64B64A64_SFLOAT"; + case VkFormat::VK_FORMAT_B10G11R11_UFLOAT_PACK32 => + return "VK_FORMAT_B10G11R11_UFLOAT_PACK32"; + case VkFormat::VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 => + return "VK_FORMAT_E5B9G9R9_UFLOAT_PACK32"; + case VkFormat::VK_FORMAT_D16_UNORM => + return "VK_FORMAT_D16_UNORM"; + case VkFormat::VK_FORMAT_X8_D24_UNORM_PACK32 => + return "VK_FORMAT_X8_D24_UNORM_PACK32"; + case VkFormat::VK_FORMAT_D32_SFLOAT => + return "VK_FORMAT_D32_SFLOAT"; + case VkFormat::VK_FORMAT_S8_UINT => + return "VK_FORMAT_S8_UINT"; + case VkFormat::VK_FORMAT_D16_UNORM_S8_UINT => + return "VK_FORMAT_D16_UNORM_S8_UINT"; + case VkFormat::VK_FORMAT_D24_UNORM_S8_UINT => + return "VK_FORMAT_D24_UNORM_S8_UINT"; + case VkFormat::VK_FORMAT_D32_SFLOAT_S8_UINT => + return "VK_FORMAT_D32_SFLOAT_S8_UINT"; + case VkFormat::VK_FORMAT_BC1_RGB_UNORM_BLOCK => + return "VK_FORMAT_BC1_RGB_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_BC1_RGB_SRGB_BLOCK => + return "VK_FORMAT_BC1_RGB_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_BC1_RGBA_UNORM_BLOCK => + return "VK_FORMAT_BC1_RGBA_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_BC1_RGBA_SRGB_BLOCK => + return "VK_FORMAT_BC1_RGBA_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_BC2_UNORM_BLOCK => + return "VK_FORMAT_BC2_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_BC2_SRGB_BLOCK => + return "VK_FORMAT_BC2_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_BC3_UNORM_BLOCK => + return "VK_FORMAT_BC3_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_BC3_SRGB_BLOCK => + return "VK_FORMAT_BC3_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_BC4_UNORM_BLOCK => + return "VK_FORMAT_BC4_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_BC4_SNORM_BLOCK => + return "VK_FORMAT_BC4_SNORM_BLOCK"; + case VkFormat::VK_FORMAT_BC5_UNORM_BLOCK => + return "VK_FORMAT_BC5_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_BC5_SNORM_BLOCK => + return "VK_FORMAT_BC5_SNORM_BLOCK"; + case VkFormat::VK_FORMAT_BC6H_UFLOAT_BLOCK => + return "VK_FORMAT_BC6H_UFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_BC6H_SFLOAT_BLOCK => + return "VK_FORMAT_BC6H_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_BC7_UNORM_BLOCK => + return "VK_FORMAT_BC7_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_BC7_SRGB_BLOCK => + return "VK_FORMAT_BC7_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK => + return "VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK => + return "VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK => + return "VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK => + return "VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK => + return "VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK => + return "VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_EAC_R11_UNORM_BLOCK => + return "VK_FORMAT_EAC_R11_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_EAC_R11_SNORM_BLOCK => + return "VK_FORMAT_EAC_R11_SNORM_BLOCK"; + case VkFormat::VK_FORMAT_EAC_R11G11_UNORM_BLOCK => + return "VK_FORMAT_EAC_R11G11_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_EAC_R11G11_SNORM_BLOCK => + return "VK_FORMAT_EAC_R11G11_SNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_4x4_UNORM_BLOCK => + return "VK_FORMAT_ASTC_4x4_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_4x4_SRGB_BLOCK => + return "VK_FORMAT_ASTC_4x4_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_5x4_UNORM_BLOCK => + return "VK_FORMAT_ASTC_5x4_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_5x4_SRGB_BLOCK => + return "VK_FORMAT_ASTC_5x4_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_5x5_UNORM_BLOCK => + return "VK_FORMAT_ASTC_5x5_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_5x5_SRGB_BLOCK => + return "VK_FORMAT_ASTC_5x5_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_6x5_UNORM_BLOCK => + return "VK_FORMAT_ASTC_6x5_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_6x5_SRGB_BLOCK => + return "VK_FORMAT_ASTC_6x5_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_6x6_UNORM_BLOCK => + return "VK_FORMAT_ASTC_6x6_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_6x6_SRGB_BLOCK => + return "VK_FORMAT_ASTC_6x6_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_8x5_UNORM_BLOCK => + return "VK_FORMAT_ASTC_8x5_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_8x5_SRGB_BLOCK => + return "VK_FORMAT_ASTC_8x5_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_8x6_UNORM_BLOCK => + return "VK_FORMAT_ASTC_8x6_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_8x6_SRGB_BLOCK => + return "VK_FORMAT_ASTC_8x6_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_8x8_UNORM_BLOCK => + return "VK_FORMAT_ASTC_8x8_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_8x8_SRGB_BLOCK => + return "VK_FORMAT_ASTC_8x8_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x5_UNORM_BLOCK => + return "VK_FORMAT_ASTC_10x5_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x5_SRGB_BLOCK => + return "VK_FORMAT_ASTC_10x5_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x6_UNORM_BLOCK => + return "VK_FORMAT_ASTC_10x6_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x6_SRGB_BLOCK => + return "VK_FORMAT_ASTC_10x6_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x8_UNORM_BLOCK => + return "VK_FORMAT_ASTC_10x8_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x8_SRGB_BLOCK => + return "VK_FORMAT_ASTC_10x8_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x10_UNORM_BLOCK => + return "VK_FORMAT_ASTC_10x10_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x10_SRGB_BLOCK => + return "VK_FORMAT_ASTC_10x10_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_12x10_UNORM_BLOCK => + return "VK_FORMAT_ASTC_12x10_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_12x10_SRGB_BLOCK => + return "VK_FORMAT_ASTC_12x10_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_12x12_UNORM_BLOCK => + return "VK_FORMAT_ASTC_12x12_UNORM_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_12x12_SRGB_BLOCK => + return "VK_FORMAT_ASTC_12x12_SRGB_BLOCK"; + case VkFormat::VK_FORMAT_G8B8G8R8_422_UNORM => + return "VK_FORMAT_G8B8G8R8_422_UNORM"; + case VkFormat::VK_FORMAT_B8G8R8G8_422_UNORM => + return "VK_FORMAT_B8G8R8G8_422_UNORM"; + case VkFormat::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM => + return "VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM"; + case VkFormat::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM => + return "VK_FORMAT_G8_B8R8_2PLANE_420_UNORM"; + case VkFormat::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM => + return "VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM"; + case VkFormat::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM => + return "VK_FORMAT_G8_B8R8_2PLANE_422_UNORM"; + case VkFormat::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM => + return "VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM"; + case VkFormat::VK_FORMAT_R10X6_UNORM_PACK16 => + return "VK_FORMAT_R10X6_UNORM_PACK16"; + case VkFormat::VK_FORMAT_R10X6G10X6_UNORM_2PACK16 => + return "VK_FORMAT_R10X6G10X6_UNORM_2PACK16"; + case VkFormat::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 => + return "VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16"; + case VkFormat::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => + return "VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"; + case VkFormat::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => + return "VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"; + case VkFormat::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => + return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => + return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => + return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => + return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => + return "VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_R12X4_UNORM_PACK16 => + return "VK_FORMAT_R12X4_UNORM_PACK16"; + case VkFormat::VK_FORMAT_R12X4G12X4_UNORM_2PACK16 => + return "VK_FORMAT_R12X4G12X4_UNORM_2PACK16"; + case VkFormat::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 => + return "VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16"; + case VkFormat::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => + return "VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"; + case VkFormat::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => + return "VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"; + case VkFormat::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => + return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => + return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => + return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => + return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => + return "VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G16B16G16R16_422_UNORM => + return "VK_FORMAT_G16B16G16R16_422_UNORM"; + case VkFormat::VK_FORMAT_B16G16R16G16_422_UNORM => + return "VK_FORMAT_B16G16R16G16_422_UNORM"; + case VkFormat::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM => + return "VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM"; + case VkFormat::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM => + return "VK_FORMAT_G16_B16R16_2PLANE_420_UNORM"; + case VkFormat::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM => + return "VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM"; + case VkFormat::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM => + return "VK_FORMAT_G16_B16R16_2PLANE_422_UNORM"; + case VkFormat::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM => + return "VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM"; + case VkFormat::VK_FORMAT_G8_B8R8_2PLANE_444_UNORM => + return "VK_FORMAT_G8_B8R8_2PLANE_444_UNORM"; + case VkFormat::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 => + return "VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 => + return "VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16"; + case VkFormat::VK_FORMAT_G16_B16R16_2PLANE_444_UNORM => + return "VK_FORMAT_G16_B16R16_2PLANE_444_UNORM"; + case VkFormat::VK_FORMAT_A4R4G4B4_UNORM_PACK16 => + return "VK_FORMAT_A4R4G4B4_UNORM_PACK16"; + case VkFormat::VK_FORMAT_A4B4G4R4_UNORM_PACK16 => + return "VK_FORMAT_A4B4G4R4_UNORM_PACK16"; + case VkFormat::VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK"; + case VkFormat::VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK => + return "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK"; + }; +}; +export type VkFormatFeatureFlagBits = enum u32 { + 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, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 16384, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 32768, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 131072, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 262144, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 524288, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 1048576, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 2097152, + VK_FORMAT_FEATURE_DISJOINT_BIT = 4194304, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 8388608, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 65536, +}; + +export fn StrVkFormatFeatureFlagBits(value: VkFormatFeatureFlagBits) str = { + switch (value) { + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT => + return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT => + return "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT => + return "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT => + return "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT => + return "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT => + return "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT => + return "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT => + return "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT => + return "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT => + return "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_BLIT_SRC_BIT => + return "VK_FORMAT_FEATURE_BLIT_SRC_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_BLIT_DST_BIT => + return "VK_FORMAT_FEATURE_BLIT_DST_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT => + return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_TRANSFER_SRC_BIT => + return "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_TRANSFER_DST_BIT => + return "VK_FORMAT_FEATURE_TRANSFER_DST_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT => + return "VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT => + return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT => + return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT => + return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT => + return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_DISJOINT_BIT => + return "VK_FORMAT_FEATURE_DISJOINT_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT => + return "VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT"; + case VkFormatFeatureFlagBits::VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT => + return "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT"; + }; +}; +export type VkFrontFace = enum u32 { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, +}; + +export fn StrVkFrontFace(value: VkFrontFace) str = { + switch (value) { + case VkFrontFace::VK_FRONT_FACE_COUNTER_CLOCKWISE => + return "VK_FRONT_FACE_COUNTER_CLOCKWISE"; + case VkFrontFace::VK_FRONT_FACE_CLOCKWISE => + return "VK_FRONT_FACE_CLOCKWISE"; + }; +}; +export type VkImageAspectFlagBits = enum u32 { + VK_IMAGE_ASPECT_COLOR_BIT = 1, + VK_IMAGE_ASPECT_DEPTH_BIT = 2, + VK_IMAGE_ASPECT_STENCIL_BIT = 4, + VK_IMAGE_ASPECT_METADATA_BIT = 8, + VK_IMAGE_ASPECT_PLANE_0_BIT = 16, + VK_IMAGE_ASPECT_PLANE_1_BIT = 32, + VK_IMAGE_ASPECT_PLANE_2_BIT = 64, + VK_IMAGE_ASPECT_NONE = 0, +}; + +export fn StrVkImageAspectFlagBits(value: VkImageAspectFlagBits) str = { + switch (value) { + case VkImageAspectFlagBits::VK_IMAGE_ASPECT_COLOR_BIT => + return "VK_IMAGE_ASPECT_COLOR_BIT"; + case VkImageAspectFlagBits::VK_IMAGE_ASPECT_DEPTH_BIT => + return "VK_IMAGE_ASPECT_DEPTH_BIT"; + case VkImageAspectFlagBits::VK_IMAGE_ASPECT_STENCIL_BIT => + return "VK_IMAGE_ASPECT_STENCIL_BIT"; + case VkImageAspectFlagBits::VK_IMAGE_ASPECT_METADATA_BIT => + return "VK_IMAGE_ASPECT_METADATA_BIT"; + case VkImageAspectFlagBits::VK_IMAGE_ASPECT_PLANE_0_BIT => + return "VK_IMAGE_ASPECT_PLANE_0_BIT"; + case VkImageAspectFlagBits::VK_IMAGE_ASPECT_PLANE_1_BIT => + return "VK_IMAGE_ASPECT_PLANE_1_BIT"; + case VkImageAspectFlagBits::VK_IMAGE_ASPECT_PLANE_2_BIT => + return "VK_IMAGE_ASPECT_PLANE_2_BIT"; + case VkImageAspectFlagBits::VK_IMAGE_ASPECT_NONE => + return "VK_IMAGE_ASPECT_NONE"; + }; +}; +export type VkImageCreateFlagBits = enum u32 { + 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, + VK_IMAGE_CREATE_ALIAS_BIT = 1024, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 64, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 32, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 128, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 256, + VK_IMAGE_CREATE_PROTECTED_BIT = 2048, + VK_IMAGE_CREATE_DISJOINT_BIT = 512, +}; + +export fn StrVkImageCreateFlagBits(value: VkImageCreateFlagBits) str = { + switch (value) { + case VkImageCreateFlagBits::VK_IMAGE_CREATE_SPARSE_BINDING_BIT => + return "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT => + return "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_SPARSE_ALIASED_BIT => + return "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT => + return "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT => + return "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_ALIAS_BIT => + return "VK_IMAGE_CREATE_ALIAS_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT => + return "VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT => + return "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT => + return "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_EXTENDED_USAGE_BIT => + return "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_PROTECTED_BIT => + return "VK_IMAGE_CREATE_PROTECTED_BIT"; + case VkImageCreateFlagBits::VK_IMAGE_CREATE_DISJOINT_BIT => + return "VK_IMAGE_CREATE_DISJOINT_BIT"; + }; +}; +export type VkImageLayout = enum u32 { + 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_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, +}; + +export fn StrVkImageLayout(value: VkImageLayout) str = { + switch (value) { + case VkImageLayout::VK_IMAGE_LAYOUT_UNDEFINED => + return "VK_IMAGE_LAYOUT_UNDEFINED"; + case VkImageLayout::VK_IMAGE_LAYOUT_GENERAL => + return "VK_IMAGE_LAYOUT_GENERAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL => + return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL => + return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL => + return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL => + return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL => + return "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL => + return "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_PREINITIALIZED => + return "VK_IMAGE_LAYOUT_PREINITIALIZED"; + case VkImageLayout::VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => + return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => + return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL => + return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL => + return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL => + return "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL => + return "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL => + return "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL"; + case VkImageLayout::VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL => + return "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL"; + }; +}; +export type VkImageTiling = enum u32 { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, +}; + +export fn StrVkImageTiling(value: VkImageTiling) str = { + switch (value) { + case VkImageTiling::VK_IMAGE_TILING_OPTIMAL => + return "VK_IMAGE_TILING_OPTIMAL"; + case VkImageTiling::VK_IMAGE_TILING_LINEAR => + return "VK_IMAGE_TILING_LINEAR"; + }; +}; +export type VkImageType = enum u32 { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, +}; + +export fn StrVkImageType(value: VkImageType) str = { + switch (value) { + case VkImageType::VK_IMAGE_TYPE_1D => + return "VK_IMAGE_TYPE_1D"; + case VkImageType::VK_IMAGE_TYPE_2D => + return "VK_IMAGE_TYPE_2D"; + case VkImageType::VK_IMAGE_TYPE_3D => + return "VK_IMAGE_TYPE_3D"; + }; +}; +export type VkImageUsageFlagBits = enum u32 { + 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, +}; + +export fn StrVkImageUsageFlagBits(value: VkImageUsageFlagBits) str = { + switch (value) { + case VkImageUsageFlagBits::VK_IMAGE_USAGE_TRANSFER_SRC_BIT => + return "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"; + case VkImageUsageFlagBits::VK_IMAGE_USAGE_TRANSFER_DST_BIT => + return "VK_IMAGE_USAGE_TRANSFER_DST_BIT"; + case VkImageUsageFlagBits::VK_IMAGE_USAGE_SAMPLED_BIT => + return "VK_IMAGE_USAGE_SAMPLED_BIT"; + case VkImageUsageFlagBits::VK_IMAGE_USAGE_STORAGE_BIT => + return "VK_IMAGE_USAGE_STORAGE_BIT"; + case VkImageUsageFlagBits::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT => + return "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"; + case VkImageUsageFlagBits::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT => + return "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"; + case VkImageUsageFlagBits::VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT => + return "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"; + case VkImageUsageFlagBits::VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT => + return "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"; + }; +}; +export type VkImageViewType = enum u32 { + 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, +}; + +export fn StrVkImageViewType(value: VkImageViewType) str = { + switch (value) { + case VkImageViewType::VK_IMAGE_VIEW_TYPE_1D => + return "VK_IMAGE_VIEW_TYPE_1D"; + case VkImageViewType::VK_IMAGE_VIEW_TYPE_2D => + return "VK_IMAGE_VIEW_TYPE_2D"; + case VkImageViewType::VK_IMAGE_VIEW_TYPE_3D => + return "VK_IMAGE_VIEW_TYPE_3D"; + case VkImageViewType::VK_IMAGE_VIEW_TYPE_CUBE => + return "VK_IMAGE_VIEW_TYPE_CUBE"; + case VkImageViewType::VK_IMAGE_VIEW_TYPE_1D_ARRAY => + return "VK_IMAGE_VIEW_TYPE_1D_ARRAY"; + case VkImageViewType::VK_IMAGE_VIEW_TYPE_2D_ARRAY => + return "VK_IMAGE_VIEW_TYPE_2D_ARRAY"; + case VkImageViewType::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY => + return "VK_IMAGE_VIEW_TYPE_CUBE_ARRAY"; + }; +}; +export type VkSharingMode = enum u32 { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, +}; + +export fn StrVkSharingMode(value: VkSharingMode) str = { + switch (value) { + case VkSharingMode::VK_SHARING_MODE_EXCLUSIVE => + return "VK_SHARING_MODE_EXCLUSIVE"; + case VkSharingMode::VK_SHARING_MODE_CONCURRENT => + return "VK_SHARING_MODE_CONCURRENT"; + }; +}; +export type VkIndexType = enum u32 { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, +}; + +export fn StrVkIndexType(value: VkIndexType) str = { + switch (value) { + case VkIndexType::VK_INDEX_TYPE_UINT16 => + return "VK_INDEX_TYPE_UINT16"; + case VkIndexType::VK_INDEX_TYPE_UINT32 => + return "VK_INDEX_TYPE_UINT32"; + }; +}; +export type VkLogicOp = enum u32 { + 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, +}; + +export fn StrVkLogicOp(value: VkLogicOp) str = { + switch (value) { + case VkLogicOp::VK_LOGIC_OP_CLEAR => + return "VK_LOGIC_OP_CLEAR"; + case VkLogicOp::VK_LOGIC_OP_AND => + return "VK_LOGIC_OP_AND"; + case VkLogicOp::VK_LOGIC_OP_AND_REVERSE => + return "VK_LOGIC_OP_AND_REVERSE"; + case VkLogicOp::VK_LOGIC_OP_COPY => + return "VK_LOGIC_OP_COPY"; + case VkLogicOp::VK_LOGIC_OP_AND_INVERTED => + return "VK_LOGIC_OP_AND_INVERTED"; + case VkLogicOp::VK_LOGIC_OP_NO_OP => + return "VK_LOGIC_OP_NO_OP"; + case VkLogicOp::VK_LOGIC_OP_XOR => + return "VK_LOGIC_OP_XOR"; + case VkLogicOp::VK_LOGIC_OP_OR => + return "VK_LOGIC_OP_OR"; + case VkLogicOp::VK_LOGIC_OP_NOR => + return "VK_LOGIC_OP_NOR"; + case VkLogicOp::VK_LOGIC_OP_EQUIVALENT => + return "VK_LOGIC_OP_EQUIVALENT"; + case VkLogicOp::VK_LOGIC_OP_INVERT => + return "VK_LOGIC_OP_INVERT"; + case VkLogicOp::VK_LOGIC_OP_OR_REVERSE => + return "VK_LOGIC_OP_OR_REVERSE"; + case VkLogicOp::VK_LOGIC_OP_COPY_INVERTED => + return "VK_LOGIC_OP_COPY_INVERTED"; + case VkLogicOp::VK_LOGIC_OP_OR_INVERTED => + return "VK_LOGIC_OP_OR_INVERTED"; + case VkLogicOp::VK_LOGIC_OP_NAND => + return "VK_LOGIC_OP_NAND"; + case VkLogicOp::VK_LOGIC_OP_SET => + return "VK_LOGIC_OP_SET"; + }; +}; +export type VkMemoryHeapFlagBits = enum u32 { + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 2, +}; + +export fn StrVkMemoryHeapFlagBits(value: VkMemoryHeapFlagBits) str = { + switch (value) { + case VkMemoryHeapFlagBits::VK_MEMORY_HEAP_DEVICE_LOCAL_BIT => + return "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"; + case VkMemoryHeapFlagBits::VK_MEMORY_HEAP_MULTI_INSTANCE_BIT => + return "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT"; + }; +}; +export type VkAccessFlagBits = enum u32 { + 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, + VK_ACCESS_NONE = 0, +}; + +export fn StrVkAccessFlagBits(value: VkAccessFlagBits) str = { + switch (value) { + case VkAccessFlagBits::VK_ACCESS_INDIRECT_COMMAND_READ_BIT => + return "VK_ACCESS_INDIRECT_COMMAND_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_INDEX_READ_BIT => + return "VK_ACCESS_INDEX_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT => + return "VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_UNIFORM_READ_BIT => + return "VK_ACCESS_UNIFORM_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT => + return "VK_ACCESS_INPUT_ATTACHMENT_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_SHADER_READ_BIT => + return "VK_ACCESS_SHADER_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_SHADER_WRITE_BIT => + return "VK_ACCESS_SHADER_WRITE_BIT"; + case VkAccessFlagBits::VK_ACCESS_COLOR_ATTACHMENT_READ_BIT => + return "VK_ACCESS_COLOR_ATTACHMENT_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT => + return "VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT"; + case VkAccessFlagBits::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT => + return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT => + return "VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"; + case VkAccessFlagBits::VK_ACCESS_TRANSFER_READ_BIT => + return "VK_ACCESS_TRANSFER_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_TRANSFER_WRITE_BIT => + return "VK_ACCESS_TRANSFER_WRITE_BIT"; + case VkAccessFlagBits::VK_ACCESS_HOST_READ_BIT => + return "VK_ACCESS_HOST_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_HOST_WRITE_BIT => + return "VK_ACCESS_HOST_WRITE_BIT"; + case VkAccessFlagBits::VK_ACCESS_MEMORY_READ_BIT => + return "VK_ACCESS_MEMORY_READ_BIT"; + case VkAccessFlagBits::VK_ACCESS_MEMORY_WRITE_BIT => + return "VK_ACCESS_MEMORY_WRITE_BIT"; + case VkAccessFlagBits::VK_ACCESS_NONE => + return "VK_ACCESS_NONE"; + }; +}; +export type VkMemoryPropertyFlagBits = enum u32 { + 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, + VK_MEMORY_PROPERTY_PROTECTED_BIT = 32, +}; + +export fn StrVkMemoryPropertyFlagBits(value: VkMemoryPropertyFlagBits) str = { + switch (value) { + case VkMemoryPropertyFlagBits::VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT => + return "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT"; + case VkMemoryPropertyFlagBits::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT => + return "VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"; + case VkMemoryPropertyFlagBits::VK_MEMORY_PROPERTY_HOST_COHERENT_BIT => + return "VK_MEMORY_PROPERTY_HOST_COHERENT_BIT"; + case VkMemoryPropertyFlagBits::VK_MEMORY_PROPERTY_HOST_CACHED_BIT => + return "VK_MEMORY_PROPERTY_HOST_CACHED_BIT"; + case VkMemoryPropertyFlagBits::VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT => + return "VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT"; + case VkMemoryPropertyFlagBits::VK_MEMORY_PROPERTY_PROTECTED_BIT => + return "VK_MEMORY_PROPERTY_PROTECTED_BIT"; + }; +}; +export type VkPhysicalDeviceType = enum u32 { + 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, +}; + +export fn StrVkPhysicalDeviceType(value: VkPhysicalDeviceType) str = { + switch (value) { + case VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_OTHER => + return "VK_PHYSICAL_DEVICE_TYPE_OTHER"; + case VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU => + return "VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU"; + case VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU => + return "VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU"; + case VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU => + return "VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU"; + case VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_CPU => + return "VK_PHYSICAL_DEVICE_TYPE_CPU"; + }; +}; +export type VkPipelineBindPoint = enum u32 { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, +}; + +export fn StrVkPipelineBindPoint(value: VkPipelineBindPoint) str = { + switch (value) { + case VkPipelineBindPoint::VK_PIPELINE_BIND_POINT_GRAPHICS => + return "VK_PIPELINE_BIND_POINT_GRAPHICS"; + case VkPipelineBindPoint::VK_PIPELINE_BIND_POINT_COMPUTE => + return "VK_PIPELINE_BIND_POINT_COMPUTE"; + }; +}; +export type VkPipelineCreateFlagBits = enum u32 { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 4, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 8, + VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 16, + VK_PIPELINE_CREATE_DISPATCH_BASE = 16, + VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 256, + VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 512, +}; + +export fn StrVkPipelineCreateFlagBits(value: VkPipelineCreateFlagBits) str = { + switch (value) { + case VkPipelineCreateFlagBits::VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT => + return "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"; + case VkPipelineCreateFlagBits::VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT => + return "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"; + case VkPipelineCreateFlagBits::VK_PIPELINE_CREATE_DERIVATIVE_BIT => + return "VK_PIPELINE_CREATE_DERIVATIVE_BIT"; + case VkPipelineCreateFlagBits::VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT => + return "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"; + case VkPipelineCreateFlagBits::VK_PIPELINE_CREATE_DISPATCH_BASE_BIT => + return "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"; + case VkPipelineCreateFlagBits::VK_PIPELINE_CREATE_DISPATCH_BASE => + return "VK_PIPELINE_CREATE_DISPATCH_BASE"; + case VkPipelineCreateFlagBits::VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT => + return "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT"; + case VkPipelineCreateFlagBits::VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT => + return "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT"; + }; +}; +export type VkPrimitiveTopology = enum u32 { + 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, +}; + +export fn StrVkPrimitiveTopology(value: VkPrimitiveTopology) str = { + switch (value) { + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_POINT_LIST => + return "VK_PRIMITIVE_TOPOLOGY_POINT_LIST"; + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_LINE_LIST => + return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST"; + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_LINE_STRIP => + return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP"; + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST => + return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST"; + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP => + return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP"; + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN => + return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN"; + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY => + return "VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY"; + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY => + return "VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY"; + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY => + return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY"; + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY => + return "VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY"; + case VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_PATCH_LIST => + return "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST"; + }; +}; +export type VkQueryControlFlagBits = enum u32 { + VK_QUERY_CONTROL_PRECISE_BIT = 1, +}; + +export fn StrVkQueryControlFlagBits(value: VkQueryControlFlagBits) str = { + switch (value) { + case VkQueryControlFlagBits::VK_QUERY_CONTROL_PRECISE_BIT => + return "VK_QUERY_CONTROL_PRECISE_BIT"; + }; +}; +export type VkQueryPipelineStatisticFlagBits = enum u32 { + 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, +}; + +export fn StrVkQueryPipelineStatisticFlagBits(value: VkQueryPipelineStatisticFlagBits) str = { + switch (value) { + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT"; + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT"; + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT"; + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT"; + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT"; + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT"; + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT"; + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT"; + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT"; + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT"; + case VkQueryPipelineStatisticFlagBits::VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT => + return "VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT"; + }; +}; +export type VkQueryResultFlagBits = enum u32 { + 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, +}; + +export fn StrVkQueryResultFlagBits(value: VkQueryResultFlagBits) str = { + switch (value) { + case VkQueryResultFlagBits::VK_QUERY_RESULT_64_BIT => + return "VK_QUERY_RESULT_64_BIT"; + case VkQueryResultFlagBits::VK_QUERY_RESULT_WAIT_BIT => + return "VK_QUERY_RESULT_WAIT_BIT"; + case VkQueryResultFlagBits::VK_QUERY_RESULT_WITH_AVAILABILITY_BIT => + return "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"; + case VkQueryResultFlagBits::VK_QUERY_RESULT_PARTIAL_BIT => + return "VK_QUERY_RESULT_PARTIAL_BIT"; + }; +}; +export type VkQueryType = enum u32 { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, +}; + +export fn StrVkQueryType(value: VkQueryType) str = { + switch (value) { + case VkQueryType::VK_QUERY_TYPE_OCCLUSION => + return "VK_QUERY_TYPE_OCCLUSION"; + case VkQueryType::VK_QUERY_TYPE_PIPELINE_STATISTICS => + return "VK_QUERY_TYPE_PIPELINE_STATISTICS"; + case VkQueryType::VK_QUERY_TYPE_TIMESTAMP => + return "VK_QUERY_TYPE_TIMESTAMP"; + }; +}; +export type VkQueueFlagBits = enum u32 { + VK_QUEUE_GRAPHICS_BIT = 1, + VK_QUEUE_COMPUTE_BIT = 2, + VK_QUEUE_TRANSFER_BIT = 4, + VK_QUEUE_SPARSE_BINDING_BIT = 8, + VK_QUEUE_PROTECTED_BIT = 16, +}; + +export fn StrVkQueueFlagBits(value: VkQueueFlagBits) str = { + switch (value) { + case VkQueueFlagBits::VK_QUEUE_GRAPHICS_BIT => + return "VK_QUEUE_GRAPHICS_BIT"; + case VkQueueFlagBits::VK_QUEUE_COMPUTE_BIT => + return "VK_QUEUE_COMPUTE_BIT"; + case VkQueueFlagBits::VK_QUEUE_TRANSFER_BIT => + return "VK_QUEUE_TRANSFER_BIT"; + case VkQueueFlagBits::VK_QUEUE_SPARSE_BINDING_BIT => + return "VK_QUEUE_SPARSE_BINDING_BIT"; + case VkQueueFlagBits::VK_QUEUE_PROTECTED_BIT => + return "VK_QUEUE_PROTECTED_BIT"; + }; +}; +export type VkSubpassContents = enum u32 { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, +}; + +export fn StrVkSubpassContents(value: VkSubpassContents) str = { + switch (value) { + case VkSubpassContents::VK_SUBPASS_CONTENTS_INLINE => + return "VK_SUBPASS_CONTENTS_INLINE"; + case VkSubpassContents::VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS => + return "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS"; + }; +}; +export type VkResult = enum u32 { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_FRAGMENTED_POOL = -12, + VK_ERROR_UNKNOWN = -13, + VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + VK_ERROR_FRAGMENTATION = -1000161000, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, + VK_PIPELINE_COMPILE_REQUIRED = 1000297000, +}; + +export fn StrVkResult(value: VkResult) str = { + switch (value) { + case VkResult::VK_SUCCESS => + return "VK_SUCCESS"; + case VkResult::VK_NOT_READY => + return "VK_NOT_READY"; + case VkResult::VK_TIMEOUT => + return "VK_TIMEOUT"; + case VkResult::VK_EVENT_SET => + return "VK_EVENT_SET"; + case VkResult::VK_EVENT_RESET => + return "VK_EVENT_RESET"; + case VkResult::VK_INCOMPLETE => + return "VK_INCOMPLETE"; + case VkResult::VK_ERROR_OUT_OF_HOST_MEMORY => + return "VK_ERROR_OUT_OF_HOST_MEMORY"; + case VkResult::VK_ERROR_OUT_OF_DEVICE_MEMORY => + return "VK_ERROR_OUT_OF_DEVICE_MEMORY"; + case VkResult::VK_ERROR_INITIALIZATION_FAILED => + return "VK_ERROR_INITIALIZATION_FAILED"; + case VkResult::VK_ERROR_DEVICE_LOST => + return "VK_ERROR_DEVICE_LOST"; + case VkResult::VK_ERROR_MEMORY_MAP_FAILED => + return "VK_ERROR_MEMORY_MAP_FAILED"; + case VkResult::VK_ERROR_LAYER_NOT_PRESENT => + return "VK_ERROR_LAYER_NOT_PRESENT"; + case VkResult::VK_ERROR_EXTENSION_NOT_PRESENT => + return "VK_ERROR_EXTENSION_NOT_PRESENT"; + case VkResult::VK_ERROR_FEATURE_NOT_PRESENT => + return "VK_ERROR_FEATURE_NOT_PRESENT"; + case VkResult::VK_ERROR_INCOMPATIBLE_DRIVER => + return "VK_ERROR_INCOMPATIBLE_DRIVER"; + case VkResult::VK_ERROR_TOO_MANY_OBJECTS => + return "VK_ERROR_TOO_MANY_OBJECTS"; + case VkResult::VK_ERROR_FORMAT_NOT_SUPPORTED => + return "VK_ERROR_FORMAT_NOT_SUPPORTED"; + case VkResult::VK_ERROR_FRAGMENTED_POOL => + return "VK_ERROR_FRAGMENTED_POOL"; + case VkResult::VK_ERROR_UNKNOWN => + return "VK_ERROR_UNKNOWN"; + case VkResult::VK_ERROR_OUT_OF_POOL_MEMORY => + return "VK_ERROR_OUT_OF_POOL_MEMORY"; + case VkResult::VK_ERROR_INVALID_EXTERNAL_HANDLE => + return "VK_ERROR_INVALID_EXTERNAL_HANDLE"; + case VkResult::VK_ERROR_FRAGMENTATION => + return "VK_ERROR_FRAGMENTATION"; + case VkResult::VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS => + return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"; + case VkResult::VK_PIPELINE_COMPILE_REQUIRED => + return "VK_PIPELINE_COMPILE_REQUIRED"; + }; +}; +export type VkShaderStageFlagBits = enum u32 { + 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_COMPUTE_BIT = 32, + VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, + VK_SHADER_STAGE_ALL = 0x7FFFFFFF, +}; + +export fn StrVkShaderStageFlagBits(value: VkShaderStageFlagBits) str = { + switch (value) { + case VkShaderStageFlagBits::VK_SHADER_STAGE_VERTEX_BIT => + return "VK_SHADER_STAGE_VERTEX_BIT"; + case VkShaderStageFlagBits::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT => + return "VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT"; + case VkShaderStageFlagBits::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT => + return "VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT"; + case VkShaderStageFlagBits::VK_SHADER_STAGE_GEOMETRY_BIT => + return "VK_SHADER_STAGE_GEOMETRY_BIT"; + case VkShaderStageFlagBits::VK_SHADER_STAGE_FRAGMENT_BIT => + return "VK_SHADER_STAGE_FRAGMENT_BIT"; + case VkShaderStageFlagBits::VK_SHADER_STAGE_COMPUTE_BIT => + return "VK_SHADER_STAGE_COMPUTE_BIT"; + case VkShaderStageFlagBits::VK_SHADER_STAGE_ALL_GRAPHICS => + return "VK_SHADER_STAGE_ALL_GRAPHICS"; + case VkShaderStageFlagBits::VK_SHADER_STAGE_ALL => + return "VK_SHADER_STAGE_ALL"; + }; +}; +export type VkSparseMemoryBindFlagBits = enum u32 { + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1, +}; + +export fn StrVkSparseMemoryBindFlagBits(value: VkSparseMemoryBindFlagBits) str = { + switch (value) { + case VkSparseMemoryBindFlagBits::VK_SPARSE_MEMORY_BIND_METADATA_BIT => + return "VK_SPARSE_MEMORY_BIND_METADATA_BIT"; + }; +}; +export type VkStencilFaceFlagBits = enum u32 { + VK_STENCIL_FACE_FRONT_BIT = 1, + VK_STENCIL_FACE_BACK_BIT = 2, + VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, + VK_STENCIL_FRONT_AND_BACK = 0x00000003, +}; + +export fn StrVkStencilFaceFlagBits(value: VkStencilFaceFlagBits) str = { + switch (value) { + case VkStencilFaceFlagBits::VK_STENCIL_FACE_FRONT_BIT => + return "VK_STENCIL_FACE_FRONT_BIT"; + case VkStencilFaceFlagBits::VK_STENCIL_FACE_BACK_BIT => + return "VK_STENCIL_FACE_BACK_BIT"; + case VkStencilFaceFlagBits::VK_STENCIL_FACE_FRONT_AND_BACK => + return "VK_STENCIL_FACE_FRONT_AND_BACK"; + case VkStencilFaceFlagBits::VK_STENCIL_FRONT_AND_BACK => + return "VK_STENCIL_FRONT_AND_BACK"; + }; +}; +export type VkStencilOp = enum u32 { + 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, +}; + +export fn StrVkStencilOp(value: VkStencilOp) str = { + switch (value) { + case VkStencilOp::VK_STENCIL_OP_KEEP => + return "VK_STENCIL_OP_KEEP"; + case VkStencilOp::VK_STENCIL_OP_ZERO => + return "VK_STENCIL_OP_ZERO"; + case VkStencilOp::VK_STENCIL_OP_REPLACE => + return "VK_STENCIL_OP_REPLACE"; + case VkStencilOp::VK_STENCIL_OP_INCREMENT_AND_CLAMP => + return "VK_STENCIL_OP_INCREMENT_AND_CLAMP"; + case VkStencilOp::VK_STENCIL_OP_DECREMENT_AND_CLAMP => + return "VK_STENCIL_OP_DECREMENT_AND_CLAMP"; + case VkStencilOp::VK_STENCIL_OP_INVERT => + return "VK_STENCIL_OP_INVERT"; + case VkStencilOp::VK_STENCIL_OP_INCREMENT_AND_WRAP => + return "VK_STENCIL_OP_INCREMENT_AND_WRAP"; + case VkStencilOp::VK_STENCIL_OP_DECREMENT_AND_WRAP => + return "VK_STENCIL_OP_DECREMENT_AND_WRAP"; + }; +}; +export type VkStructureType = enum u32 { + 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_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54, + VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000, + VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001, + VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, + VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002, + VK_STRUCTURE_TYPE_DEPENDENCY_INFO = 1000314003, + VK_STRUCTURE_TYPE_SUBMIT_INFO_2 = 1000314004, + VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, + VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000, + VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001, + VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005, + VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006, + VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008, + VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, + VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001, + VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, + VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, +}; + +export fn StrVkStructureType(value: VkStructureType) str = { + switch (value) { + case VkStructureType::VK_STRUCTURE_TYPE_APPLICATION_INFO => + return "VK_STRUCTURE_TYPE_APPLICATION_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_SUBMIT_INFO => + return "VK_STRUCTURE_TYPE_SUBMIT_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO => + return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE => + return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE"; + case VkStructureType::VK_STRUCTURE_TYPE_BIND_SPARSE_INFO => + return "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_EVENT_CREATE_INFO => + return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO => + return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO => + return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO => + return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO => + return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO => + return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO => + return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO => + return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO => + return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET => + return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET"; + case VkStructureType::VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET => + return "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET"; + case VkStructureType::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO => + return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO => + return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO => + return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO => + return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO => + return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO => + return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO => + return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER => + return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER => + return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER"; + case VkStructureType::VK_STRUCTURE_TYPE_MEMORY_BARRIER => + return "VK_STRUCTURE_TYPE_MEMORY_BARRIER"; + case VkStructureType::VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO => + return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO => + return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS => + return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS"; + case VkStructureType::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO => + return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO => + return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO => + return "VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO => + return "VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO => + return "VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO => + return "VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO => + return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO => + return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 => + return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 => + return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 => + return "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 => + return "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2"; + case VkStructureType::VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 => + return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2"; + case VkStructureType::VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 => + return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 => + return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 => + return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"; + case VkStructureType::VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 => + return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO => + return "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO => + return "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO => + return "VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 => + return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO => + return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO => + return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO => + return "VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO => + return "VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES => + return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES => + return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES => + return "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO => + return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO => + return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES => + return "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES => + return "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT => + return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO => + return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 => + return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2"; + case VkStructureType::VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 => + return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2"; + case VkStructureType::VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 => + return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2"; + case VkStructureType::VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 => + return "VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2"; + case VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 => + return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO => + return "VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_SUBPASS_END_INFO => + return "VK_STRUCTURE_TYPE_SUBPASS_END_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO => + return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO => + return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT => + return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE => + return "VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO => + return "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO => + return "VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO => + return "VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT => + return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT"; + case VkStructureType::VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT => + return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO => + return "VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO => + return "VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO => + return "VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO => + return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO => + return "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO => + return "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO => + return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO => + return "VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 => + return "VK_STRUCTURE_TYPE_MEMORY_BARRIER_2"; + case VkStructureType::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 => + return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 => + return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2"; + case VkStructureType::VK_STRUCTURE_TYPE_DEPENDENCY_INFO => + return "VK_STRUCTURE_TYPE_DEPENDENCY_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_SUBMIT_INFO_2 => + return "VK_STRUCTURE_TYPE_SUBMIT_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO => + return "VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO => + return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 => + return "VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 => + return "VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 => + return "VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 => + return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 => + return "VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 => + return "VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2"; + case VkStructureType::VK_STRUCTURE_TYPE_BUFFER_COPY_2 => + return "VK_STRUCTURE_TYPE_BUFFER_COPY_2"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_COPY_2 => + return "VK_STRUCTURE_TYPE_IMAGE_COPY_2"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_BLIT_2 => + return "VK_STRUCTURE_TYPE_IMAGE_BLIT_2"; + case VkStructureType::VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 => + return "VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2"; + case VkStructureType::VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 => + return "VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK => + return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK"; + case VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO => + return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_RENDERING_INFO => + return "VK_STRUCTURE_TYPE_RENDERING_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO => + return "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO => + return "VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO => + return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 => + return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES"; + case VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES => + return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS => + return "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS"; + case VkStructureType::VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS => + return "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS"; + }; +}; +export type VkSystemAllocationScope = enum u32 { + 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, +}; + +export fn StrVkSystemAllocationScope(value: VkSystemAllocationScope) str = { + switch (value) { + case VkSystemAllocationScope::VK_SYSTEM_ALLOCATION_SCOPE_COMMAND => + return "VK_SYSTEM_ALLOCATION_SCOPE_COMMAND"; + case VkSystemAllocationScope::VK_SYSTEM_ALLOCATION_SCOPE_OBJECT => + return "VK_SYSTEM_ALLOCATION_SCOPE_OBJECT"; + case VkSystemAllocationScope::VK_SYSTEM_ALLOCATION_SCOPE_CACHE => + return "VK_SYSTEM_ALLOCATION_SCOPE_CACHE"; + case VkSystemAllocationScope::VK_SYSTEM_ALLOCATION_SCOPE_DEVICE => + return "VK_SYSTEM_ALLOCATION_SCOPE_DEVICE"; + case VkSystemAllocationScope::VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE => + return "VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE"; + }; +}; +export type VkInternalAllocationType = enum u32 { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, +}; + +export fn StrVkInternalAllocationType(value: VkInternalAllocationType) str = { + switch (value) { + case VkInternalAllocationType::VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE => + return "VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE"; + }; +}; +export type VkSamplerAddressMode = enum u32 { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, +}; + +export fn StrVkSamplerAddressMode(value: VkSamplerAddressMode) str = { + switch (value) { + case VkSamplerAddressMode::VK_SAMPLER_ADDRESS_MODE_REPEAT => + return "VK_SAMPLER_ADDRESS_MODE_REPEAT"; + case VkSamplerAddressMode::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT => + return "VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT"; + case VkSamplerAddressMode::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE => + return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE"; + case VkSamplerAddressMode::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER => + return "VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER"; + case VkSamplerAddressMode::VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE => + return "VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE"; + }; +}; +export type VkFilter = enum u32 { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, +}; + +export fn StrVkFilter(value: VkFilter) str = { + switch (value) { + case VkFilter::VK_FILTER_NEAREST => + return "VK_FILTER_NEAREST"; + case VkFilter::VK_FILTER_LINEAR => + return "VK_FILTER_LINEAR"; + }; +}; +export type VkSamplerMipmapMode = enum u32 { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, +}; + +export fn StrVkSamplerMipmapMode(value: VkSamplerMipmapMode) str = { + switch (value) { + case VkSamplerMipmapMode::VK_SAMPLER_MIPMAP_MODE_NEAREST => + return "VK_SAMPLER_MIPMAP_MODE_NEAREST"; + case VkSamplerMipmapMode::VK_SAMPLER_MIPMAP_MODE_LINEAR => + return "VK_SAMPLER_MIPMAP_MODE_LINEAR"; + }; +}; +export type VkVertexInputRate = enum u32 { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, +}; + +export fn StrVkVertexInputRate(value: VkVertexInputRate) str = { + switch (value) { + case VkVertexInputRate::VK_VERTEX_INPUT_RATE_VERTEX => + return "VK_VERTEX_INPUT_RATE_VERTEX"; + case VkVertexInputRate::VK_VERTEX_INPUT_RATE_INSTANCE => + return "VK_VERTEX_INPUT_RATE_INSTANCE"; + }; +}; +export type VkPipelineStageFlagBits = enum u32 { + 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, + VK_PIPELINE_STAGE_NONE = 0, +}; + +export fn StrVkPipelineStageFlagBits(value: VkPipelineStageFlagBits) str = { + switch (value) { + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT => + return "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT => + return "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT => + return "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT => + return "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT => + return "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT => + return "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT => + return "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT => + return "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT => + return "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT => + return "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT => + return "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT => + return "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_TRANSFER_BIT => + return "VK_PIPELINE_STAGE_TRANSFER_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT => + return "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_HOST_BIT => + return "VK_PIPELINE_STAGE_HOST_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT => + return "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT => + return "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"; + case VkPipelineStageFlagBits::VK_PIPELINE_STAGE_NONE => + return "VK_PIPELINE_STAGE_NONE"; + }; +}; +export type VkSparseImageFormatFlagBits = enum u32 { + 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, +}; + +export fn StrVkSparseImageFormatFlagBits(value: VkSparseImageFormatFlagBits) str = { + switch (value) { + case VkSparseImageFormatFlagBits::VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT => + return "VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT"; + case VkSparseImageFormatFlagBits::VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT => + return "VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT"; + case VkSparseImageFormatFlagBits::VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT => + return "VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT"; + }; +}; +export type VkSampleCountFlagBits = enum u32 { + 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, +}; + +export fn StrVkSampleCountFlagBits(value: VkSampleCountFlagBits) str = { + switch (value) { + case VkSampleCountFlagBits::VK_SAMPLE_COUNT_1_BIT => + return "VK_SAMPLE_COUNT_1_BIT"; + case VkSampleCountFlagBits::VK_SAMPLE_COUNT_2_BIT => + return "VK_SAMPLE_COUNT_2_BIT"; + case VkSampleCountFlagBits::VK_SAMPLE_COUNT_4_BIT => + return "VK_SAMPLE_COUNT_4_BIT"; + case VkSampleCountFlagBits::VK_SAMPLE_COUNT_8_BIT => + return "VK_SAMPLE_COUNT_8_BIT"; + case VkSampleCountFlagBits::VK_SAMPLE_COUNT_16_BIT => + return "VK_SAMPLE_COUNT_16_BIT"; + case VkSampleCountFlagBits::VK_SAMPLE_COUNT_32_BIT => + return "VK_SAMPLE_COUNT_32_BIT"; + case VkSampleCountFlagBits::VK_SAMPLE_COUNT_64_BIT => + return "VK_SAMPLE_COUNT_64_BIT"; + }; +}; +export type VkAttachmentDescriptionFlagBits = enum u32 { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1, +}; + +export fn StrVkAttachmentDescriptionFlagBits(value: VkAttachmentDescriptionFlagBits) str = { + switch (value) { + case VkAttachmentDescriptionFlagBits::VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT => + return "VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT"; + }; +}; +export type VkDescriptorPoolCreateFlagBits = enum u32 { + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 2, +}; + +export fn StrVkDescriptorPoolCreateFlagBits(value: VkDescriptorPoolCreateFlagBits) str = { + switch (value) { + case VkDescriptorPoolCreateFlagBits::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT => + return "VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT"; + case VkDescriptorPoolCreateFlagBits::VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT => + return "VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT"; + }; +}; +export type VkDependencyFlagBits = enum u32 { + VK_DEPENDENCY_BY_REGION_BIT = 1, + VK_DEPENDENCY_DEVICE_GROUP_BIT = 4, + VK_DEPENDENCY_VIEW_LOCAL_BIT = 2, +}; + +export fn StrVkDependencyFlagBits(value: VkDependencyFlagBits) str = { + switch (value) { + case VkDependencyFlagBits::VK_DEPENDENCY_BY_REGION_BIT => + return "VK_DEPENDENCY_BY_REGION_BIT"; + case VkDependencyFlagBits::VK_DEPENDENCY_DEVICE_GROUP_BIT => + return "VK_DEPENDENCY_DEVICE_GROUP_BIT"; + case VkDependencyFlagBits::VK_DEPENDENCY_VIEW_LOCAL_BIT => + return "VK_DEPENDENCY_VIEW_LOCAL_BIT"; + }; +}; +export type VkObjectType = enum u32 { + 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, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, +}; + +export fn StrVkObjectType(value: VkObjectType) str = { + switch (value) { + case VkObjectType::VK_OBJECT_TYPE_UNKNOWN => + return "VK_OBJECT_TYPE_UNKNOWN"; + case VkObjectType::VK_OBJECT_TYPE_INSTANCE => + return "VK_OBJECT_TYPE_INSTANCE"; + case VkObjectType::VK_OBJECT_TYPE_PHYSICAL_DEVICE => + return "VK_OBJECT_TYPE_PHYSICAL_DEVICE"; + case VkObjectType::VK_OBJECT_TYPE_DEVICE => + return "VK_OBJECT_TYPE_DEVICE"; + case VkObjectType::VK_OBJECT_TYPE_QUEUE => + return "VK_OBJECT_TYPE_QUEUE"; + case VkObjectType::VK_OBJECT_TYPE_SEMAPHORE => + return "VK_OBJECT_TYPE_SEMAPHORE"; + case VkObjectType::VK_OBJECT_TYPE_COMMAND_BUFFER => + return "VK_OBJECT_TYPE_COMMAND_BUFFER"; + case VkObjectType::VK_OBJECT_TYPE_FENCE => + return "VK_OBJECT_TYPE_FENCE"; + case VkObjectType::VK_OBJECT_TYPE_DEVICE_MEMORY => + return "VK_OBJECT_TYPE_DEVICE_MEMORY"; + case VkObjectType::VK_OBJECT_TYPE_BUFFER => + return "VK_OBJECT_TYPE_BUFFER"; + case VkObjectType::VK_OBJECT_TYPE_IMAGE => + return "VK_OBJECT_TYPE_IMAGE"; + case VkObjectType::VK_OBJECT_TYPE_EVENT => + return "VK_OBJECT_TYPE_EVENT"; + case VkObjectType::VK_OBJECT_TYPE_QUERY_POOL => + return "VK_OBJECT_TYPE_QUERY_POOL"; + case VkObjectType::VK_OBJECT_TYPE_BUFFER_VIEW => + return "VK_OBJECT_TYPE_BUFFER_VIEW"; + case VkObjectType::VK_OBJECT_TYPE_IMAGE_VIEW => + return "VK_OBJECT_TYPE_IMAGE_VIEW"; + case VkObjectType::VK_OBJECT_TYPE_SHADER_MODULE => + return "VK_OBJECT_TYPE_SHADER_MODULE"; + case VkObjectType::VK_OBJECT_TYPE_PIPELINE_CACHE => + return "VK_OBJECT_TYPE_PIPELINE_CACHE"; + case VkObjectType::VK_OBJECT_TYPE_PIPELINE_LAYOUT => + return "VK_OBJECT_TYPE_PIPELINE_LAYOUT"; + case VkObjectType::VK_OBJECT_TYPE_RENDER_PASS => + return "VK_OBJECT_TYPE_RENDER_PASS"; + case VkObjectType::VK_OBJECT_TYPE_PIPELINE => + return "VK_OBJECT_TYPE_PIPELINE"; + case VkObjectType::VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT => + return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT"; + case VkObjectType::VK_OBJECT_TYPE_SAMPLER => + return "VK_OBJECT_TYPE_SAMPLER"; + case VkObjectType::VK_OBJECT_TYPE_DESCRIPTOR_POOL => + return "VK_OBJECT_TYPE_DESCRIPTOR_POOL"; + case VkObjectType::VK_OBJECT_TYPE_DESCRIPTOR_SET => + return "VK_OBJECT_TYPE_DESCRIPTOR_SET"; + case VkObjectType::VK_OBJECT_TYPE_FRAMEBUFFER => + return "VK_OBJECT_TYPE_FRAMEBUFFER"; + case VkObjectType::VK_OBJECT_TYPE_COMMAND_POOL => + return "VK_OBJECT_TYPE_COMMAND_POOL"; + case VkObjectType::VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION => + return "VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION"; + case VkObjectType::VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE => + return "VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE"; + case VkObjectType::VK_OBJECT_TYPE_PRIVATE_DATA_SLOT => + return "VK_OBJECT_TYPE_PRIVATE_DATA_SLOT"; + }; +}; +export type VkEventCreateFlagBits = enum u32 { + VK_EVENT_CREATE_DEVICE_ONLY_BIT = 1, +}; + +export fn StrVkEventCreateFlagBits(value: VkEventCreateFlagBits) str = { + switch (value) { + case VkEventCreateFlagBits::VK_EVENT_CREATE_DEVICE_ONLY_BIT => + return "VK_EVENT_CREATE_DEVICE_ONLY_BIT"; + }; +}; +export type VkDescriptorUpdateTemplateType = enum u32 { + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, +}; + +export fn StrVkDescriptorUpdateTemplateType(value: VkDescriptorUpdateTemplateType) str = { + switch (value) { + case VkDescriptorUpdateTemplateType::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET => + return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET"; + }; +}; +export type VkPointClippingBehavior = enum u32 { + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, +}; + +export fn StrVkPointClippingBehavior(value: VkPointClippingBehavior) str = { + switch (value) { + case VkPointClippingBehavior::VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES => + return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES"; + case VkPointClippingBehavior::VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY => + return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY"; + }; +}; +export type VkResolveModeFlagBits = enum u32 { + 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, +}; + +export fn StrVkResolveModeFlagBits(value: VkResolveModeFlagBits) str = { + switch (value) { + case VkResolveModeFlagBits::VK_RESOLVE_MODE_NONE => + return "VK_RESOLVE_MODE_NONE"; + case VkResolveModeFlagBits::VK_RESOLVE_MODE_SAMPLE_ZERO_BIT => + return "VK_RESOLVE_MODE_SAMPLE_ZERO_BIT"; + case VkResolveModeFlagBits::VK_RESOLVE_MODE_AVERAGE_BIT => + return "VK_RESOLVE_MODE_AVERAGE_BIT"; + case VkResolveModeFlagBits::VK_RESOLVE_MODE_MIN_BIT => + return "VK_RESOLVE_MODE_MIN_BIT"; + case VkResolveModeFlagBits::VK_RESOLVE_MODE_MAX_BIT => + return "VK_RESOLVE_MODE_MAX_BIT"; + }; +}; +export type VkDescriptorBindingFlagBits = enum u32 { + 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, +}; + +export fn StrVkDescriptorBindingFlagBits(value: VkDescriptorBindingFlagBits) str = { + switch (value) { + case VkDescriptorBindingFlagBits::VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT => + return "VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT"; + case VkDescriptorBindingFlagBits::VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT => + return "VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT"; + case VkDescriptorBindingFlagBits::VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT => + return "VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT"; + case VkDescriptorBindingFlagBits::VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT => + return "VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT"; + }; +}; +export type VkSemaphoreType = enum u32 { + VK_SEMAPHORE_TYPE_BINARY = 0, + VK_SEMAPHORE_TYPE_TIMELINE = 1, +}; + +export fn StrVkSemaphoreType(value: VkSemaphoreType) str = { + switch (value) { + case VkSemaphoreType::VK_SEMAPHORE_TYPE_BINARY => + return "VK_SEMAPHORE_TYPE_BINARY"; + case VkSemaphoreType::VK_SEMAPHORE_TYPE_TIMELINE => + return "VK_SEMAPHORE_TYPE_TIMELINE"; + }; +}; +export type VkPipelineCreationFeedbackFlagBits = enum u32 { + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 1, + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 1, + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 2, + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = 2, + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 4, + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 4, +}; + +export fn StrVkPipelineCreationFeedbackFlagBits(value: VkPipelineCreationFeedbackFlagBits) str = { + switch (value) { + case VkPipelineCreationFeedbackFlagBits::VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT => + return "VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT"; + case VkPipelineCreationFeedbackFlagBits::VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT => + return "VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT"; + case VkPipelineCreationFeedbackFlagBits::VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT => + return "VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT"; + case VkPipelineCreationFeedbackFlagBits::VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT => + return "VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT"; + case VkPipelineCreationFeedbackFlagBits::VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT => + return "VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT"; + case VkPipelineCreationFeedbackFlagBits::VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT => + return "VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT"; + }; +}; +export type VkSemaphoreWaitFlagBits = enum u32 { + VK_SEMAPHORE_WAIT_ANY_BIT = 1, +}; + +export fn StrVkSemaphoreWaitFlagBits(value: VkSemaphoreWaitFlagBits) str = { + switch (value) { + case VkSemaphoreWaitFlagBits::VK_SEMAPHORE_WAIT_ANY_BIT => + return "VK_SEMAPHORE_WAIT_ANY_BIT"; + }; +}; +export type VkToolPurposeFlagBits = enum u32 { + VK_TOOL_PURPOSE_VALIDATION_BIT = 1, + VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = 1, + VK_TOOL_PURPOSE_PROFILING_BIT = 2, + VK_TOOL_PURPOSE_PROFILING_BIT_EXT = 2, + VK_TOOL_PURPOSE_TRACING_BIT = 4, + VK_TOOL_PURPOSE_TRACING_BIT_EXT = 4, + VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT = 8, + VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = 8, + VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 16, + VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = 16, +}; + +export fn StrVkToolPurposeFlagBits(value: VkToolPurposeFlagBits) str = { + switch (value) { + case VkToolPurposeFlagBits::VK_TOOL_PURPOSE_VALIDATION_BIT => + return "VK_TOOL_PURPOSE_VALIDATION_BIT"; + case VkToolPurposeFlagBits::VK_TOOL_PURPOSE_VALIDATION_BIT_EXT => + return "VK_TOOL_PURPOSE_VALIDATION_BIT_EXT"; + case VkToolPurposeFlagBits::VK_TOOL_PURPOSE_PROFILING_BIT => + return "VK_TOOL_PURPOSE_PROFILING_BIT"; + case VkToolPurposeFlagBits::VK_TOOL_PURPOSE_PROFILING_BIT_EXT => + return "VK_TOOL_PURPOSE_PROFILING_BIT_EXT"; + case VkToolPurposeFlagBits::VK_TOOL_PURPOSE_TRACING_BIT => + return "VK_TOOL_PURPOSE_TRACING_BIT"; + case VkToolPurposeFlagBits::VK_TOOL_PURPOSE_TRACING_BIT_EXT => + return "VK_TOOL_PURPOSE_TRACING_BIT_EXT"; + case VkToolPurposeFlagBits::VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT => + return "VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT"; + case VkToolPurposeFlagBits::VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT => + return "VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT"; + case VkToolPurposeFlagBits::VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT => + return "VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT"; + case VkToolPurposeFlagBits::VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT => + return "VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT"; + }; +}; +export type VkAccessFlagBits2 = enum u64 { + VK_ACCESS_2_NONE = 0, + VK_ACCESS_2_NONE_KHR = 0, + VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 1, + VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 1, + VK_ACCESS_2_INDEX_READ_BIT = 2, + VK_ACCESS_2_INDEX_READ_BIT_KHR = 2, + VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 4, + VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 4, + VK_ACCESS_2_UNIFORM_READ_BIT = 8, + VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 8, + VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 16, + VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 16, + VK_ACCESS_2_SHADER_READ_BIT = 32, + VK_ACCESS_2_SHADER_READ_BIT_KHR = 32, + VK_ACCESS_2_SHADER_WRITE_BIT = 64, + VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 64, + VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 128, + VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 128, + VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 256, + VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 256, + VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 512, + VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 512, + VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 1024, + VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 1024, + VK_ACCESS_2_TRANSFER_READ_BIT = 2048, + VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 2048, + VK_ACCESS_2_TRANSFER_WRITE_BIT = 4096, + VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 4096, + VK_ACCESS_2_HOST_READ_BIT = 8192, + VK_ACCESS_2_HOST_READ_BIT_KHR = 8192, + VK_ACCESS_2_HOST_WRITE_BIT = 16384, + VK_ACCESS_2_HOST_WRITE_BIT_KHR = 16384, + VK_ACCESS_2_MEMORY_READ_BIT = 32768, + VK_ACCESS_2_MEMORY_READ_BIT_KHR = 32768, + VK_ACCESS_2_MEMORY_WRITE_BIT = 65536, + VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 65536, + VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 4294967296, + VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 4294967296, + VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 8589934592, + VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 8589934592, + VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 17179869184, + VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 17179869184, +}; + +export fn StrVkAccessFlagBits2(value: VkAccessFlagBits2) str = { + switch (value) { + case VkAccessFlagBits2::VK_ACCESS_2_NONE => + return "VK_ACCESS_2_NONE"; + case VkAccessFlagBits2::VK_ACCESS_2_NONE_KHR => + return "VK_ACCESS_2_NONE_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT => + return "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR => + return "VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_INDEX_READ_BIT => + return "VK_ACCESS_2_INDEX_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_INDEX_READ_BIT_KHR => + return "VK_ACCESS_2_INDEX_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT => + return "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR => + return "VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_UNIFORM_READ_BIT => + return "VK_ACCESS_2_UNIFORM_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_UNIFORM_READ_BIT_KHR => + return "VK_ACCESS_2_UNIFORM_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT => + return "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR => + return "VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_SHADER_READ_BIT => + return "VK_ACCESS_2_SHADER_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_SHADER_READ_BIT_KHR => + return "VK_ACCESS_2_SHADER_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_SHADER_WRITE_BIT => + return "VK_ACCESS_2_SHADER_WRITE_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_SHADER_WRITE_BIT_KHR => + return "VK_ACCESS_2_SHADER_WRITE_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT => + return "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR => + return "VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT => + return "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR => + return "VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT => + return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR => + return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT => + return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR => + return "VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_TRANSFER_READ_BIT => + return "VK_ACCESS_2_TRANSFER_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_TRANSFER_READ_BIT_KHR => + return "VK_ACCESS_2_TRANSFER_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_TRANSFER_WRITE_BIT => + return "VK_ACCESS_2_TRANSFER_WRITE_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR => + return "VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_HOST_READ_BIT => + return "VK_ACCESS_2_HOST_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_HOST_READ_BIT_KHR => + return "VK_ACCESS_2_HOST_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_HOST_WRITE_BIT => + return "VK_ACCESS_2_HOST_WRITE_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_HOST_WRITE_BIT_KHR => + return "VK_ACCESS_2_HOST_WRITE_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_MEMORY_READ_BIT => + return "VK_ACCESS_2_MEMORY_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_MEMORY_READ_BIT_KHR => + return "VK_ACCESS_2_MEMORY_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_MEMORY_WRITE_BIT => + return "VK_ACCESS_2_MEMORY_WRITE_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_MEMORY_WRITE_BIT_KHR => + return "VK_ACCESS_2_MEMORY_WRITE_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_SHADER_SAMPLED_READ_BIT => + return "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR => + return "VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_SHADER_STORAGE_READ_BIT => + return "VK_ACCESS_2_SHADER_STORAGE_READ_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR => + return "VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR"; + case VkAccessFlagBits2::VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT => + return "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT"; + case VkAccessFlagBits2::VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR => + return "VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR"; + }; +}; +export type VkPipelineStageFlagBits2 = enum u64 { + VK_PIPELINE_STAGE_2_NONE = 0, + VK_PIPELINE_STAGE_2_NONE_KHR = 0, + VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 1, + VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 1, + VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 2, + VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 2, + VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 4, + VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 4, + VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 8, + VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 8, + VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 16, + VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 16, + VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 32, + VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 32, + VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 64, + VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 64, + VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 128, + VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 128, + VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 256, + VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 256, + VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 512, + VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 512, + VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 1024, + VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 1024, + VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 2048, + VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 2048, + VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 4096, + VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 4096, + VK_PIPELINE_STAGE_2_TRANSFER_BIT = 4096, + VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 4096, + VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 8192, + VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 8192, + VK_PIPELINE_STAGE_2_HOST_BIT = 16384, + VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 16384, + VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 32768, + VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 32768, + VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 65536, + VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 65536, + VK_PIPELINE_STAGE_2_COPY_BIT = 4294967296, + VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 4294967296, + VK_PIPELINE_STAGE_2_RESOLVE_BIT = 8589934592, + VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 8589934592, + VK_PIPELINE_STAGE_2_BLIT_BIT = 17179869184, + VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 17179869184, + VK_PIPELINE_STAGE_2_CLEAR_BIT = 34359738368, + VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 34359738368, + VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 68719476736, + VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 68719476736, + VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 137438953472, + VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 137438953472, + VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 274877906944, + VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 274877906944, +}; + +export fn StrVkPipelineStageFlagBits2(value: VkPipelineStageFlagBits2) str = { + switch (value) { + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_NONE => + return "VK_PIPELINE_STAGE_2_NONE"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_NONE_KHR => + return "VK_PIPELINE_STAGE_2_NONE_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT => + return "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR => + return "VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT => + return "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR => + return "VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT => + return "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR => + return "VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT => + return "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR => + return "VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT => + return "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR => + return "VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT => + return "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR => + return "VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT => + return "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR => + return "VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT => + return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR => + return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT => + return "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR => + return "VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT => + return "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR => + return "VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT => + return "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR => + return "VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT => + return "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR => + return "VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT => + return "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR => + return "VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_TRANSFER_BIT => + return "VK_PIPELINE_STAGE_2_TRANSFER_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR => + return "VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT => + return "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR => + return "VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_HOST_BIT => + return "VK_PIPELINE_STAGE_2_HOST_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_HOST_BIT_KHR => + return "VK_PIPELINE_STAGE_2_HOST_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT => + return "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR => + return "VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT => + return "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR => + return "VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_COPY_BIT => + return "VK_PIPELINE_STAGE_2_COPY_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_COPY_BIT_KHR => + return "VK_PIPELINE_STAGE_2_COPY_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_RESOLVE_BIT => + return "VK_PIPELINE_STAGE_2_RESOLVE_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR => + return "VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_BLIT_BIT => + return "VK_PIPELINE_STAGE_2_BLIT_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_BLIT_BIT_KHR => + return "VK_PIPELINE_STAGE_2_BLIT_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_CLEAR_BIT => + return "VK_PIPELINE_STAGE_2_CLEAR_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR => + return "VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT => + return "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR => + return "VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT => + return "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR => + return "VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT => + return "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT"; + case VkPipelineStageFlagBits2::VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR => + return "VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR"; + }; +}; +export type VkFormatFeatureFlagBits2 = enum u64 { + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 1, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 1, + VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 2, + VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 2, + VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 4, + VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 4, + VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 8, + VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 8, + VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 16, + VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 16, + VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 32, + VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 32, + VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 64, + VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 64, + VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 128, + VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 128, + VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 256, + VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 256, + VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 512, + VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 512, + VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 1024, + VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 1024, + VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 2048, + VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 2048, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4096, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 4096, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 8192, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 8192, + VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 16384, + VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 16384, + VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 32768, + VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 32768, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 65536, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 65536, + VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 131072, + VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 131072, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 262144, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 262144, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 524288, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 524288, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 1048576, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 1048576, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 2097152, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 2097152, + VK_FORMAT_FEATURE_2_DISJOINT_BIT = 4194304, + VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 4194304, + VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 8388608, + VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 8388608, + VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 2147483648, + VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 2147483648, + VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 4294967296, + VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 4294967296, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 8589934592, + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 8589934592, +}; + +export fn StrVkFormatFeatureFlagBits2(value: VkFormatFeatureFlagBits2) str = { + switch (value) { + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT => + return "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR => + return "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT => + return "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR => + return "VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT => + return "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR => + return "VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT => + return "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR => + return "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT => + return "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR => + return "VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT => + return "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR => + return "VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT => + return "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR => + return "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT => + return "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR => + return "VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT => + return "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR => + return "VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_BLIT_SRC_BIT => + return "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR => + return "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_BLIT_DST_BIT => + return "VK_FORMAT_FEATURE_2_BLIT_DST_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR => + return "VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT => + return "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR => + return "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT => + return "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR => + return "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT => + return "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR => + return "VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_DISJOINT_BIT => + return "VK_FORMAT_FEATURE_2_DISJOINT_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR => + return "VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT => + return "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR => + return "VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT => + return "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR => + return "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT => + return "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR => + return "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT"; + case VkFormatFeatureFlagBits2::VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR => + return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR"; + }; +}; +export type VkRenderingFlagBits = enum u32 { + VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 1, + VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = 1, + VK_RENDERING_SUSPENDING_BIT = 2, + VK_RENDERING_SUSPENDING_BIT_KHR = 2, + VK_RENDERING_RESUMING_BIT = 4, + VK_RENDERING_RESUMING_BIT_KHR = 4, +}; + +export fn StrVkRenderingFlagBits(value: VkRenderingFlagBits) str = { + switch (value) { + case VkRenderingFlagBits::VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT => + return "VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT"; + case VkRenderingFlagBits::VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR => + return "VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR"; + case VkRenderingFlagBits::VK_RENDERING_SUSPENDING_BIT => + return "VK_RENDERING_SUSPENDING_BIT"; + case VkRenderingFlagBits::VK_RENDERING_SUSPENDING_BIT_KHR => + return "VK_RENDERING_SUSPENDING_BIT_KHR"; + case VkRenderingFlagBits::VK_RENDERING_RESUMING_BIT => + return "VK_RENDERING_RESUMING_BIT"; + case VkRenderingFlagBits::VK_RENDERING_RESUMING_BIT_KHR => + return "VK_RENDERING_RESUMING_BIT_KHR"; + }; +}; +export type VkExternalMemoryHandleTypeFlagBits = enum u32 { + 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, +}; + +export fn StrVkExternalMemoryHandleTypeFlagBits(value: VkExternalMemoryHandleTypeFlagBits) str = { + switch (value) { + case VkExternalMemoryHandleTypeFlagBits::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT => + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"; + case VkExternalMemoryHandleTypeFlagBits::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT => + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT"; + case VkExternalMemoryHandleTypeFlagBits::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT => + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; + case VkExternalMemoryHandleTypeFlagBits::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT => + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT"; + case VkExternalMemoryHandleTypeFlagBits::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT => + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT"; + case VkExternalMemoryHandleTypeFlagBits::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT => + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT"; + case VkExternalMemoryHandleTypeFlagBits::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT => + return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT"; + }; +}; +export type VkExternalMemoryFeatureFlagBits = enum u32 { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4, +}; + +export fn StrVkExternalMemoryFeatureFlagBits(value: VkExternalMemoryFeatureFlagBits) str = { + switch (value) { + case VkExternalMemoryFeatureFlagBits::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT => + return "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT"; + case VkExternalMemoryFeatureFlagBits::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT => + return "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT"; + case VkExternalMemoryFeatureFlagBits::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT => + return "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT"; + }; +}; +export type VkExternalSemaphoreHandleTypeFlagBits = enum u32 { + 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_D3D11_FENCE_BIT = 8, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 16, +}; + +export fn StrVkExternalSemaphoreHandleTypeFlagBits(value: VkExternalSemaphoreHandleTypeFlagBits) str = { + switch (value) { + case VkExternalSemaphoreHandleTypeFlagBits::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT => + return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT"; + case VkExternalSemaphoreHandleTypeFlagBits::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT => + return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT"; + case VkExternalSemaphoreHandleTypeFlagBits::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT => + return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; + case VkExternalSemaphoreHandleTypeFlagBits::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT => + return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"; + case VkExternalSemaphoreHandleTypeFlagBits::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT => + return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT"; + case VkExternalSemaphoreHandleTypeFlagBits::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT => + return "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT"; + }; +}; +export type VkExternalSemaphoreFeatureFlagBits = enum u32 { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2, +}; + +export fn StrVkExternalSemaphoreFeatureFlagBits(value: VkExternalSemaphoreFeatureFlagBits) str = { + switch (value) { + case VkExternalSemaphoreFeatureFlagBits::VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT => + return "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT"; + case VkExternalSemaphoreFeatureFlagBits::VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT => + return "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT"; + }; +}; +export type VkSemaphoreImportFlagBits = enum u32 { + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1, +}; + +export fn StrVkSemaphoreImportFlagBits(value: VkSemaphoreImportFlagBits) str = { + switch (value) { + case VkSemaphoreImportFlagBits::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT => + return "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT"; + }; +}; +export type VkExternalFenceHandleTypeFlagBits = enum u32 { + 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, +}; + +export fn StrVkExternalFenceHandleTypeFlagBits(value: VkExternalFenceHandleTypeFlagBits) str = { + switch (value) { + case VkExternalFenceHandleTypeFlagBits::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT => + return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT"; + case VkExternalFenceHandleTypeFlagBits::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT => + return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT"; + case VkExternalFenceHandleTypeFlagBits::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT => + return "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"; + case VkExternalFenceHandleTypeFlagBits::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT => + return "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT"; + }; +}; +export type VkExternalFenceFeatureFlagBits = enum u32 { + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2, +}; + +export fn StrVkExternalFenceFeatureFlagBits(value: VkExternalFenceFeatureFlagBits) str = { + switch (value) { + case VkExternalFenceFeatureFlagBits::VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT => + return "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT"; + case VkExternalFenceFeatureFlagBits::VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT => + return "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT"; + }; +}; +export type VkFenceImportFlagBits = enum u32 { + VK_FENCE_IMPORT_TEMPORARY_BIT = 1, +}; + +export fn StrVkFenceImportFlagBits(value: VkFenceImportFlagBits) str = { + switch (value) { + case VkFenceImportFlagBits::VK_FENCE_IMPORT_TEMPORARY_BIT => + return "VK_FENCE_IMPORT_TEMPORARY_BIT"; + }; +}; +export type VkPeerMemoryFeatureFlagBits = enum u32 { + 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, +}; + +export fn StrVkPeerMemoryFeatureFlagBits(value: VkPeerMemoryFeatureFlagBits) str = { + switch (value) { + case VkPeerMemoryFeatureFlagBits::VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT => + return "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT"; + case VkPeerMemoryFeatureFlagBits::VK_PEER_MEMORY_FEATURE_COPY_DST_BIT => + return "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT"; + case VkPeerMemoryFeatureFlagBits::VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT => + return "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT"; + case VkPeerMemoryFeatureFlagBits::VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT => + return "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT"; + }; +}; +export type VkMemoryAllocateFlagBits = enum u32 { + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 2, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 4, +}; + +export fn StrVkMemoryAllocateFlagBits(value: VkMemoryAllocateFlagBits) str = { + switch (value) { + case VkMemoryAllocateFlagBits::VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT => + return "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"; + case VkMemoryAllocateFlagBits::VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT => + return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT"; + case VkMemoryAllocateFlagBits::VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT => + return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"; + }; +}; +export type VkSubgroupFeatureFlagBits = enum u32 { + 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, +}; + +export fn StrVkSubgroupFeatureFlagBits(value: VkSubgroupFeatureFlagBits) str = { + switch (value) { + case VkSubgroupFeatureFlagBits::VK_SUBGROUP_FEATURE_BASIC_BIT => + return "VK_SUBGROUP_FEATURE_BASIC_BIT"; + case VkSubgroupFeatureFlagBits::VK_SUBGROUP_FEATURE_VOTE_BIT => + return "VK_SUBGROUP_FEATURE_VOTE_BIT"; + case VkSubgroupFeatureFlagBits::VK_SUBGROUP_FEATURE_ARITHMETIC_BIT => + return "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT"; + case VkSubgroupFeatureFlagBits::VK_SUBGROUP_FEATURE_BALLOT_BIT => + return "VK_SUBGROUP_FEATURE_BALLOT_BIT"; + case VkSubgroupFeatureFlagBits::VK_SUBGROUP_FEATURE_SHUFFLE_BIT => + return "VK_SUBGROUP_FEATURE_SHUFFLE_BIT"; + case VkSubgroupFeatureFlagBits::VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT => + return "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT"; + case VkSubgroupFeatureFlagBits::VK_SUBGROUP_FEATURE_CLUSTERED_BIT => + return "VK_SUBGROUP_FEATURE_CLUSTERED_BIT"; + case VkSubgroupFeatureFlagBits::VK_SUBGROUP_FEATURE_QUAD_BIT => + return "VK_SUBGROUP_FEATURE_QUAD_BIT"; + }; +}; +export type VkTessellationDomainOrigin = enum u32 { + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, +}; + +export fn StrVkTessellationDomainOrigin(value: VkTessellationDomainOrigin) str = { + switch (value) { + case VkTessellationDomainOrigin::VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT => + return "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT"; + case VkTessellationDomainOrigin::VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT => + return "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT"; + }; +}; +export type VkSamplerYcbcrModelConversion = enum u32 { + 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, +}; + +export fn StrVkSamplerYcbcrModelConversion(value: VkSamplerYcbcrModelConversion) str = { + switch (value) { + case VkSamplerYcbcrModelConversion::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY => + return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY"; + case VkSamplerYcbcrModelConversion::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY => + return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY"; + case VkSamplerYcbcrModelConversion::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 => + return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709"; + case VkSamplerYcbcrModelConversion::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 => + return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601"; + case VkSamplerYcbcrModelConversion::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 => + return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020"; + }; +}; +export type VkSamplerYcbcrRange = enum u32 { + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, +}; + +export fn StrVkSamplerYcbcrRange(value: VkSamplerYcbcrRange) str = { + switch (value) { + case VkSamplerYcbcrRange::VK_SAMPLER_YCBCR_RANGE_ITU_FULL => + return "VK_SAMPLER_YCBCR_RANGE_ITU_FULL"; + case VkSamplerYcbcrRange::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW => + return "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW"; + }; +}; +export type VkChromaLocation = enum u32 { + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, +}; + +export fn StrVkChromaLocation(value: VkChromaLocation) str = { + switch (value) { + case VkChromaLocation::VK_CHROMA_LOCATION_COSITED_EVEN => + return "VK_CHROMA_LOCATION_COSITED_EVEN"; + case VkChromaLocation::VK_CHROMA_LOCATION_MIDPOINT => + return "VK_CHROMA_LOCATION_MIDPOINT"; + }; +}; +export type VkSamplerReductionMode = enum u32 { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, + VK_SAMPLER_REDUCTION_MODE_MIN = 1, + VK_SAMPLER_REDUCTION_MODE_MAX = 2, +}; + +export fn StrVkSamplerReductionMode(value: VkSamplerReductionMode) str = { + switch (value) { + case VkSamplerReductionMode::VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE => + return "VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE"; + case VkSamplerReductionMode::VK_SAMPLER_REDUCTION_MODE_MIN => + return "VK_SAMPLER_REDUCTION_MODE_MIN"; + case VkSamplerReductionMode::VK_SAMPLER_REDUCTION_MODE_MAX => + return "VK_SAMPLER_REDUCTION_MODE_MAX"; + }; +}; +export type VkShaderFloatControlsIndependence = enum u32 { + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, +}; + +export fn StrVkShaderFloatControlsIndependence(value: VkShaderFloatControlsIndependence) str = { + switch (value) { + case VkShaderFloatControlsIndependence::VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY => + return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY"; + case VkShaderFloatControlsIndependence::VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL => + return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL"; + case VkShaderFloatControlsIndependence::VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE => + return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE"; + }; +}; +export type VkSubmitFlagBits = enum u32 { + VK_SUBMIT_PROTECTED_BIT = 1, + VK_SUBMIT_PROTECTED_BIT_KHR = 1, +}; + +export fn StrVkSubmitFlagBits(value: VkSubmitFlagBits) str = { + switch (value) { + case VkSubmitFlagBits::VK_SUBMIT_PROTECTED_BIT => + return "VK_SUBMIT_PROTECTED_BIT"; + case VkSubmitFlagBits::VK_SUBMIT_PROTECTED_BIT_KHR => + return "VK_SUBMIT_PROTECTED_BIT_KHR"; + }; +}; +export type VkVendorId = enum u32 { + VK_VENDOR_ID_VIV = 0x10001, + VK_VENDOR_ID_VSI = 0x10002, + VK_VENDOR_ID_KAZAN = 0x10003, + VK_VENDOR_ID_CODEPLAY = 0x10004, + VK_VENDOR_ID_MESA = 0x10005, + VK_VENDOR_ID_POCL = 0x10006, +}; + +export fn StrVkVendorId(value: VkVendorId) str = { + switch (value) { + case VkVendorId::VK_VENDOR_ID_VIV => + return "VK_VENDOR_ID_VIV"; + case VkVendorId::VK_VENDOR_ID_VSI => + return "VK_VENDOR_ID_VSI"; + case VkVendorId::VK_VENDOR_ID_KAZAN => + return "VK_VENDOR_ID_KAZAN"; + case VkVendorId::VK_VENDOR_ID_CODEPLAY => + return "VK_VENDOR_ID_CODEPLAY"; + case VkVendorId::VK_VENDOR_ID_MESA => + return "VK_VENDOR_ID_MESA"; + case VkVendorId::VK_VENDOR_ID_POCL => + return "VK_VENDOR_ID_POCL"; + }; +}; +export type VkDriverId = enum u32 { + 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, + VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, + VK_DRIVER_ID_JUICE_PROPRIETARY = 16, + VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, + VK_DRIVER_ID_MESA_TURNIP = 18, + VK_DRIVER_ID_MESA_V3DV = 19, + VK_DRIVER_ID_MESA_PANVK = 20, + VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, + VK_DRIVER_ID_MESA_VENUS = 22, +}; + +export fn StrVkDriverId(value: VkDriverId) str = { + switch (value) { + case VkDriverId::VK_DRIVER_ID_AMD_PROPRIETARY => + return "VK_DRIVER_ID_AMD_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_AMD_OPEN_SOURCE => + return "VK_DRIVER_ID_AMD_OPEN_SOURCE"; + case VkDriverId::VK_DRIVER_ID_MESA_RADV => + return "VK_DRIVER_ID_MESA_RADV"; + case VkDriverId::VK_DRIVER_ID_NVIDIA_PROPRIETARY => + return "VK_DRIVER_ID_NVIDIA_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS => + return "VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS"; + case VkDriverId::VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA => + return "VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA"; + case VkDriverId::VK_DRIVER_ID_IMAGINATION_PROPRIETARY => + return "VK_DRIVER_ID_IMAGINATION_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_QUALCOMM_PROPRIETARY => + return "VK_DRIVER_ID_QUALCOMM_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_ARM_PROPRIETARY => + return "VK_DRIVER_ID_ARM_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_GOOGLE_SWIFTSHADER => + return "VK_DRIVER_ID_GOOGLE_SWIFTSHADER"; + case VkDriverId::VK_DRIVER_ID_GGP_PROPRIETARY => + return "VK_DRIVER_ID_GGP_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_BROADCOM_PROPRIETARY => + return "VK_DRIVER_ID_BROADCOM_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_MESA_LLVMPIPE => + return "VK_DRIVER_ID_MESA_LLVMPIPE"; + case VkDriverId::VK_DRIVER_ID_MOLTENVK => + return "VK_DRIVER_ID_MOLTENVK"; + case VkDriverId::VK_DRIVER_ID_COREAVI_PROPRIETARY => + return "VK_DRIVER_ID_COREAVI_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_JUICE_PROPRIETARY => + return "VK_DRIVER_ID_JUICE_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_VERISILICON_PROPRIETARY => + return "VK_DRIVER_ID_VERISILICON_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_MESA_TURNIP => + return "VK_DRIVER_ID_MESA_TURNIP"; + case VkDriverId::VK_DRIVER_ID_MESA_V3DV => + return "VK_DRIVER_ID_MESA_V3DV"; + case VkDriverId::VK_DRIVER_ID_MESA_PANVK => + return "VK_DRIVER_ID_MESA_PANVK"; + case VkDriverId::VK_DRIVER_ID_SAMSUNG_PROPRIETARY => + return "VK_DRIVER_ID_SAMSUNG_PROPRIETARY"; + case VkDriverId::VK_DRIVER_ID_MESA_VENUS => + return "VK_DRIVER_ID_MESA_VENUS"; + }; +}; +export type PFN_vkInternalAllocationNotification = nullable *fn( + pUserData: nullable *void, + size_: size, + allocationType: VkInternalAllocationType, + allocationScope: VkSystemAllocationScope, +) void; +export type PFN_vkInternalFreeNotification = nullable *fn( + pUserData: nullable *void, + size_: size, + allocationType: VkInternalAllocationType, + allocationScope: VkSystemAllocationScope, +) void; +export type PFN_vkReallocationFunction = nullable *fn( + pUserData: nullable *void, + pOriginal: nullable *void, + size_: size, + alignment: size, + allocationScope: VkSystemAllocationScope, +) nullable *void; +export type PFN_vkAllocationFunction = nullable *fn( + pUserData: nullable *void, + size_: size, + alignment: size, + allocationScope: VkSystemAllocationScope, +) nullable *void; +export type PFN_vkFreeFunction = nullable *fn( + pUserData: nullable *void, + pMemory: nullable *void, +) void; +export type PFN_vkVoidFunction = nullable *fn( +) void; +export type VkBaseOutStructure = struct { + sType: VkStructureType, + pNext: nullable *VkBaseOutStructure, +}; + +export type VkBaseInStructure = struct { + sType: VkStructureType, + pNext: nullable *const VkBaseInStructure, +}; + +export type VkOffset2D = struct { + x: i32, + y: i32, +}; + +export type VkOffset3D = struct { + x: i32, + y: i32, + z: i32, +}; + +export type VkExtent2D = struct { + width: u32, + height: u32, +}; + +export type VkExtent3D = struct { + width: u32, + height: u32, + depth: u32, +}; + +export type VkViewport = struct { + x: f32, + y: f32, + width: f32, + height: f32, + minDepth: f32, + maxDepth: f32, +}; + +export type VkRect2D = struct { + offset_: VkOffset2D, + extent: VkExtent2D, +}; + +export type VkClearRect = struct { + rect: VkRect2D, + baseArrayLayer: u32, + layerCount: u32, +}; + +export type VkComponentMapping = struct { + r: VkComponentSwizzle, + g: VkComponentSwizzle, + b: VkComponentSwizzle, + a: VkComponentSwizzle, +}; + +export type VkExtensionProperties = struct { + extensionName: [VK_MAX_EXTENSION_NAME_SIZE]char, + specVersion: u32, +}; + +export type VkLayerProperties = struct { + layerName: [VK_MAX_EXTENSION_NAME_SIZE]char, + specVersion: u32, + implementationVersion: u32, + description: [VK_MAX_DESCRIPTION_SIZE]char, +}; + +export type VkApplicationInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + pApplicationName: nullable *const char, + applicationVersion: u32, + pEngineName: nullable *const char, + engineVersion: u32, + apiVersion: u32, +}; + +export type VkAllocationCallbacks = struct { + pUserData: nullable *void, + pfnAllocation: PFN_vkAllocationFunction, + pfnReallocation: PFN_vkReallocationFunction, + pfnFree: PFN_vkFreeFunction, + pfnInternalAllocation: PFN_vkInternalAllocationNotification, + pfnInternalFree: PFN_vkInternalFreeNotification, +}; + +export type VkDescriptorImageInfo = struct { + sampler: VkSampler, + imageView: VkImageView, + imageLayout: VkImageLayout, +}; + +export type VkCopyDescriptorSet = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcSet: VkDescriptorSet, + srcBinding: u32, + srcArrayElement: u32, + dstSet: VkDescriptorSet, + dstBinding: u32, + dstArrayElement: u32, + descriptorCount: u32, +}; + +export type VkDescriptorPoolSize = struct { + type_: VkDescriptorType, + descriptorCount: u32, +}; + +export type VkDescriptorSetAllocateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + descriptorPool: VkDescriptorPool, + descriptorSetCount: u32, + pSetLayouts: nullable *const VkDescriptorSetLayout, +}; + +export type VkSpecializationMapEntry = struct { + constantID: u32, + offset_: u32, + size_: size, +}; + +export type VkSpecializationInfo = struct { + mapEntryCount: u32, + pMapEntries: nullable *const VkSpecializationMapEntry, + dataSize: size, + pData: nullable *const void, +}; + +export type VkVertexInputBindingDescription = struct { + binding: u32, + stride: u32, + inputRate: VkVertexInputRate, +}; + +export type VkVertexInputAttributeDescription = struct { + location: u32, + binding: u32, + format: VkFormat, + offset_: u32, +}; + +export type VkStencilOpState = struct { + failOp: VkStencilOp, + passOp: VkStencilOp, + depthFailOp: VkStencilOp, + compareOp: VkCompareOp, + compareMask: u32, + writeMask: u32, + reference: u32, +}; + +export type VkPipelineCacheHeaderVersionOne = struct { + headerSize: u32, + headerVersion: VkPipelineCacheHeaderVersion, + vendorID: u32, + deviceID: u32, + pipelineCacheUUID: [VK_UUID_SIZE]u8, +}; + +export type VkCommandBufferAllocateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + commandPool: VkCommandPool, + level: VkCommandBufferLevel, + commandBufferCount: u32, +}; + +export type VkClearColorValue = union { + float32: [4]f32, + int32: [4]i32, + uint32: [4]u32, +}; + +export type VkClearDepthStencilValue = struct { + depth: f32, + stencil: u32, +}; + +export type VkClearValue = union { + color: VkClearColorValue, + depthStencil: VkClearDepthStencilValue, +}; + +export type VkAttachmentReference = struct { + attachment: u32, + layout: VkImageLayout, +}; + +export type VkDrawIndirectCommand = struct { + vertexCount: u32, + instanceCount: u32, + firstVertex: u32, + firstInstance: u32, +}; + +export type VkDrawIndexedIndirectCommand = struct { + indexCount: u32, + instanceCount: u32, + firstIndex: u32, + vertexOffset: i32, + firstInstance: u32, +}; + +export type VkDispatchIndirectCommand = struct { + x: u32, + y: u32, + z: u32, +}; + +export type VkDevicePrivateDataCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + privateDataSlotRequestCount: u32, +}; + +export type VkConformanceVersion = struct { + major: u8, + minor: u8, + subminor: u8, + patch: u8, +}; + +export type VkPhysicalDeviceDriverProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + driverID: VkDriverId, + driverName: [VK_MAX_DRIVER_NAME_SIZE]char, + driverInfo: [VK_MAX_DRIVER_INFO_SIZE]char, + conformanceVersion: VkConformanceVersion, +}; + +export type VkPhysicalDeviceExternalImageFormatInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + handleType: VkExternalMemoryHandleTypeFlagBits, +}; + +export type VkPhysicalDeviceExternalSemaphoreInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + handleType: VkExternalSemaphoreHandleTypeFlagBits, +}; + +export type VkPhysicalDeviceExternalFenceInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + handleType: VkExternalFenceHandleTypeFlagBits, +}; + +export type VkPhysicalDeviceMultiviewProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + maxMultiviewViewCount: u32, + maxMultiviewInstanceIndex: u32, +}; + +export type VkRenderPassMultiviewCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + subpassCount: u32, + pViewMasks: nullable *const u32, + dependencyCount: u32, + pViewOffsets: nullable *const i32, + correlationMaskCount: u32, + pCorrelationMasks: nullable *const u32, +}; + +export type VkBindBufferMemoryDeviceGroupInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + deviceIndexCount: u32, + pDeviceIndices: nullable *const u32, +}; + +export type VkBindImageMemoryDeviceGroupInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + deviceIndexCount: u32, + pDeviceIndices: nullable *const u32, + splitInstanceBindRegionCount: u32, + pSplitInstanceBindRegions: nullable *const VkRect2D, +}; + +export type VkDeviceGroupRenderPassBeginInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + deviceMask: u32, + deviceRenderAreaCount: u32, + pDeviceRenderAreas: nullable *const VkRect2D, +}; + +export type VkDeviceGroupCommandBufferBeginInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + deviceMask: u32, +}; + +export type VkDeviceGroupSubmitInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + waitSemaphoreCount: u32, + pWaitSemaphoreDeviceIndices: nullable *const u32, + commandBufferCount: u32, + pCommandBufferDeviceMasks: nullable *const u32, + signalSemaphoreCount: u32, + pSignalSemaphoreDeviceIndices: nullable *const u32, +}; + +export type VkDeviceGroupBindSparseInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + resourceDeviceIndex: u32, + memoryDeviceIndex: u32, +}; + +export type VkDeviceGroupDeviceCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + physicalDeviceCount: u32, + pPhysicalDevices: nullable *const VkPhysicalDevice, +}; + +export type VkDescriptorUpdateTemplateEntry = struct { + dstBinding: u32, + dstArrayElement: u32, + descriptorCount: u32, + descriptorType: VkDescriptorType, + offset_: size, + stride: size, +}; + +export type VkBufferMemoryRequirementsInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + buffer: VkBuffer, +}; + +export type VkImageMemoryRequirementsInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + image: VkImage, +}; + +export type VkImageSparseMemoryRequirementsInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + image: VkImage, +}; + +export type VkPhysicalDevicePointClippingProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + pointClippingBehavior: VkPointClippingBehavior, +}; + +export type VkMemoryDedicatedAllocateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + image: VkImage, + buffer: VkBuffer, +}; + +export type VkPipelineTessellationDomainOriginStateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + domainOrigin: VkTessellationDomainOrigin, +}; + +export type VkSamplerYcbcrConversionInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + conversion: VkSamplerYcbcrConversion, +}; + +export type VkBindImagePlaneMemoryInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + planeAspect: VkImageAspectFlagBits, +}; + +export type VkImagePlaneMemoryRequirementsInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + planeAspect: VkImageAspectFlagBits, +}; + +export type VkSamplerYcbcrConversionImageFormatProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + combinedImageSamplerDescriptorCount: u32, +}; + +export type VkSamplerReductionModeCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + reductionMode: VkSamplerReductionMode, +}; + +export type VkPhysicalDeviceInlineUniformBlockProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + maxInlineUniformBlockSize: u32, + maxPerStageDescriptorInlineUniformBlocks: u32, + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32, + maxDescriptorSetInlineUniformBlocks: u32, + maxDescriptorSetUpdateAfterBindInlineUniformBlocks: u32, +}; + +export type VkWriteDescriptorSetInlineUniformBlock = struct { + sType: VkStructureType, + pNext: nullable *const void, + dataSize: u32, + pData: nullable *const void, +}; + +export type VkDescriptorPoolInlineUniformBlockCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + maxInlineUniformBlockBindings: u32, +}; + +export type VkImageFormatListCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + viewFormatCount: u32, + pViewFormats: nullable *const VkFormat, +}; + +export type VkDescriptorSetVariableDescriptorCountAllocateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + descriptorSetCount: u32, + pDescriptorCounts: nullable *const u32, +}; + +export type VkDescriptorSetVariableDescriptorCountLayoutSupport = struct { + sType: VkStructureType, + pNext: nullable *void, + maxVariableDescriptorCount: u32, +}; + +export type VkSubpassBeginInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + contents: VkSubpassContents, +}; + +export type VkSubpassEndInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, +}; + +export type VkPhysicalDeviceTimelineSemaphoreProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + maxTimelineSemaphoreValueDifference: u64, +}; + +export type VkSemaphoreTypeCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + semaphoreType: VkSemaphoreType, + initialValue: u64, +}; + +export type VkTimelineSemaphoreSubmitInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + waitSemaphoreValueCount: u32, + pWaitSemaphoreValues: nullable *const u64, + signalSemaphoreValueCount: u32, + pSignalSemaphoreValues: nullable *const u64, +}; + +export type VkSemaphoreSignalInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + semaphore: VkSemaphore, + value: u64, +}; + +export type VkBufferDeviceAddressInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + buffer: VkBuffer, +}; + +export type VkBufferOpaqueCaptureAddressCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + opaqueCaptureAddress: u64, +}; + +export type VkRenderPassAttachmentBeginInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + attachmentCount: u32, + pAttachments: nullable *const VkImageView, +}; + +export type VkAttachmentReferenceStencilLayout = struct { + sType: VkStructureType, + pNext: nullable *void, + stencilLayout: VkImageLayout, +}; + +export type VkAttachmentDescriptionStencilLayout = struct { + sType: VkStructureType, + pNext: nullable *void, + stencilInitialLayout: VkImageLayout, + stencilFinalLayout: VkImageLayout, +}; + +export type VkPipelineShaderStageRequiredSubgroupSizeCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *void, + requiredSubgroupSize: u32, +}; + +export type VkMemoryOpaqueCaptureAddressAllocateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + opaqueCaptureAddress: u64, +}; + +export type VkDeviceMemoryOpaqueCaptureAddressInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + memory: VkDeviceMemory, +}; + +export type VkCommandBufferSubmitInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + commandBuffer: VkCommandBuffer, + deviceMask: u32, +}; + +export type VkPipelineRenderingCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + viewMask: u32, + colorAttachmentCount: u32, + pColorAttachmentFormats: nullable *const VkFormat, + depthAttachmentFormat: VkFormat, + stencilAttachmentFormat: VkFormat, +}; + +export type VkRenderingAttachmentInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + imageView: VkImageView, + imageLayout: VkImageLayout, + resolveMode: VkResolveModeFlagBits, + resolveImageView: VkImageView, + resolveImageLayout: VkImageLayout, + loadOp: VkAttachmentLoadOp, + storeOp: VkAttachmentStoreOp, + clearValue: VkClearValue, +}; + +export type VkSampleMask = u32; +export type VkBool32 = u32; +export type VkFlags = u32; +export type VkFlags64 = u64; +export type VkDeviceSize = u64; +export type VkDeviceAddress = u64; +export type VkFramebufferCreateFlags = VkFlags; +export type VkQueryPoolCreateFlags = VkFlags; +export type VkRenderPassCreateFlags = VkFlags; +export type VkSamplerCreateFlags = VkFlags; +export type VkPipelineLayoutCreateFlags = VkFlags; +export type VkPipelineCacheCreateFlags = VkFlags; +export type VkPipelineDepthStencilStateCreateFlags = VkFlags; +export type VkPipelineDynamicStateCreateFlags = VkFlags; +export type VkPipelineColorBlendStateCreateFlags = VkFlags; +export type VkPipelineMultisampleStateCreateFlags = VkFlags; +export type VkPipelineRasterizationStateCreateFlags = VkFlags; +export type VkPipelineViewportStateCreateFlags = VkFlags; +export type VkPipelineTessellationStateCreateFlags = VkFlags; +export type VkPipelineInputAssemblyStateCreateFlags = VkFlags; +export type VkPipelineVertexInputStateCreateFlags = VkFlags; +export type VkPipelineShaderStageCreateFlags = VkFlags; +export type VkDescriptorSetLayoutCreateFlags = VkFlags; +export type VkBufferViewCreateFlags = VkFlags; +export type VkInstanceCreateFlags = VkFlags; +export type VkDeviceCreateFlags = VkFlags; +export type VkDeviceQueueCreateFlags = VkFlags; +export type VkQueueFlags = VkFlags; +export type VkMemoryPropertyFlags = VkFlags; +export type VkMemoryHeapFlags = VkFlags; +export type VkAccessFlags = VkFlags; +export type VkBufferUsageFlags = VkFlags; +export type VkBufferCreateFlags = VkFlags; +export type VkShaderStageFlags = VkFlags; +export type VkImageUsageFlags = VkFlags; +export type VkImageCreateFlags = VkFlags; +export type VkImageViewCreateFlags = VkFlags; +export type VkPipelineCreateFlags = VkFlags; +export type VkColorComponentFlags = VkFlags; +export type VkFenceCreateFlags = VkFlags; +export type VkSemaphoreCreateFlags = VkFlags; +export type VkFormatFeatureFlags = VkFlags; +export type VkQueryControlFlags = VkFlags; +export type VkQueryResultFlags = VkFlags; +export type VkShaderModuleCreateFlags = VkFlags; +export type VkEventCreateFlags = VkFlags; +export type VkCommandPoolCreateFlags = VkFlags; +export type VkCommandPoolResetFlags = VkFlags; +export type VkCommandBufferResetFlags = VkFlags; +export type VkCommandBufferUsageFlags = VkFlags; +export type VkQueryPipelineStatisticFlags = VkFlags; +export type VkMemoryMapFlags = VkFlags; +export type VkImageAspectFlags = VkFlags; +export type VkSparseMemoryBindFlags = VkFlags; +export type VkSparseImageFormatFlags = VkFlags; +export type VkSubpassDescriptionFlags = VkFlags; +export type VkPipelineStageFlags = VkFlags; +export type VkSampleCountFlags = VkFlags; +export type VkAttachmentDescriptionFlags = VkFlags; +export type VkStencilFaceFlags = VkFlags; +export type VkCullModeFlags = VkFlags; +export type VkDescriptorPoolCreateFlags = VkFlags; +export type VkDescriptorPoolResetFlags = VkFlags; +export type VkDependencyFlags = VkFlags; +export type VkSubgroupFeatureFlags = VkFlags; +export type VkPrivateDataSlotCreateFlags = VkFlags; +export type VkDescriptorUpdateTemplateCreateFlags = VkFlags; +export type VkPipelineCreationFeedbackFlags = VkFlags; +export type VkSemaphoreWaitFlags = VkFlags; +export type VkAccessFlags2 = VkFlags64; +export type VkPipelineStageFlags2 = VkFlags64; +export type VkFormatFeatureFlags2 = VkFlags64; +export type VkRenderingFlags = VkFlags; +export type VkPeerMemoryFeatureFlags = VkFlags; +export type VkMemoryAllocateFlags = VkFlags; +export type VkCommandPoolTrimFlags = VkFlags; +export type VkExternalMemoryHandleTypeFlags = VkFlags; +export type VkExternalMemoryFeatureFlags = VkFlags; +export type VkExternalSemaphoreHandleTypeFlags = VkFlags; +export type VkExternalSemaphoreFeatureFlags = VkFlags; +export type VkSemaphoreImportFlags = VkFlags; +export type VkExternalFenceHandleTypeFlags = VkFlags; +export type VkExternalFenceFeatureFlags = VkFlags; +export type VkFenceImportFlags = VkFlags; +export type VkDescriptorBindingFlags = VkFlags; +export type VkResolveModeFlags = VkFlags; +export type VkToolPurposeFlags = VkFlags; +export type VkSubmitFlags = VkFlags; +export type VkDeviceQueueCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkDeviceQueueCreateFlags, + queueFamilyIndex: u32, + queueCount: u32, + pQueuePriorities: nullable *const f32, +}; + +export type VkInstanceCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkInstanceCreateFlags, + pApplicationInfo: nullable *const VkApplicationInfo, + enabledLayerCount: u32, + ppEnabledLayerNames: nullable *const nullable *const char, + enabledExtensionCount: u32, + ppEnabledExtensionNames: nullable *const nullable *const char, +}; + +export type VkQueueFamilyProperties = struct { + queueFlags: VkQueueFlags, + queueCount: u32, + timestampValidBits: u32, + minImageTransferGranularity: VkExtent3D, +}; + +export type VkMemoryAllocateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + allocationSize: VkDeviceSize, + memoryTypeIndex: u32, +}; + +export type VkMemoryRequirements = struct { + size_: VkDeviceSize, + alignment: VkDeviceSize, + memoryTypeBits: u32, +}; + +export type VkSparseImageFormatProperties = struct { + aspectMask: VkImageAspectFlags, + imageGranularity: VkExtent3D, + flags: VkSparseImageFormatFlags, +}; + +export type VkSparseImageMemoryRequirements = struct { + formatProperties: VkSparseImageFormatProperties, + imageMipTailFirstLod: u32, + imageMipTailSize: VkDeviceSize, + imageMipTailOffset: VkDeviceSize, + imageMipTailStride: VkDeviceSize, +}; + +export type VkMemoryType = struct { + propertyFlags: VkMemoryPropertyFlags, + heapIndex: u32, +}; + +export type VkMemoryHeap = struct { + size_: VkDeviceSize, + flags: VkMemoryHeapFlags, +}; + +export type VkMappedMemoryRange = struct { + sType: VkStructureType, + pNext: nullable *const void, + memory: VkDeviceMemory, + offset_: VkDeviceSize, + size_: VkDeviceSize, +}; + +export type VkFormatProperties = struct { + linearTilingFeatures: VkFormatFeatureFlags, + optimalTilingFeatures: VkFormatFeatureFlags, + bufferFeatures: VkFormatFeatureFlags, +}; + +export type VkImageFormatProperties = struct { + maxExtent: VkExtent3D, + maxMipLevels: u32, + maxArrayLayers: u32, + sampleCounts: VkSampleCountFlags, + maxResourceSize: VkDeviceSize, +}; + +export type VkDescriptorBufferInfo = struct { + buffer: VkBuffer, + offset_: VkDeviceSize, + range: VkDeviceSize, +}; + +export type VkWriteDescriptorSet = struct { + sType: VkStructureType, + pNext: nullable *const void, + dstSet: VkDescriptorSet, + dstBinding: u32, + dstArrayElement: u32, + descriptorCount: u32, + descriptorType: VkDescriptorType, + pImageInfo: nullable *const VkDescriptorImageInfo, + pBufferInfo: nullable *const VkDescriptorBufferInfo, + pTexelBufferView: nullable *const VkBufferView, +}; + +export type VkBufferCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkBufferCreateFlags, + size_: VkDeviceSize, + usage: VkBufferUsageFlags, + sharingMode: VkSharingMode, + queueFamilyIndexCount: u32, + pQueueFamilyIndices: nullable *const u32, +}; + +export type VkBufferViewCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkBufferViewCreateFlags, + buffer: VkBuffer, + format: VkFormat, + offset_: VkDeviceSize, + range: VkDeviceSize, +}; + +export type VkImageSubresource = struct { + aspectMask: VkImageAspectFlags, + mipLevel: u32, + arrayLayer: u32, +}; + +export type VkImageSubresourceLayers = struct { + aspectMask: VkImageAspectFlags, + mipLevel: u32, + baseArrayLayer: u32, + layerCount: u32, +}; + +export type VkImageSubresourceRange = struct { + aspectMask: VkImageAspectFlags, + baseMipLevel: u32, + levelCount: u32, + baseArrayLayer: u32, + layerCount: u32, +}; + +export type VkMemoryBarrier = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcAccessMask: VkAccessFlags, + dstAccessMask: VkAccessFlags, +}; + +export type VkBufferMemoryBarrier = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcAccessMask: VkAccessFlags, + dstAccessMask: VkAccessFlags, + srcQueueFamilyIndex: u32, + dstQueueFamilyIndex: u32, + buffer: VkBuffer, + offset_: VkDeviceSize, + size_: VkDeviceSize, +}; + +export type VkImageMemoryBarrier = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcAccessMask: VkAccessFlags, + dstAccessMask: VkAccessFlags, + oldLayout: VkImageLayout, + newLayout: VkImageLayout, + srcQueueFamilyIndex: u32, + dstQueueFamilyIndex: u32, + image: VkImage, + subresourceRange: VkImageSubresourceRange, +}; + +export type VkImageCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkImageCreateFlags, + imageType: VkImageType, + format: VkFormat, + extent: VkExtent3D, + mipLevels: u32, + arrayLayers: u32, + samples: VkSampleCountFlagBits, + tiling: VkImageTiling, + usage: VkImageUsageFlags, + sharingMode: VkSharingMode, + queueFamilyIndexCount: u32, + pQueueFamilyIndices: nullable *const u32, + initialLayout: VkImageLayout, +}; + +export type VkSubresourceLayout = struct { + offset_: VkDeviceSize, + size_: VkDeviceSize, + rowPitch: VkDeviceSize, + arrayPitch: VkDeviceSize, + depthPitch: VkDeviceSize, +}; + +export type VkImageViewCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkImageViewCreateFlags, + image: VkImage, + viewType: VkImageViewType, + format: VkFormat, + components: VkComponentMapping, + subresourceRange: VkImageSubresourceRange, +}; + +export type VkBufferCopy = struct { + srcOffset: VkDeviceSize, + dstOffset: VkDeviceSize, + size_: VkDeviceSize, +}; + +export type VkSparseMemoryBind = struct { + resourceOffset: VkDeviceSize, + size_: VkDeviceSize, + memory: VkDeviceMemory, + memoryOffset: VkDeviceSize, + flags: VkSparseMemoryBindFlags, +}; + +export type VkSparseImageMemoryBind = struct { + subresource: VkImageSubresource, + offset_: VkOffset3D, + extent: VkExtent3D, + memory: VkDeviceMemory, + memoryOffset: VkDeviceSize, + flags: VkSparseMemoryBindFlags, +}; + +export type VkSparseBufferMemoryBindInfo = struct { + buffer: VkBuffer, + bindCount: u32, + pBinds: nullable *const VkSparseMemoryBind, +}; + +export type VkSparseImageOpaqueMemoryBindInfo = struct { + image: VkImage, + bindCount: u32, + pBinds: nullable *const VkSparseMemoryBind, +}; + +export type VkSparseImageMemoryBindInfo = struct { + image: VkImage, + bindCount: u32, + pBinds: nullable *const VkSparseImageMemoryBind, +}; + +export type VkBindSparseInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + waitSemaphoreCount: u32, + pWaitSemaphores: nullable *const VkSemaphore, + bufferBindCount: u32, + pBufferBinds: nullable *const VkSparseBufferMemoryBindInfo, + imageOpaqueBindCount: u32, + pImageOpaqueBinds: nullable *const VkSparseImageOpaqueMemoryBindInfo, + imageBindCount: u32, + pImageBinds: nullable *const VkSparseImageMemoryBindInfo, + signalSemaphoreCount: u32, + pSignalSemaphores: nullable *const VkSemaphore, +}; + +export type VkImageCopy = struct { + srcSubresource: VkImageSubresourceLayers, + srcOffset: VkOffset3D, + dstSubresource: VkImageSubresourceLayers, + dstOffset: VkOffset3D, + extent: VkExtent3D, +}; + +export type VkImageBlit = struct { + srcSubresource: VkImageSubresourceLayers, + srcOffsets: [2]VkOffset3D, + dstSubresource: VkImageSubresourceLayers, + dstOffsets: [2]VkOffset3D, +}; + +export type VkBufferImageCopy = struct { + bufferOffset: VkDeviceSize, + bufferRowLength: u32, + bufferImageHeight: u32, + imageSubresource: VkImageSubresourceLayers, + imageOffset: VkOffset3D, + imageExtent: VkExtent3D, +}; + +export type VkImageResolve = struct { + srcSubresource: VkImageSubresourceLayers, + srcOffset: VkOffset3D, + dstSubresource: VkImageSubresourceLayers, + dstOffset: VkOffset3D, + extent: VkExtent3D, +}; + +export type VkShaderModuleCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkShaderModuleCreateFlags, + codeSize: size, + pCode: nullable *const u32, +}; + +export type VkDescriptorSetLayoutBinding = struct { + binding: u32, + descriptorType: VkDescriptorType, + descriptorCount: u32, + stageFlags: VkShaderStageFlags, + pImmutableSamplers: nullable *const VkSampler, +}; + +export type VkDescriptorSetLayoutCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkDescriptorSetLayoutCreateFlags, + bindingCount: u32, + pBindings: nullable *const VkDescriptorSetLayoutBinding, +}; + +export type VkDescriptorPoolCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkDescriptorPoolCreateFlags, + maxSets: u32, + poolSizeCount: u32, + pPoolSizes: nullable *const VkDescriptorPoolSize, +}; + +export type VkPipelineShaderStageCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineShaderStageCreateFlags, + stage: VkShaderStageFlagBits, + module: VkShaderModule, + pName: nullable *const char, + pSpecializationInfo: nullable *const VkSpecializationInfo, +}; + +export type VkComputePipelineCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineCreateFlags, + stage: VkPipelineShaderStageCreateInfo, + layout: VkPipelineLayout, + basePipelineHandle: VkPipeline, + basePipelineIndex: i32, +}; + +export type VkPipelineVertexInputStateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineVertexInputStateCreateFlags, + vertexBindingDescriptionCount: u32, + pVertexBindingDescriptions: nullable *const VkVertexInputBindingDescription, + vertexAttributeDescriptionCount: u32, + pVertexAttributeDescriptions: nullable *const VkVertexInputAttributeDescription, +}; + +export type VkPipelineInputAssemblyStateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineInputAssemblyStateCreateFlags, + topology: VkPrimitiveTopology, + primitiveRestartEnable: VkBool32, +}; + +export type VkPipelineTessellationStateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineTessellationStateCreateFlags, + patchControlPoints: u32, +}; + +export type VkPipelineViewportStateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineViewportStateCreateFlags, + viewportCount: u32, + pViewports: nullable *const VkViewport, + scissorCount: u32, + pScissors: nullable *const VkRect2D, +}; + +export type VkPipelineRasterizationStateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineRasterizationStateCreateFlags, + depthClampEnable: VkBool32, + rasterizerDiscardEnable: VkBool32, + polygonMode: VkPolygonMode, + cullMode: VkCullModeFlags, + frontFace: VkFrontFace, + depthBiasEnable: VkBool32, + depthBiasConstantFactor: f32, + depthBiasClamp: f32, + depthBiasSlopeFactor: f32, + lineWidth: f32, +}; + +export type VkPipelineMultisampleStateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineMultisampleStateCreateFlags, + rasterizationSamples: VkSampleCountFlagBits, + sampleShadingEnable: VkBool32, + minSampleShading: f32, + pSampleMask: nullable *const VkSampleMask, + alphaToCoverageEnable: VkBool32, + alphaToOneEnable: VkBool32, +}; + +export type VkPipelineColorBlendAttachmentState = struct { + blendEnable: VkBool32, + srcColorBlendFactor: VkBlendFactor, + dstColorBlendFactor: VkBlendFactor, + colorBlendOp: VkBlendOp, + srcAlphaBlendFactor: VkBlendFactor, + dstAlphaBlendFactor: VkBlendFactor, + alphaBlendOp: VkBlendOp, + colorWriteMask: VkColorComponentFlags, +}; + +export type VkPipelineColorBlendStateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineColorBlendStateCreateFlags, + logicOpEnable: VkBool32, + logicOp: VkLogicOp, + attachmentCount: u32, + pAttachments: nullable *const VkPipelineColorBlendAttachmentState, + blendConstants: [4]f32, +}; + +export type VkPipelineDynamicStateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineDynamicStateCreateFlags, + dynamicStateCount: u32, + pDynamicStates: nullable *const VkDynamicState, +}; + +export type VkPipelineDepthStencilStateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineDepthStencilStateCreateFlags, + depthTestEnable: VkBool32, + depthWriteEnable: VkBool32, + depthCompareOp: VkCompareOp, + depthBoundsTestEnable: VkBool32, + stencilTestEnable: VkBool32, + front: VkStencilOpState, + back: VkStencilOpState, + minDepthBounds: f32, + maxDepthBounds: f32, +}; + +export type VkGraphicsPipelineCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineCreateFlags, + stageCount: u32, + pStages: nullable *const VkPipelineShaderStageCreateInfo, + pVertexInputState: nullable *const VkPipelineVertexInputStateCreateInfo, + pInputAssemblyState: nullable *const VkPipelineInputAssemblyStateCreateInfo, + pTessellationState: nullable *const VkPipelineTessellationStateCreateInfo, + pViewportState: nullable *const VkPipelineViewportStateCreateInfo, + pRasterizationState: nullable *const VkPipelineRasterizationStateCreateInfo, + pMultisampleState: nullable *const VkPipelineMultisampleStateCreateInfo, + pDepthStencilState: nullable *const VkPipelineDepthStencilStateCreateInfo, + pColorBlendState: nullable *const VkPipelineColorBlendStateCreateInfo, + pDynamicState: nullable *const VkPipelineDynamicStateCreateInfo, + layout: VkPipelineLayout, + renderPass: VkRenderPass, + subpass: u32, + basePipelineHandle: VkPipeline, + basePipelineIndex: i32, +}; + +export type VkPipelineCacheCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineCacheCreateFlags, + initialDataSize: size, + pInitialData: nullable *const void, +}; + +export type VkPushConstantRange = struct { + stageFlags: VkShaderStageFlags, + offset_: u32, + size_: u32, +}; + +export type VkPipelineLayoutCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPipelineLayoutCreateFlags, + setLayoutCount: u32, + pSetLayouts: nullable *const VkDescriptorSetLayout, + pushConstantRangeCount: u32, + pPushConstantRanges: nullable *const VkPushConstantRange, +}; + +export type VkSamplerCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkSamplerCreateFlags, + magFilter: VkFilter, + minFilter: VkFilter, + mipmapMode: VkSamplerMipmapMode, + addressModeU: VkSamplerAddressMode, + addressModeV: VkSamplerAddressMode, + addressModeW: VkSamplerAddressMode, + mipLodBias: f32, + anisotropyEnable: VkBool32, + maxAnisotropy: f32, + compareEnable: VkBool32, + compareOp: VkCompareOp, + minLod: f32, + maxLod: f32, + borderColor: VkBorderColor, + unnormalizedCoordinates: VkBool32, +}; + +export type VkCommandPoolCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkCommandPoolCreateFlags, + queueFamilyIndex: u32, +}; + +export type VkCommandBufferInheritanceInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + renderPass: VkRenderPass, + subpass: u32, + framebuffer: VkFramebuffer, + occlusionQueryEnable: VkBool32, + queryFlags: VkQueryControlFlags, + pipelineStatistics: VkQueryPipelineStatisticFlags, +}; + +export type VkCommandBufferBeginInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkCommandBufferUsageFlags, + pInheritanceInfo: nullable *const VkCommandBufferInheritanceInfo, +}; + +export type VkRenderPassBeginInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + renderPass: VkRenderPass, + framebuffer: VkFramebuffer, + renderArea: VkRect2D, + clearValueCount: u32, + pClearValues: nullable *const VkClearValue, +}; + +export type VkClearAttachment = struct { + aspectMask: VkImageAspectFlags, + colorAttachment: u32, + clearValue: VkClearValue, +}; + +export type VkAttachmentDescription = struct { + flags: VkAttachmentDescriptionFlags, + format: VkFormat, + samples: VkSampleCountFlagBits, + loadOp: VkAttachmentLoadOp, + storeOp: VkAttachmentStoreOp, + stencilLoadOp: VkAttachmentLoadOp, + stencilStoreOp: VkAttachmentStoreOp, + initialLayout: VkImageLayout, + finalLayout: VkImageLayout, +}; + +export type VkSubpassDescription = struct { + flags: VkSubpassDescriptionFlags, + pipelineBindPoint: VkPipelineBindPoint, + inputAttachmentCount: u32, + pInputAttachments: nullable *const VkAttachmentReference, + colorAttachmentCount: u32, + pColorAttachments: nullable *const VkAttachmentReference, + pResolveAttachments: nullable *const VkAttachmentReference, + pDepthStencilAttachment: nullable *const VkAttachmentReference, + preserveAttachmentCount: u32, + pPreserveAttachments: nullable *const u32, +}; + +export type VkSubpassDependency = struct { + srcSubpass: u32, + dstSubpass: u32, + srcStageMask: VkPipelineStageFlags, + dstStageMask: VkPipelineStageFlags, + srcAccessMask: VkAccessFlags, + dstAccessMask: VkAccessFlags, + dependencyFlags: VkDependencyFlags, +}; + +export type VkRenderPassCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkRenderPassCreateFlags, + attachmentCount: u32, + pAttachments: nullable *const VkAttachmentDescription, + subpassCount: u32, + pSubpasses: nullable *const VkSubpassDescription, + dependencyCount: u32, + pDependencies: nullable *const VkSubpassDependency, +}; + +export type VkEventCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkEventCreateFlags, +}; + +export type VkFenceCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkFenceCreateFlags, +}; + +export type VkPhysicalDeviceFeatures = struct { + 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, +}; + +export type VkPhysicalDeviceSparseProperties = struct { + residencyStandard2DBlockShape: VkBool32, + residencyStandard2DMultisampleBlockShape: VkBool32, + residencyStandard3DBlockShape: VkBool32, + residencyAlignedMipSize: VkBool32, + residencyNonResidentStrict: VkBool32, +}; + +export type VkPhysicalDeviceLimits = struct { + maxImageDimension1D: u32, + maxImageDimension2D: u32, + maxImageDimension3D: u32, + maxImageDimensionCube: u32, + maxImageArrayLayers: u32, + maxTexelBufferElements: u32, + maxUniformBufferRange: u32, + maxStorageBufferRange: u32, + maxPushConstantsSize: u32, + maxMemoryAllocationCount: u32, + maxSamplerAllocationCount: u32, + bufferImageGranularity: VkDeviceSize, + sparseAddressSpaceSize: VkDeviceSize, + maxBoundDescriptorSets: u32, + maxPerStageDescriptorSamplers: u32, + maxPerStageDescriptorUniformBuffers: u32, + maxPerStageDescriptorStorageBuffers: u32, + maxPerStageDescriptorSampledImages: u32, + maxPerStageDescriptorStorageImages: u32, + maxPerStageDescriptorInputAttachments: u32, + maxPerStageResources: u32, + maxDescriptorSetSamplers: u32, + maxDescriptorSetUniformBuffers: u32, + maxDescriptorSetUniformBuffersDynamic: u32, + maxDescriptorSetStorageBuffers: u32, + maxDescriptorSetStorageBuffersDynamic: u32, + maxDescriptorSetSampledImages: u32, + maxDescriptorSetStorageImages: u32, + maxDescriptorSetInputAttachments: u32, + maxVertexInputAttributes: u32, + maxVertexInputBindings: u32, + maxVertexInputAttributeOffset: u32, + maxVertexInputBindingStride: u32, + maxVertexOutputComponents: u32, + maxTessellationGenerationLevel: u32, + maxTessellationPatchSize: u32, + maxTessellationControlPerVertexInputComponents: u32, + maxTessellationControlPerVertexOutputComponents: u32, + maxTessellationControlPerPatchOutputComponents: u32, + maxTessellationControlTotalOutputComponents: u32, + maxTessellationEvaluationInputComponents: u32, + maxTessellationEvaluationOutputComponents: u32, + maxGeometryShaderInvocations: u32, + maxGeometryInputComponents: u32, + maxGeometryOutputComponents: u32, + maxGeometryOutputVertices: u32, + maxGeometryTotalOutputComponents: u32, + maxFragmentInputComponents: u32, + maxFragmentOutputAttachments: u32, + maxFragmentDualSrcAttachments: u32, + maxFragmentCombinedOutputResources: u32, + maxComputeSharedMemorySize: u32, + maxComputeWorkGroupCount: [3]u32, + maxComputeWorkGroupInvocations: u32, + maxComputeWorkGroupSize: [3]u32, + subPixelPrecisionBits: u32, + subTexelPrecisionBits: u32, + mipmapPrecisionBits: u32, + maxDrawIndexedIndexValue: u32, + maxDrawIndirectCount: u32, + maxSamplerLodBias: f32, + maxSamplerAnisotropy: f32, + maxViewports: u32, + maxViewportDimensions: [2]u32, + viewportBoundsRange: [2]f32, + viewportSubPixelBits: u32, + minMemoryMapAlignment: size, + minTexelBufferOffsetAlignment: VkDeviceSize, + minUniformBufferOffsetAlignment: VkDeviceSize, + minStorageBufferOffsetAlignment: VkDeviceSize, + minTexelOffset: i32, + maxTexelOffset: u32, + minTexelGatherOffset: i32, + maxTexelGatherOffset: u32, + minInterpolationOffset: f32, + maxInterpolationOffset: f32, + subPixelInterpolationOffsetBits: u32, + maxFramebufferWidth: u32, + maxFramebufferHeight: u32, + maxFramebufferLayers: u32, + framebufferColorSampleCounts: VkSampleCountFlags, + framebufferDepthSampleCounts: VkSampleCountFlags, + framebufferStencilSampleCounts: VkSampleCountFlags, + framebufferNoAttachmentsSampleCounts: VkSampleCountFlags, + maxColorAttachments: u32, + sampledImageColorSampleCounts: VkSampleCountFlags, + sampledImageIntegerSampleCounts: VkSampleCountFlags, + sampledImageDepthSampleCounts: VkSampleCountFlags, + sampledImageStencilSampleCounts: VkSampleCountFlags, + storageImageSampleCounts: VkSampleCountFlags, + maxSampleMaskWords: u32, + timestampComputeAndGraphics: VkBool32, + timestampPeriod: f32, + maxClipDistances: u32, + maxCullDistances: u32, + maxCombinedClipAndCullDistances: u32, + discreteQueuePriorities: u32, + pointSizeRange: [2]f32, + lineWidthRange: [2]f32, + pointSizeGranularity: f32, + lineWidthGranularity: f32, + strictLines: VkBool32, + standardSampleLocations: VkBool32, + optimalBufferCopyOffsetAlignment: VkDeviceSize, + optimalBufferCopyRowPitchAlignment: VkDeviceSize, + nonCoherentAtomSize: VkDeviceSize, +}; + +export type VkSemaphoreCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkSemaphoreCreateFlags, +}; + +export type VkQueryPoolCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkQueryPoolCreateFlags, + queryType: VkQueryType, + queryCount: u32, + pipelineStatistics: VkQueryPipelineStatisticFlags, +}; + +export type VkFramebufferCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkFramebufferCreateFlags, + renderPass: VkRenderPass, + attachmentCount: u32, + pAttachments: nullable *const VkImageView, + width: u32, + height: u32, + layers: u32, +}; + +export type VkSubmitInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + waitSemaphoreCount: u32, + pWaitSemaphores: nullable *const VkSemaphore, + pWaitDstStageMask: nullable *const VkPipelineStageFlags, + commandBufferCount: u32, + pCommandBuffers: nullable *const VkCommandBuffer, + signalSemaphoreCount: u32, + pSignalSemaphores: nullable *const VkSemaphore, +}; + +export type VkPrivateDataSlotCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkPrivateDataSlotCreateFlags, +}; + +export type VkPhysicalDevicePrivateDataFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + privateData: VkBool32, +}; + +export type VkPhysicalDeviceFeatures2 = struct { + sType: VkStructureType, + pNext: nullable *void, + features: VkPhysicalDeviceFeatures, +}; + +export type VkFormatProperties2 = struct { + sType: VkStructureType, + pNext: nullable *void, + formatProperties: VkFormatProperties, +}; + +export type VkImageFormatProperties2 = struct { + sType: VkStructureType, + pNext: nullable *void, + imageFormatProperties: VkImageFormatProperties, +}; + +export type VkPhysicalDeviceImageFormatInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + format: VkFormat, + type_: VkImageType, + tiling: VkImageTiling, + usage: VkImageUsageFlags, + flags: VkImageCreateFlags, +}; + +export type VkQueueFamilyProperties2 = struct { + sType: VkStructureType, + pNext: nullable *void, + queueFamilyProperties: VkQueueFamilyProperties, +}; + +export type VkSparseImageFormatProperties2 = struct { + sType: VkStructureType, + pNext: nullable *void, + properties: VkSparseImageFormatProperties, +}; + +export type VkPhysicalDeviceSparseImageFormatInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + format: VkFormat, + type_: VkImageType, + samples: VkSampleCountFlagBits, + usage: VkImageUsageFlags, + tiling: VkImageTiling, +}; + +export type VkPhysicalDeviceVariablePointersFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + variablePointersStorageBuffer: VkBool32, + variablePointers: VkBool32, +}; + +export type VkPhysicalDeviceVariablePointerFeatures = VkPhysicalDeviceVariablePointersFeatures; +export type VkExternalMemoryProperties = struct { + externalMemoryFeatures: VkExternalMemoryFeatureFlags, + exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlags, + compatibleHandleTypes: VkExternalMemoryHandleTypeFlags, +}; + +export type VkExternalImageFormatProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + externalMemoryProperties: VkExternalMemoryProperties, +}; + +export type VkPhysicalDeviceExternalBufferInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkBufferCreateFlags, + usage: VkBufferUsageFlags, + handleType: VkExternalMemoryHandleTypeFlagBits, +}; + +export type VkExternalBufferProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + externalMemoryProperties: VkExternalMemoryProperties, +}; + +export type VkPhysicalDeviceIDProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + deviceUUID: [VK_UUID_SIZE]u8, + driverUUID: [VK_UUID_SIZE]u8, + deviceLUID: [VK_LUID_SIZE]u8, + deviceNodeMask: u32, + deviceLUIDValid: VkBool32, +}; + +export type VkExternalMemoryImageCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + handleTypes: VkExternalMemoryHandleTypeFlags, +}; + +export type VkExternalMemoryBufferCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + handleTypes: VkExternalMemoryHandleTypeFlags, +}; + +export type VkExportMemoryAllocateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + handleTypes: VkExternalMemoryHandleTypeFlags, +}; + +export type VkExternalSemaphoreProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + exportFromImportedHandleTypes: VkExternalSemaphoreHandleTypeFlags, + compatibleHandleTypes: VkExternalSemaphoreHandleTypeFlags, + externalSemaphoreFeatures: VkExternalSemaphoreFeatureFlags, +}; + +export type VkExportSemaphoreCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + handleTypes: VkExternalSemaphoreHandleTypeFlags, +}; + +export type VkExternalFenceProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + exportFromImportedHandleTypes: VkExternalFenceHandleTypeFlags, + compatibleHandleTypes: VkExternalFenceHandleTypeFlags, + externalFenceFeatures: VkExternalFenceFeatureFlags, +}; + +export type VkExportFenceCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + handleTypes: VkExternalFenceHandleTypeFlags, +}; + +export type VkPhysicalDeviceMultiviewFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + multiview: VkBool32, + multiviewGeometryShader: VkBool32, + multiviewTessellationShader: VkBool32, +}; + +export type VkPhysicalDeviceGroupProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + physicalDeviceCount: u32, + physicalDevices: [VK_MAX_DEVICE_GROUP_SIZE]VkPhysicalDevice, + subsetAllocation: VkBool32, +}; + +export type VkMemoryAllocateFlagsInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkMemoryAllocateFlags, + deviceMask: u32, +}; + +export type VkBindBufferMemoryInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + buffer: VkBuffer, + memory: VkDeviceMemory, + memoryOffset: VkDeviceSize, +}; + +export type VkBindImageMemoryInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + image: VkImage, + memory: VkDeviceMemory, + memoryOffset: VkDeviceSize, +}; + +export type VkDescriptorUpdateTemplateCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkDescriptorUpdateTemplateCreateFlags, + descriptorUpdateEntryCount: u32, + pDescriptorUpdateEntries: nullable *const VkDescriptorUpdateTemplateEntry, + templateType: VkDescriptorUpdateTemplateType, + descriptorSetLayout: VkDescriptorSetLayout, + pipelineBindPoint: VkPipelineBindPoint, + pipelineLayout: VkPipelineLayout, + set: u32, +}; + +export type VkInputAttachmentAspectReference = struct { + subpass: u32, + inputAttachmentIndex: u32, + aspectMask: VkImageAspectFlags, +}; + +export type VkRenderPassInputAttachmentAspectCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + aspectReferenceCount: u32, + pAspectReferences: nullable *const VkInputAttachmentAspectReference, +}; + +export type VkPhysicalDevice16BitStorageFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + storageBuffer16BitAccess: VkBool32, + uniformAndStorageBuffer16BitAccess: VkBool32, + storagePushConstant16: VkBool32, + storageInputOutput16: VkBool32, +}; + +export type VkPhysicalDeviceSubgroupProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + subgroupSize: u32, + supportedStages: VkShaderStageFlags, + supportedOperations: VkSubgroupFeatureFlags, + quadOperationsInAllStages: VkBool32, +}; + +export type VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + shaderSubgroupExtendedTypes: VkBool32, +}; + +export type VkDeviceBufferMemoryRequirements = struct { + sType: VkStructureType, + pNext: nullable *const void, + pCreateInfo: nullable *const VkBufferCreateInfo, +}; + +export type VkDeviceImageMemoryRequirements = struct { + sType: VkStructureType, + pNext: nullable *const void, + pCreateInfo: nullable *const VkImageCreateInfo, + planeAspect: VkImageAspectFlagBits, +}; + +export type VkMemoryRequirements2 = struct { + sType: VkStructureType, + pNext: nullable *void, + memoryRequirements: VkMemoryRequirements, +}; + +export type VkSparseImageMemoryRequirements2 = struct { + sType: VkStructureType, + pNext: nullable *void, + memoryRequirements: VkSparseImageMemoryRequirements, +}; + +export type VkMemoryDedicatedRequirements = struct { + sType: VkStructureType, + pNext: nullable *void, + prefersDedicatedAllocation: VkBool32, + requiresDedicatedAllocation: VkBool32, +}; + +export type VkImageViewUsageCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + usage: VkImageUsageFlags, +}; + +export type VkSamplerYcbcrConversionCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + format: VkFormat, + ycbcrModel: VkSamplerYcbcrModelConversion, + ycbcrRange: VkSamplerYcbcrRange, + components: VkComponentMapping, + xChromaOffset: VkChromaLocation, + yChromaOffset: VkChromaLocation, + chromaFilter: VkFilter, + forceExplicitReconstruction: VkBool32, +}; + +export type VkPhysicalDeviceSamplerYcbcrConversionFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + samplerYcbcrConversion: VkBool32, +}; + +export type VkProtectedSubmitInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + protectedSubmit: VkBool32, +}; + +export type VkPhysicalDeviceProtectedMemoryFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + protectedMemory: VkBool32, +}; + +export type VkPhysicalDeviceProtectedMemoryProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + protectedNoFault: VkBool32, +}; + +export type VkDeviceQueueInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkDeviceQueueCreateFlags, + queueFamilyIndex: u32, + queueIndex: u32, +}; + +export type VkPhysicalDeviceSamplerFilterMinmaxProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + filterMinmaxSingleComponentFormats: VkBool32, + filterMinmaxImageComponentMapping: VkBool32, +}; + +export type VkPhysicalDeviceInlineUniformBlockFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + inlineUniformBlock: VkBool32, + descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32, +}; + +export type VkPhysicalDeviceMaintenance3Properties = struct { + sType: VkStructureType, + pNext: nullable *void, + maxPerSetDescriptors: u32, + maxMemoryAllocationSize: VkDeviceSize, +}; + +export type VkPhysicalDeviceMaintenance4Features = struct { + sType: VkStructureType, + pNext: nullable *void, + maintenance4: VkBool32, +}; + +export type VkPhysicalDeviceMaintenance4Properties = struct { + sType: VkStructureType, + pNext: nullable *void, + maxBufferSize: VkDeviceSize, +}; + +export type VkDescriptorSetLayoutSupport = struct { + sType: VkStructureType, + pNext: nullable *void, + supported: VkBool32, +}; + +export type VkPhysicalDeviceShaderDrawParametersFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + shaderDrawParameters: VkBool32, +}; + +export type VkPhysicalDeviceShaderDrawParameterFeatures = VkPhysicalDeviceShaderDrawParametersFeatures; +export type VkPhysicalDeviceShaderFloat16Int8Features = struct { + sType: VkStructureType, + pNext: nullable *void, + shaderFloat16: VkBool32, + shaderInt8: VkBool32, +}; + +export type VkPhysicalDeviceFloatControlsProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + 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, +}; + +export type VkPhysicalDeviceHostQueryResetFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + hostQueryReset: VkBool32, +}; + +export type VkPhysicalDeviceDescriptorIndexingFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + 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, +}; + +export type VkPhysicalDeviceDescriptorIndexingProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + maxUpdateAfterBindDescriptorsInAllPools: u32, + shaderUniformBufferArrayNonUniformIndexingNative: VkBool32, + shaderSampledImageArrayNonUniformIndexingNative: VkBool32, + shaderStorageBufferArrayNonUniformIndexingNative: VkBool32, + shaderStorageImageArrayNonUniformIndexingNative: VkBool32, + shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32, + robustBufferAccessUpdateAfterBind: VkBool32, + quadDivergentImplicitLod: VkBool32, + maxPerStageDescriptorUpdateAfterBindSamplers: u32, + maxPerStageDescriptorUpdateAfterBindUniformBuffers: u32, + maxPerStageDescriptorUpdateAfterBindStorageBuffers: u32, + maxPerStageDescriptorUpdateAfterBindSampledImages: u32, + maxPerStageDescriptorUpdateAfterBindStorageImages: u32, + maxPerStageDescriptorUpdateAfterBindInputAttachments: u32, + maxPerStageUpdateAfterBindResources: u32, + maxDescriptorSetUpdateAfterBindSamplers: u32, + maxDescriptorSetUpdateAfterBindUniformBuffers: u32, + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32, + maxDescriptorSetUpdateAfterBindStorageBuffers: u32, + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32, + maxDescriptorSetUpdateAfterBindSampledImages: u32, + maxDescriptorSetUpdateAfterBindStorageImages: u32, + maxDescriptorSetUpdateAfterBindInputAttachments: u32, +}; + +export type VkDescriptorSetLayoutBindingFlagsCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + bindingCount: u32, + pBindingFlags: nullable *const VkDescriptorBindingFlags, +}; + +export type VkAttachmentDescription2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkAttachmentDescriptionFlags, + format: VkFormat, + samples: VkSampleCountFlagBits, + loadOp: VkAttachmentLoadOp, + storeOp: VkAttachmentStoreOp, + stencilLoadOp: VkAttachmentLoadOp, + stencilStoreOp: VkAttachmentStoreOp, + initialLayout: VkImageLayout, + finalLayout: VkImageLayout, +}; + +export type VkAttachmentReference2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + attachment: u32, + layout: VkImageLayout, + aspectMask: VkImageAspectFlags, +}; + +export type VkSubpassDescription2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkSubpassDescriptionFlags, + pipelineBindPoint: VkPipelineBindPoint, + viewMask: u32, + inputAttachmentCount: u32, + pInputAttachments: nullable *const VkAttachmentReference2, + colorAttachmentCount: u32, + pColorAttachments: nullable *const VkAttachmentReference2, + pResolveAttachments: nullable *const VkAttachmentReference2, + pDepthStencilAttachment: nullable *const VkAttachmentReference2, + preserveAttachmentCount: u32, + pPreserveAttachments: nullable *const u32, +}; + +export type VkSubpassDependency2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcSubpass: u32, + dstSubpass: u32, + srcStageMask: VkPipelineStageFlags, + dstStageMask: VkPipelineStageFlags, + srcAccessMask: VkAccessFlags, + dstAccessMask: VkAccessFlags, + dependencyFlags: VkDependencyFlags, + viewOffset: i32, +}; + +export type VkRenderPassCreateInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkRenderPassCreateFlags, + attachmentCount: u32, + pAttachments: nullable *const VkAttachmentDescription2, + subpassCount: u32, + pSubpasses: nullable *const VkSubpassDescription2, + dependencyCount: u32, + pDependencies: nullable *const VkSubpassDependency2, + correlatedViewMaskCount: u32, + pCorrelatedViewMasks: nullable *const u32, +}; + +export type VkPhysicalDeviceTimelineSemaphoreFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + timelineSemaphore: VkBool32, +}; + +export type VkSemaphoreWaitInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkSemaphoreWaitFlags, + semaphoreCount: u32, + pSemaphores: nullable *const VkSemaphore, + pValues: nullable *const u64, +}; + +export type VkPhysicalDevice8BitStorageFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + storageBuffer8BitAccess: VkBool32, + uniformAndStorageBuffer8BitAccess: VkBool32, + storagePushConstant8: VkBool32, +}; + +export type VkPhysicalDeviceVulkanMemoryModelFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + vulkanMemoryModel: VkBool32, + vulkanMemoryModelDeviceScope: VkBool32, + vulkanMemoryModelAvailabilityVisibilityChains: VkBool32, +}; + +export type VkPhysicalDeviceShaderAtomicInt64Features = struct { + sType: VkStructureType, + pNext: nullable *void, + shaderBufferInt64Atomics: VkBool32, + shaderSharedInt64Atomics: VkBool32, +}; + +export type VkPhysicalDeviceDepthStencilResolveProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + supportedDepthResolveModes: VkResolveModeFlags, + supportedStencilResolveModes: VkResolveModeFlags, + independentResolveNone: VkBool32, + independentResolve: VkBool32, +}; + +export type VkSubpassDescriptionDepthStencilResolve = struct { + sType: VkStructureType, + pNext: nullable *const void, + depthResolveMode: VkResolveModeFlagBits, + stencilResolveMode: VkResolveModeFlagBits, + pDepthStencilResolveAttachment: nullable *const VkAttachmentReference2, +}; + +export type VkImageStencilUsageCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + stencilUsage: VkImageUsageFlags, +}; + +export type VkPhysicalDeviceScalarBlockLayoutFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + scalarBlockLayout: VkBool32, +}; + +export type VkPhysicalDeviceUniformBufferStandardLayoutFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + uniformBufferStandardLayout: VkBool32, +}; + +export type VkPhysicalDeviceBufferDeviceAddressFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + bufferDeviceAddress: VkBool32, + bufferDeviceAddressCaptureReplay: VkBool32, + bufferDeviceAddressMultiDevice: VkBool32, +}; + +export type VkPhysicalDeviceImagelessFramebufferFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + imagelessFramebuffer: VkBool32, +}; + +export type VkFramebufferAttachmentImageInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkImageCreateFlags, + usage: VkImageUsageFlags, + width: u32, + height: u32, + layerCount: u32, + viewFormatCount: u32, + pViewFormats: nullable *const VkFormat, +}; + +export type VkPhysicalDeviceTextureCompressionASTCHDRFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + textureCompressionASTC_HDR: VkBool32, +}; + +export type VkPipelineCreationFeedback = struct { + flags: VkPipelineCreationFeedbackFlags, + duration: u64, +}; + +export type VkPipelineCreationFeedbackCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + pPipelineCreationFeedback: nullable *VkPipelineCreationFeedback, + pipelineStageCreationFeedbackCount: u32, + pPipelineStageCreationFeedbacks: nullable *VkPipelineCreationFeedback, +}; + +export type VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + separateDepthStencilLayouts: VkBool32, +}; + +export type VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + shaderDemoteToHelperInvocation: VkBool32, +}; + +export type VkPhysicalDeviceTexelBufferAlignmentProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + storageTexelBufferOffsetAlignmentBytes: VkDeviceSize, + storageTexelBufferOffsetSingleTexelAlignment: VkBool32, + uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize, + uniformTexelBufferOffsetSingleTexelAlignment: VkBool32, +}; + +export type VkPhysicalDeviceSubgroupSizeControlFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + subgroupSizeControl: VkBool32, + computeFullSubgroups: VkBool32, +}; + +export type VkPhysicalDeviceSubgroupSizeControlProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + minSubgroupSize: u32, + maxSubgroupSize: u32, + maxComputeWorkgroupSubgroups: u32, + requiredSubgroupSizeStages: VkShaderStageFlags, +}; + +export type VkPhysicalDevicePipelineCreationCacheControlFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + pipelineCreationCacheControl: VkBool32, +}; + +export type VkPhysicalDeviceVulkan11Features = struct { + sType: VkStructureType, + pNext: nullable *void, + storageBuffer16BitAccess: VkBool32, + uniformAndStorageBuffer16BitAccess: VkBool32, + storagePushConstant16: VkBool32, + storageInputOutput16: VkBool32, + multiview: VkBool32, + multiviewGeometryShader: VkBool32, + multiviewTessellationShader: VkBool32, + variablePointersStorageBuffer: VkBool32, + variablePointers: VkBool32, + protectedMemory: VkBool32, + samplerYcbcrConversion: VkBool32, + shaderDrawParameters: VkBool32, +}; + +export type VkPhysicalDeviceVulkan11Properties = struct { + sType: VkStructureType, + pNext: nullable *void, + deviceUUID: [VK_UUID_SIZE]u8, + driverUUID: [VK_UUID_SIZE]u8, + deviceLUID: [VK_LUID_SIZE]u8, + deviceNodeMask: u32, + deviceLUIDValid: VkBool32, + subgroupSize: u32, + subgroupSupportedStages: VkShaderStageFlags, + subgroupSupportedOperations: VkSubgroupFeatureFlags, + subgroupQuadOperationsInAllStages: VkBool32, + pointClippingBehavior: VkPointClippingBehavior, + maxMultiviewViewCount: u32, + maxMultiviewInstanceIndex: u32, + protectedNoFault: VkBool32, + maxPerSetDescriptors: u32, + maxMemoryAllocationSize: VkDeviceSize, +}; + +export type VkPhysicalDeviceVulkan12Features = struct { + sType: VkStructureType, + pNext: nullable *void, + 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, +}; + +export type VkPhysicalDeviceVulkan12Properties = struct { + sType: VkStructureType, + pNext: nullable *void, + driverID: VkDriverId, + driverName: [VK_MAX_DRIVER_NAME_SIZE]char, + driverInfo: [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: u32, + shaderUniformBufferArrayNonUniformIndexingNative: VkBool32, + shaderSampledImageArrayNonUniformIndexingNative: VkBool32, + shaderStorageBufferArrayNonUniformIndexingNative: VkBool32, + shaderStorageImageArrayNonUniformIndexingNative: VkBool32, + shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32, + robustBufferAccessUpdateAfterBind: VkBool32, + quadDivergentImplicitLod: VkBool32, + maxPerStageDescriptorUpdateAfterBindSamplers: u32, + maxPerStageDescriptorUpdateAfterBindUniformBuffers: u32, + maxPerStageDescriptorUpdateAfterBindStorageBuffers: u32, + maxPerStageDescriptorUpdateAfterBindSampledImages: u32, + maxPerStageDescriptorUpdateAfterBindStorageImages: u32, + maxPerStageDescriptorUpdateAfterBindInputAttachments: u32, + maxPerStageUpdateAfterBindResources: u32, + maxDescriptorSetUpdateAfterBindSamplers: u32, + maxDescriptorSetUpdateAfterBindUniformBuffers: u32, + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32, + maxDescriptorSetUpdateAfterBindStorageBuffers: u32, + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32, + maxDescriptorSetUpdateAfterBindSampledImages: u32, + maxDescriptorSetUpdateAfterBindStorageImages: u32, + maxDescriptorSetUpdateAfterBindInputAttachments: u32, + supportedDepthResolveModes: VkResolveModeFlags, + supportedStencilResolveModes: VkResolveModeFlags, + independentResolveNone: VkBool32, + independentResolve: VkBool32, + filterMinmaxSingleComponentFormats: VkBool32, + filterMinmaxImageComponentMapping: VkBool32, + maxTimelineSemaphoreValueDifference: u64, + framebufferIntegerColorSampleCounts: VkSampleCountFlags, +}; + +export type VkPhysicalDeviceVulkan13Features = struct { + sType: VkStructureType, + pNext: nullable *void, + robustImageAccess: VkBool32, + inlineUniformBlock: VkBool32, + descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32, + pipelineCreationCacheControl: VkBool32, + privateData: VkBool32, + shaderDemoteToHelperInvocation: VkBool32, + shaderTerminateInvocation: VkBool32, + subgroupSizeControl: VkBool32, + computeFullSubgroups: VkBool32, + synchronization2: VkBool32, + textureCompressionASTC_HDR: VkBool32, + shaderZeroInitializeWorkgroupMemory: VkBool32, + dynamicRendering: VkBool32, + shaderIntegerDotProduct: VkBool32, + maintenance4: VkBool32, +}; + +export type VkPhysicalDeviceVulkan13Properties = struct { + sType: VkStructureType, + pNext: nullable *void, + minSubgroupSize: u32, + maxSubgroupSize: u32, + maxComputeWorkgroupSubgroups: u32, + requiredSubgroupSizeStages: VkShaderStageFlags, + maxInlineUniformBlockSize: u32, + maxPerStageDescriptorInlineUniformBlocks: u32, + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32, + maxDescriptorSetInlineUniformBlocks: u32, + maxDescriptorSetUpdateAfterBindInlineUniformBlocks: u32, + maxInlineUniformTotalSize: u32, + integerDotProduct8BitUnsignedAccelerated: VkBool32, + integerDotProduct8BitSignedAccelerated: VkBool32, + integerDotProduct8BitMixedSignednessAccelerated: VkBool32, + integerDotProduct4x8BitPackedUnsignedAccelerated: VkBool32, + integerDotProduct4x8BitPackedSignedAccelerated: VkBool32, + integerDotProduct4x8BitPackedMixedSignednessAccelerated: VkBool32, + integerDotProduct16BitUnsignedAccelerated: VkBool32, + integerDotProduct16BitSignedAccelerated: VkBool32, + integerDotProduct16BitMixedSignednessAccelerated: VkBool32, + integerDotProduct32BitUnsignedAccelerated: VkBool32, + integerDotProduct32BitSignedAccelerated: VkBool32, + integerDotProduct32BitMixedSignednessAccelerated: VkBool32, + integerDotProduct64BitUnsignedAccelerated: VkBool32, + integerDotProduct64BitSignedAccelerated: VkBool32, + integerDotProduct64BitMixedSignednessAccelerated: VkBool32, + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating8BitSignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: VkBool32, + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: VkBool32, + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating16BitSignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: VkBool32, + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating32BitSignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: VkBool32, + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating64BitSignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: VkBool32, + storageTexelBufferOffsetAlignmentBytes: VkDeviceSize, + storageTexelBufferOffsetSingleTexelAlignment: VkBool32, + uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize, + uniformTexelBufferOffsetSingleTexelAlignment: VkBool32, + maxBufferSize: VkDeviceSize, +}; + +export type VkPhysicalDeviceToolProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + name: [VK_MAX_EXTENSION_NAME_SIZE]char, + version: [VK_MAX_EXTENSION_NAME_SIZE]char, + purposes: VkToolPurposeFlags, + description: [VK_MAX_DESCRIPTION_SIZE]char, + layer: [VK_MAX_EXTENSION_NAME_SIZE]char, +}; + +export type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + shaderZeroInitializeWorkgroupMemory: VkBool32, +}; + +export type VkPhysicalDeviceImageRobustnessFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + robustImageAccess: VkBool32, +}; + +export type VkBufferCopy2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcOffset: VkDeviceSize, + dstOffset: VkDeviceSize, + size_: VkDeviceSize, +}; + +export type VkImageCopy2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcSubresource: VkImageSubresourceLayers, + srcOffset: VkOffset3D, + dstSubresource: VkImageSubresourceLayers, + dstOffset: VkOffset3D, + extent: VkExtent3D, +}; + +export type VkImageBlit2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcSubresource: VkImageSubresourceLayers, + srcOffsets: [2]VkOffset3D, + dstSubresource: VkImageSubresourceLayers, + dstOffsets: [2]VkOffset3D, +}; + +export type VkBufferImageCopy2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + bufferOffset: VkDeviceSize, + bufferRowLength: u32, + bufferImageHeight: u32, + imageSubresource: VkImageSubresourceLayers, + imageOffset: VkOffset3D, + imageExtent: VkExtent3D, +}; + +export type VkImageResolve2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcSubresource: VkImageSubresourceLayers, + srcOffset: VkOffset3D, + dstSubresource: VkImageSubresourceLayers, + dstOffset: VkOffset3D, + extent: VkExtent3D, +}; + +export type VkCopyBufferInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcBuffer: VkBuffer, + dstBuffer: VkBuffer, + regionCount: u32, + pRegions: nullable *const VkBufferCopy2, +}; + +export type VkCopyImageInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcImage: VkImage, + srcImageLayout: VkImageLayout, + dstImage: VkImage, + dstImageLayout: VkImageLayout, + regionCount: u32, + pRegions: nullable *const VkImageCopy2, +}; + +export type VkBlitImageInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcImage: VkImage, + srcImageLayout: VkImageLayout, + dstImage: VkImage, + dstImageLayout: VkImageLayout, + regionCount: u32, + pRegions: nullable *const VkImageBlit2, + filter: VkFilter, +}; + +export type VkCopyBufferToImageInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcBuffer: VkBuffer, + dstImage: VkImage, + dstImageLayout: VkImageLayout, + regionCount: u32, + pRegions: nullable *const VkBufferImageCopy2, +}; + +export type VkCopyImageToBufferInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcImage: VkImage, + srcImageLayout: VkImageLayout, + dstBuffer: VkBuffer, + regionCount: u32, + pRegions: nullable *const VkBufferImageCopy2, +}; + +export type VkResolveImageInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcImage: VkImage, + srcImageLayout: VkImageLayout, + dstImage: VkImage, + dstImageLayout: VkImageLayout, + regionCount: u32, + pRegions: nullable *const VkImageResolve2, +}; + +export type VkPhysicalDeviceShaderTerminateInvocationFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + shaderTerminateInvocation: VkBool32, +}; + +export type VkMemoryBarrier2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcStageMask: VkPipelineStageFlags2, + srcAccessMask: VkAccessFlags2, + dstStageMask: VkPipelineStageFlags2, + dstAccessMask: VkAccessFlags2, +}; + +export type VkImageMemoryBarrier2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcStageMask: VkPipelineStageFlags2, + srcAccessMask: VkAccessFlags2, + dstStageMask: VkPipelineStageFlags2, + dstAccessMask: VkAccessFlags2, + oldLayout: VkImageLayout, + newLayout: VkImageLayout, + srcQueueFamilyIndex: u32, + dstQueueFamilyIndex: u32, + image: VkImage, + subresourceRange: VkImageSubresourceRange, +}; + +export type VkBufferMemoryBarrier2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + srcStageMask: VkPipelineStageFlags2, + srcAccessMask: VkAccessFlags2, + dstStageMask: VkPipelineStageFlags2, + dstAccessMask: VkAccessFlags2, + srcQueueFamilyIndex: u32, + dstQueueFamilyIndex: u32, + buffer: VkBuffer, + offset_: VkDeviceSize, + size_: VkDeviceSize, +}; + +export type VkDependencyInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + dependencyFlags: VkDependencyFlags, + memoryBarrierCount: u32, + pMemoryBarriers: nullable *const VkMemoryBarrier2, + bufferMemoryBarrierCount: u32, + pBufferMemoryBarriers: nullable *const VkBufferMemoryBarrier2, + imageMemoryBarrierCount: u32, + pImageMemoryBarriers: nullable *const VkImageMemoryBarrier2, +}; + +export type VkSemaphoreSubmitInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + semaphore: VkSemaphore, + value: u64, + stageMask: VkPipelineStageFlags2, + deviceIndex: u32, +}; + +export type VkSubmitInfo2 = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkSubmitFlags, + waitSemaphoreInfoCount: u32, + pWaitSemaphoreInfos: nullable *const VkSemaphoreSubmitInfo, + commandBufferInfoCount: u32, + pCommandBufferInfos: nullable *const VkCommandBufferSubmitInfo, + signalSemaphoreInfoCount: u32, + pSignalSemaphoreInfos: nullable *const VkSemaphoreSubmitInfo, +}; + +export type VkPhysicalDeviceSynchronization2Features = struct { + sType: VkStructureType, + pNext: nullable *void, + synchronization2: VkBool32, +}; + +export type VkPhysicalDeviceShaderIntegerDotProductFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + shaderIntegerDotProduct: VkBool32, +}; + +export type VkPhysicalDeviceShaderIntegerDotProductProperties = struct { + sType: VkStructureType, + pNext: nullable *void, + integerDotProduct8BitUnsignedAccelerated: VkBool32, + integerDotProduct8BitSignedAccelerated: VkBool32, + integerDotProduct8BitMixedSignednessAccelerated: VkBool32, + integerDotProduct4x8BitPackedUnsignedAccelerated: VkBool32, + integerDotProduct4x8BitPackedSignedAccelerated: VkBool32, + integerDotProduct4x8BitPackedMixedSignednessAccelerated: VkBool32, + integerDotProduct16BitUnsignedAccelerated: VkBool32, + integerDotProduct16BitSignedAccelerated: VkBool32, + integerDotProduct16BitMixedSignednessAccelerated: VkBool32, + integerDotProduct32BitUnsignedAccelerated: VkBool32, + integerDotProduct32BitSignedAccelerated: VkBool32, + integerDotProduct32BitMixedSignednessAccelerated: VkBool32, + integerDotProduct64BitUnsignedAccelerated: VkBool32, + integerDotProduct64BitSignedAccelerated: VkBool32, + integerDotProduct64BitMixedSignednessAccelerated: VkBool32, + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating8BitSignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: VkBool32, + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: VkBool32, + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating16BitSignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: VkBool32, + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating32BitSignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: VkBool32, + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating64BitSignedAccelerated: VkBool32, + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: VkBool32, +}; + +export type VkFormatProperties3 = struct { + sType: VkStructureType, + pNext: nullable *void, + linearTilingFeatures: VkFormatFeatureFlags2, + optimalTilingFeatures: VkFormatFeatureFlags2, + bufferFeatures: VkFormatFeatureFlags2, +}; + +export type VkRenderingInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkRenderingFlags, + renderArea: VkRect2D, + layerCount: u32, + viewMask: u32, + colorAttachmentCount: u32, + pColorAttachments: nullable *const VkRenderingAttachmentInfo, + pDepthAttachment: nullable *const VkRenderingAttachmentInfo, + pStencilAttachment: nullable *const VkRenderingAttachmentInfo, +}; + +export type VkPhysicalDeviceDynamicRenderingFeatures = struct { + sType: VkStructureType, + pNext: nullable *void, + dynamicRendering: VkBool32, +}; + +export type VkCommandBufferInheritanceRenderingInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkRenderingFlags, + viewMask: u32, + colorAttachmentCount: u32, + pColorAttachmentFormats: nullable *const VkFormat, + depthAttachmentFormat: VkFormat, + stencilAttachmentFormat: VkFormat, + rasterizationSamples: VkSampleCountFlagBits, +}; + +export type VkPhysicalDeviceProperties = struct { + apiVersion: u32, + driverVersion: u32, + vendorID: u32, + deviceID: u32, + deviceType: VkPhysicalDeviceType, + deviceName: [VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]char, + pipelineCacheUUID: [VK_UUID_SIZE]u8, + limits: VkPhysicalDeviceLimits, + sparseProperties: VkPhysicalDeviceSparseProperties, +}; + +export type VkDeviceCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + flags: VkDeviceCreateFlags, + queueCreateInfoCount: u32, + pQueueCreateInfos: nullable *const VkDeviceQueueCreateInfo, + enabledLayerCount: u32, + ppEnabledLayerNames: nullable *const nullable *const char, + enabledExtensionCount: u32, + ppEnabledExtensionNames: nullable *const nullable *const char, + pEnabledFeatures: nullable *const VkPhysicalDeviceFeatures, +}; + +export type VkPhysicalDeviceMemoryProperties = struct { + memoryTypeCount: u32, + memoryTypes: [VK_MAX_MEMORY_TYPES]VkMemoryType, + memoryHeapCount: u32, + memoryHeaps: [VK_MAX_MEMORY_HEAPS]VkMemoryHeap, +}; + +export type VkPhysicalDeviceProperties2 = struct { + sType: VkStructureType, + pNext: nullable *void, + properties: VkPhysicalDeviceProperties, +}; + +export type VkPhysicalDeviceMemoryProperties2 = struct { + sType: VkStructureType, + pNext: nullable *void, + memoryProperties: VkPhysicalDeviceMemoryProperties, +}; + +export type VkFramebufferAttachmentsCreateInfo = struct { + sType: VkStructureType, + pNext: nullable *const void, + attachmentImageInfoCount: u32, + pAttachmentImageInfos: nullable *const VkFramebufferAttachmentImageInfo, +}; + + +// Constants +export def VK_ATTACHMENT_UNUSED: uint = ~0; +export def VK_FALSE: uint = 0; +export def VK_LOD_CLAMP_NONE: f32 = 1000.0; +export def VK_LUID_SIZE: uint = 8; +export def VK_MAX_DESCRIPTION_SIZE: uint = 256; +export def VK_MAX_DEVICE_GROUP_SIZE: uint = 32; +export def VK_MAX_DRIVER_INFO_SIZE: uint = 256; +export def VK_MAX_DRIVER_NAME_SIZE: uint = 256; +export def VK_MAX_EXTENSION_NAME_SIZE: uint = 256; +export def VK_MAX_MEMORY_HEAPS: uint = 16; +export def VK_MAX_MEMORY_TYPES: uint = 32; +export def VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: uint = 256; +export def VK_QUEUE_FAMILY_EXTERNAL: uint = ~1; +export def VK_QUEUE_FAMILY_IGNORED: uint = ~0; +export def VK_REMAINING_ARRAY_LAYERS: uint = ~0; +export def VK_REMAINING_MIP_LEVELS: uint = ~0; +export def VK_SUBPASS_EXTERNAL: uint = ~0; +export def VK_TRUE: uint = 1; +export def VK_UUID_SIZE: uint = 16; +export def VK_WHOLE_SIZE: uint = ~0; + +// Function pointers +export type fp_vkAllocateCommandBuffers = fn(device: VkDevice, pAllocateInfo: nullable *const VkCommandBufferAllocateInfo, pCommandBuffers: nullable *VkCommandBuffer) VkResult; +export type fp_vkAllocateDescriptorSets = fn(device: VkDevice, pAllocateInfo: nullable *const VkDescriptorSetAllocateInfo, pDescriptorSets: nullable *VkDescriptorSet) VkResult; +export type fp_vkAllocateMemory = fn(device: VkDevice, pAllocateInfo: nullable *const VkMemoryAllocateInfo, pAllocator: nullable *const VkAllocationCallbacks, pMemory: nullable *VkDeviceMemory) VkResult; +export type fp_vkBeginCommandBuffer = fn(commandBuffer: VkCommandBuffer, pBeginInfo: nullable *const VkCommandBufferBeginInfo) VkResult; +export type fp_vkBindBufferMemory = fn(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) VkResult; +export type fp_vkBindBufferMemory2 = fn(device: VkDevice, bindInfoCount: u32, pBindInfos: nullable *const VkBindBufferMemoryInfo) VkResult; +export type fp_vkBindImageMemory = fn(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) VkResult; +export type fp_vkBindImageMemory2 = fn(device: VkDevice, bindInfoCount: u32, pBindInfos: nullable *const VkBindImageMemoryInfo) VkResult; +export type fp_vkCmdBeginQuery = fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags) void; +export type fp_vkCmdBeginRenderPass = fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: nullable *const VkRenderPassBeginInfo, contents: VkSubpassContents) void; +export type fp_vkCmdBeginRenderPass2 = fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: nullable *const VkRenderPassBeginInfo, pSubpassBeginInfo: nullable *const VkSubpassBeginInfo) void; +export type fp_vkCmdBeginRendering = fn(commandBuffer: VkCommandBuffer, pRenderingInfo: nullable *const VkRenderingInfo) void; +export type fp_vkCmdBindDescriptorSets = fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: nullable *const VkDescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: nullable *const u32) void; +export type fp_vkCmdBindIndexBuffer = fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset_: VkDeviceSize, indexType: VkIndexType) void; +export type fp_vkCmdBindPipeline = fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline) void; +export type fp_vkCmdBindVertexBuffers = fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: nullable *const VkBuffer, pOffsets: nullable *const VkDeviceSize) void; +export type fp_vkCmdBindVertexBuffers2 = fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: nullable *const VkBuffer, pOffsets: nullable *const VkDeviceSize, pSizes: nullable *const VkDeviceSize, pStrides: nullable *const VkDeviceSize) void; +export type fp_vkCmdBlitImage = fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: nullable *const VkImageBlit, filter: VkFilter) void; +export type fp_vkCmdBlitImage2 = fn(commandBuffer: VkCommandBuffer, pBlitImageInfo: nullable *const VkBlitImageInfo2) void; +export type fp_vkCmdClearAttachments = fn(commandBuffer: VkCommandBuffer, attachmentCount: u32, pAttachments: nullable *const VkClearAttachment, rectCount: u32, pRects: nullable *const VkClearRect) void; +export type fp_vkCmdClearColorImage = fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: nullable *const VkClearColorValue, rangeCount: u32, pRanges: nullable *const VkImageSubresourceRange) void; +export type fp_vkCmdClearDepthStencilImage = fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: nullable *const VkClearDepthStencilValue, rangeCount: u32, pRanges: nullable *const VkImageSubresourceRange) void; +export type fp_vkCmdCopyBuffer = fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: nullable *const VkBufferCopy) void; +export type fp_vkCmdCopyBuffer2 = fn(commandBuffer: VkCommandBuffer, pCopyBufferInfo: nullable *const VkCopyBufferInfo2) void; +export type fp_vkCmdCopyBufferToImage = fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: nullable *const VkBufferImageCopy) void; +export type fp_vkCmdCopyBufferToImage2 = fn(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: nullable *const VkCopyBufferToImageInfo2) void; +export type fp_vkCmdCopyImage = fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: nullable *const VkImageCopy) void; +export type fp_vkCmdCopyImage2 = fn(commandBuffer: VkCommandBuffer, pCopyImageInfo: nullable *const VkCopyImageInfo2) void; +export type fp_vkCmdCopyImageToBuffer = fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: u32, pRegions: nullable *const VkBufferImageCopy) void; +export type fp_vkCmdCopyImageToBuffer2 = fn(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: nullable *const VkCopyImageToBufferInfo2) void; +export type fp_vkCmdCopyQueryPoolResults = fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags) void; +export type fp_vkCmdDispatch = fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32) void; +export type fp_vkCmdDispatchBase = fn(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32) void; +export type fp_vkCmdDispatchIndirect = fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset_: VkDeviceSize) void; +export type fp_vkCmdDraw = fn(commandBuffer: VkCommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32) void; +export type fp_vkCmdDrawIndexed = fn(commandBuffer: VkCommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32) void; +export type fp_vkCmdDrawIndexedIndirect = fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset_: VkDeviceSize, drawCount: u32, stride: u32) void; +export type fp_vkCmdDrawIndexedIndirectCount = fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset_: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32) void; +export type fp_vkCmdDrawIndirect = fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset_: VkDeviceSize, drawCount: u32, stride: u32) void; +export type fp_vkCmdDrawIndirectCount = fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset_: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32) void; +export type fp_vkCmdEndQuery = fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32) void; +export type fp_vkCmdEndRenderPass = fn(commandBuffer: VkCommandBuffer) void; +export type fp_vkCmdEndRenderPass2 = fn(commandBuffer: VkCommandBuffer, pSubpassEndInfo: nullable *const VkSubpassEndInfo) void; +export type fp_vkCmdEndRendering = fn(commandBuffer: VkCommandBuffer) void; +export type fp_vkCmdExecuteCommands = fn(commandBuffer: VkCommandBuffer, commandBufferCount: u32, pCommandBuffers: nullable *const VkCommandBuffer) void; +export type fp_vkCmdFillBuffer = fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size_: VkDeviceSize, data: u32) void; +export type fp_vkCmdNextSubpass = fn(commandBuffer: VkCommandBuffer, contents: VkSubpassContents) void; +export type fp_vkCmdNextSubpass2 = fn(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: nullable *const VkSubpassBeginInfo, pSubpassEndInfo: nullable *const VkSubpassEndInfo) void; +export type fp_vkCmdPipelineBarrier = fn(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: nullable *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: nullable *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: nullable *const VkImageMemoryBarrier) void; +export type fp_vkCmdPipelineBarrier2 = fn(commandBuffer: VkCommandBuffer, pDependencyInfo: nullable *const VkDependencyInfo) void; +export type fp_vkCmdPushConstants = fn(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset_: u32, size_: u32, pValues: nullable *const void) void; +export type fp_vkCmdResetEvent = fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags) void; +export type fp_vkCmdResetEvent2 = fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2) void; +export type fp_vkCmdResetQueryPool = fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32) void; +export type fp_vkCmdResolveImage = fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: nullable *const VkImageResolve) void; +export type fp_vkCmdResolveImage2 = fn(commandBuffer: VkCommandBuffer, pResolveImageInfo: nullable *const VkResolveImageInfo2) void; +export type fp_vkCmdSetBlendConstants = fn(commandBuffer: VkCommandBuffer, blendConstants: [4]f32) void; +export type fp_vkCmdSetCullMode = fn(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags) void; +export type fp_vkCmdSetDepthBias = fn(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32) void; +export type fp_vkCmdSetDepthBiasEnable = fn(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32) void; +export type fp_vkCmdSetDepthBounds = fn(commandBuffer: VkCommandBuffer, minDepthBounds: f32, maxDepthBounds: f32) void; +export type fp_vkCmdSetDepthBoundsTestEnable = fn(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32) void; +export type fp_vkCmdSetDepthCompareOp = fn(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp) void; +export type fp_vkCmdSetDepthTestEnable = fn(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32) void; +export type fp_vkCmdSetDepthWriteEnable = fn(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32) void; +export type fp_vkCmdSetDeviceMask = fn(commandBuffer: VkCommandBuffer, deviceMask: u32) void; +export type fp_vkCmdSetEvent = fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags) void; +export type fp_vkCmdSetEvent2 = fn(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: nullable *const VkDependencyInfo) void; +export type fp_vkCmdSetFrontFace = fn(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace) void; +export type fp_vkCmdSetLineWidth = fn(commandBuffer: VkCommandBuffer, lineWidth: f32) void; +export type fp_vkCmdSetPrimitiveRestartEnable = fn(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32) void; +export type fp_vkCmdSetPrimitiveTopology = fn(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology) void; +export type fp_vkCmdSetRasterizerDiscardEnable = fn(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32) void; +export type fp_vkCmdSetScissor = fn(commandBuffer: VkCommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: nullable *const VkRect2D) void; +export type fp_vkCmdSetScissorWithCount = fn(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: nullable *const VkRect2D) void; +export type fp_vkCmdSetStencilCompareMask = fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: u32) void; +export type fp_vkCmdSetStencilOp = fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp) void; +export type fp_vkCmdSetStencilReference = fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: u32) void; +export type fp_vkCmdSetStencilTestEnable = fn(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32) void; +export type fp_vkCmdSetStencilWriteMask = fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: u32) void; +export type fp_vkCmdSetViewport = fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: nullable *const VkViewport) void; +export type fp_vkCmdSetViewportWithCount = fn(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: nullable *const VkViewport) void; +export type fp_vkCmdUpdateBuffer = fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: nullable *const void) void; +export type fp_vkCmdWaitEvents = fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: nullable *const VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: nullable *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: nullable *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: nullable *const VkImageMemoryBarrier) void; +export type fp_vkCmdWaitEvents2 = fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: nullable *const VkEvent, pDependencyInfos: nullable *const VkDependencyInfo) void; +export type fp_vkCmdWriteTimestamp = fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: u32) void; +export type fp_vkCmdWriteTimestamp2 = fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32) void; +export type fp_vkCreateBuffer = fn(device: VkDevice, pCreateInfo: nullable *const VkBufferCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pBuffer: nullable *VkBuffer) VkResult; +export type fp_vkCreateBufferView = fn(device: VkDevice, pCreateInfo: nullable *const VkBufferViewCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pView: nullable *VkBufferView) VkResult; +export type fp_vkCreateCommandPool = fn(device: VkDevice, pCreateInfo: nullable *const VkCommandPoolCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pCommandPool: nullable *VkCommandPool) VkResult; +export type fp_vkCreateComputePipelines = fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: nullable *const VkComputePipelineCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pPipelines: nullable *VkPipeline) VkResult; +export type fp_vkCreateDescriptorPool = fn(device: VkDevice, pCreateInfo: nullable *const VkDescriptorPoolCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pDescriptorPool: nullable *VkDescriptorPool) VkResult; +export type fp_vkCreateDescriptorSetLayout = fn(device: VkDevice, pCreateInfo: nullable *const VkDescriptorSetLayoutCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pSetLayout: nullable *VkDescriptorSetLayout) VkResult; +export type fp_vkCreateDescriptorUpdateTemplate = fn(device: VkDevice, pCreateInfo: nullable *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pDescriptorUpdateTemplate: nullable *VkDescriptorUpdateTemplate) VkResult; +export type fp_vkCreateDevice = fn(physicalDevice: VkPhysicalDevice, pCreateInfo: nullable *const VkDeviceCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pDevice: nullable *VkDevice) VkResult; +export type fp_vkCreateEvent = fn(device: VkDevice, pCreateInfo: nullable *const VkEventCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pEvent: nullable *VkEvent) VkResult; +export type fp_vkCreateFence = fn(device: VkDevice, pCreateInfo: nullable *const VkFenceCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pFence: nullable *VkFence) VkResult; +export type fp_vkCreateFramebuffer = fn(device: VkDevice, pCreateInfo: nullable *const VkFramebufferCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pFramebuffer: nullable *VkFramebuffer) VkResult; +export type fp_vkCreateGraphicsPipelines = fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: nullable *const VkGraphicsPipelineCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pPipelines: nullable *VkPipeline) VkResult; +export type fp_vkCreateImage = fn(device: VkDevice, pCreateInfo: nullable *const VkImageCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pImage: nullable *VkImage) VkResult; +export type fp_vkCreateImageView = fn(device: VkDevice, pCreateInfo: nullable *const VkImageViewCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pView: nullable *VkImageView) VkResult; +export type fp_vkCreateInstance = fn(pCreateInfo: nullable *const VkInstanceCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pInstance: nullable *VkInstance) VkResult; +export type fp_vkCreatePipelineCache = fn(device: VkDevice, pCreateInfo: nullable *const VkPipelineCacheCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pPipelineCache: nullable *VkPipelineCache) VkResult; +export type fp_vkCreatePipelineLayout = fn(device: VkDevice, pCreateInfo: nullable *const VkPipelineLayoutCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pPipelineLayout: nullable *VkPipelineLayout) VkResult; +export type fp_vkCreatePrivateDataSlot = fn(device: VkDevice, pCreateInfo: nullable *const VkPrivateDataSlotCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pPrivateDataSlot: nullable *VkPrivateDataSlot) VkResult; +export type fp_vkCreateQueryPool = fn(device: VkDevice, pCreateInfo: nullable *const VkQueryPoolCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pQueryPool: nullable *VkQueryPool) VkResult; +export type fp_vkCreateRenderPass = fn(device: VkDevice, pCreateInfo: nullable *const VkRenderPassCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pRenderPass: nullable *VkRenderPass) VkResult; +export type fp_vkCreateRenderPass2 = fn(device: VkDevice, pCreateInfo: nullable *const VkRenderPassCreateInfo2, pAllocator: nullable *const VkAllocationCallbacks, pRenderPass: nullable *VkRenderPass) VkResult; +export type fp_vkCreateSampler = fn(device: VkDevice, pCreateInfo: nullable *const VkSamplerCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pSampler: nullable *VkSampler) VkResult; +export type fp_vkCreateSamplerYcbcrConversion = fn(device: VkDevice, pCreateInfo: nullable *const VkSamplerYcbcrConversionCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pYcbcrConversion: nullable *VkSamplerYcbcrConversion) VkResult; +export type fp_vkCreateSemaphore = fn(device: VkDevice, pCreateInfo: nullable *const VkSemaphoreCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pSemaphore: nullable *VkSemaphore) VkResult; +export type fp_vkCreateShaderModule = fn(device: VkDevice, pCreateInfo: nullable *const VkShaderModuleCreateInfo, pAllocator: nullable *const VkAllocationCallbacks, pShaderModule: nullable *VkShaderModule) VkResult; +export type fp_vkDestroyBuffer = fn(device: VkDevice, buffer: VkBuffer, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyBufferView = fn(device: VkDevice, bufferView: VkBufferView, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyCommandPool = fn(device: VkDevice, commandPool: VkCommandPool, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyDescriptorPool = fn(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyDescriptorSetLayout = fn(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyDescriptorUpdateTemplate = fn(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyDevice = fn(device: VkDevice, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyEvent = fn(device: VkDevice, event: VkEvent, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyFence = fn(device: VkDevice, fence: VkFence, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyFramebuffer = fn(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyImage = fn(device: VkDevice, image: VkImage, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyImageView = fn(device: VkDevice, imageView: VkImageView, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyInstance = fn(instance: VkInstance, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyPipeline = fn(device: VkDevice, pipeline: VkPipeline, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyPipelineCache = fn(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyPipelineLayout = fn(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyPrivateDataSlot = fn(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyQueryPool = fn(device: VkDevice, queryPool: VkQueryPool, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyRenderPass = fn(device: VkDevice, renderPass: VkRenderPass, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroySampler = fn(device: VkDevice, sampler: VkSampler, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroySamplerYcbcrConversion = fn(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroySemaphore = fn(device: VkDevice, semaphore: VkSemaphore, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDestroyShaderModule = fn(device: VkDevice, shaderModule: VkShaderModule, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkDeviceWaitIdle = fn(device: VkDevice) VkResult; +export type fp_vkEndCommandBuffer = fn(commandBuffer: VkCommandBuffer) VkResult; +export type fp_vkEnumerateDeviceExtensionProperties = fn(physicalDevice: VkPhysicalDevice, pLayerName: nullable *const char, pPropertyCount: nullable *u32, pProperties: nullable *VkExtensionProperties) VkResult; +export type fp_vkEnumerateDeviceLayerProperties = fn(physicalDevice: VkPhysicalDevice, pPropertyCount: nullable *u32, pProperties: nullable *VkLayerProperties) VkResult; +export type fp_vkEnumerateInstanceExtensionProperties = fn(pLayerName: nullable *const char, pPropertyCount: nullable *u32, pProperties: nullable *VkExtensionProperties) VkResult; +export type fp_vkEnumerateInstanceLayerProperties = fn(pPropertyCount: nullable *u32, pProperties: nullable *VkLayerProperties) VkResult; +export type fp_vkEnumerateInstanceVersion = fn(pApiVersion: nullable *u32) VkResult; +export type fp_vkEnumeratePhysicalDeviceGroups = fn(instance: VkInstance, pPhysicalDeviceGroupCount: nullable *u32, pPhysicalDeviceGroupProperties: nullable *VkPhysicalDeviceGroupProperties) VkResult; +export type fp_vkEnumeratePhysicalDevices = fn(instance: VkInstance, pPhysicalDeviceCount: nullable *u32, pPhysicalDevices: nullable *VkPhysicalDevice) VkResult; +export type fp_vkFlushMappedMemoryRanges = fn(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: nullable *const VkMappedMemoryRange) VkResult; +export type fp_vkFreeCommandBuffers = fn(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: u32, pCommandBuffers: nullable *const VkCommandBuffer) void; +export type fp_vkFreeDescriptorSets = fn(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: u32, pDescriptorSets: nullable *const VkDescriptorSet) VkResult; +export type fp_vkFreeMemory = fn(device: VkDevice, memory: VkDeviceMemory, pAllocator: nullable *const VkAllocationCallbacks) void; +export type fp_vkGetBufferDeviceAddress = fn(device: VkDevice, pInfo: nullable *const VkBufferDeviceAddressInfo) VkDeviceAddress; +export type fp_vkGetBufferMemoryRequirements = fn(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: nullable *VkMemoryRequirements) void; +export type fp_vkGetBufferMemoryRequirements2 = fn(device: VkDevice, pInfo: nullable *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: nullable *VkMemoryRequirements2) void; +export type fp_vkGetBufferOpaqueCaptureAddress = fn(device: VkDevice, pInfo: nullable *const VkBufferDeviceAddressInfo) u64; +export type fp_vkGetDescriptorSetLayoutSupport = fn(device: VkDevice, pCreateInfo: nullable *const VkDescriptorSetLayoutCreateInfo, pSupport: nullable *VkDescriptorSetLayoutSupport) void; +export type fp_vkGetDeviceBufferMemoryRequirements = fn(device: VkDevice, pInfo: nullable *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: nullable *VkMemoryRequirements2) void; +export type fp_vkGetDeviceGroupPeerMemoryFeatures = fn(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: nullable *VkPeerMemoryFeatureFlags) void; +export type fp_vkGetDeviceImageMemoryRequirements = fn(device: VkDevice, pInfo: nullable *const VkDeviceImageMemoryRequirements, pMemoryRequirements: nullable *VkMemoryRequirements2) void; +export type fp_vkGetDeviceImageSparseMemoryRequirements = fn(device: VkDevice, pInfo: nullable *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: nullable *u32, pSparseMemoryRequirements: nullable *VkSparseImageMemoryRequirements2) void; +export type fp_vkGetDeviceMemoryCommitment = fn(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: nullable *VkDeviceSize) void; +export type fp_vkGetDeviceMemoryOpaqueCaptureAddress = fn(device: VkDevice, pInfo: nullable *const VkDeviceMemoryOpaqueCaptureAddressInfo) u64; +export type fp_vkGetDeviceProcAddr = fn(device: VkDevice, pName: nullable *const char) PFN_vkVoidFunction; +export type fp_vkGetDeviceQueue = fn(device: VkDevice, queueFamilyIndex: u32, queueIndex: u32, pQueue: nullable *VkQueue) void; +export type fp_vkGetDeviceQueue2 = fn(device: VkDevice, pQueueInfo: nullable *const VkDeviceQueueInfo2, pQueue: nullable *VkQueue) void; +export type fp_vkGetEventStatus = fn(device: VkDevice, event: VkEvent) VkResult; +export type fp_vkGetFenceStatus = fn(device: VkDevice, fence: VkFence) VkResult; +export type fp_vkGetImageMemoryRequirements = fn(device: VkDevice, image: VkImage, pMemoryRequirements: nullable *VkMemoryRequirements) void; +export type fp_vkGetImageMemoryRequirements2 = fn(device: VkDevice, pInfo: nullable *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: nullable *VkMemoryRequirements2) void; +export type fp_vkGetImageSparseMemoryRequirements = fn(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: nullable *u32, pSparseMemoryRequirements: nullable *VkSparseImageMemoryRequirements) void; +export type fp_vkGetImageSparseMemoryRequirements2 = fn(device: VkDevice, pInfo: nullable *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: nullable *u32, pSparseMemoryRequirements: nullable *VkSparseImageMemoryRequirements2) void; +export type fp_vkGetImageSubresourceLayout = fn(device: VkDevice, image: VkImage, pSubresource: nullable *const VkImageSubresource, pLayout: nullable *VkSubresourceLayout) void; +export type fp_vkGetInstanceProcAddr = fn(instance: VkInstance, pName: nullable *const char) PFN_vkVoidFunction; +export type fp_vkGetPhysicalDeviceExternalBufferProperties = fn(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: nullable *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: nullable *VkExternalBufferProperties) void; +export type fp_vkGetPhysicalDeviceExternalFenceProperties = fn(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: nullable *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: nullable *VkExternalFenceProperties) void; +export type fp_vkGetPhysicalDeviceExternalSemaphoreProperties = fn(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: nullable *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: nullable *VkExternalSemaphoreProperties) void; +export type fp_vkGetPhysicalDeviceFeatures = fn(physicalDevice: VkPhysicalDevice, pFeatures: nullable *VkPhysicalDeviceFeatures) void; +export type fp_vkGetPhysicalDeviceFeatures2 = fn(physicalDevice: VkPhysicalDevice, pFeatures: nullable *VkPhysicalDeviceFeatures2) void; +export type fp_vkGetPhysicalDeviceFormatProperties = fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: nullable *VkFormatProperties) void; +export type fp_vkGetPhysicalDeviceFormatProperties2 = fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: nullable *VkFormatProperties2) void; +export type fp_vkGetPhysicalDeviceImageFormatProperties = fn(physicalDevice: VkPhysicalDevice, format: VkFormat, type_: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: nullable *VkImageFormatProperties) VkResult; +export type fp_vkGetPhysicalDeviceImageFormatProperties2 = fn(physicalDevice: VkPhysicalDevice, pImageFormatInfo: nullable *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: nullable *VkImageFormatProperties2) VkResult; +export type fp_vkGetPhysicalDeviceMemoryProperties = fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: nullable *VkPhysicalDeviceMemoryProperties) void; +export type fp_vkGetPhysicalDeviceMemoryProperties2 = fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: nullable *VkPhysicalDeviceMemoryProperties2) void; +export type fp_vkGetPhysicalDeviceProperties = fn(physicalDevice: VkPhysicalDevice, pProperties: nullable *VkPhysicalDeviceProperties) void; +export type fp_vkGetPhysicalDeviceProperties2 = fn(physicalDevice: VkPhysicalDevice, pProperties: nullable *VkPhysicalDeviceProperties2) void; +export type fp_vkGetPhysicalDeviceQueueFamilyProperties = fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: nullable *u32, pQueueFamilyProperties: nullable *VkQueueFamilyProperties) void; +export type fp_vkGetPhysicalDeviceQueueFamilyProperties2 = fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: nullable *u32, pQueueFamilyProperties: nullable *VkQueueFamilyProperties2) void; +export type fp_vkGetPhysicalDeviceSparseImageFormatProperties = fn(physicalDevice: VkPhysicalDevice, format: VkFormat, type_: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: nullable *u32, pProperties: nullable *VkSparseImageFormatProperties) void; +export type fp_vkGetPhysicalDeviceSparseImageFormatProperties2 = fn(physicalDevice: VkPhysicalDevice, pFormatInfo: nullable *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: nullable *u32, pProperties: nullable *VkSparseImageFormatProperties2) void; +export type fp_vkGetPhysicalDeviceToolProperties = fn(physicalDevice: VkPhysicalDevice, pToolCount: nullable *u32, pToolProperties: nullable *VkPhysicalDeviceToolProperties) VkResult; +export type fp_vkGetPipelineCacheData = fn(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: nullable *size, pData: nullable *void) VkResult; +export type fp_vkGetPrivateData = fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: nullable *u64) void; +export type fp_vkGetQueryPoolResults = fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dataSize: size, pData: nullable *void, stride: VkDeviceSize, flags: VkQueryResultFlags) VkResult; +export type fp_vkGetRenderAreaGranularity = fn(device: VkDevice, renderPass: VkRenderPass, pGranularity: nullable *VkExtent2D) void; +export type fp_vkGetSemaphoreCounterValue = fn(device: VkDevice, semaphore: VkSemaphore, pValue: nullable *u64) VkResult; +export type fp_vkInvalidateMappedMemoryRanges = fn(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: nullable *const VkMappedMemoryRange) VkResult; +export type fp_vkMapMemory = fn(device: VkDevice, memory: VkDeviceMemory, offset_: VkDeviceSize, size_: VkDeviceSize, flags: VkMemoryMapFlags, ppData: nullable *nullable *void) VkResult; +export type fp_vkMergePipelineCaches = fn(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: u32, pSrcCaches: nullable *const VkPipelineCache) VkResult; +export type fp_vkQueueBindSparse = fn(queue: VkQueue, bindInfoCount: u32, pBindInfo: nullable *const VkBindSparseInfo, fence: VkFence) VkResult; +export type fp_vkQueueSubmit = fn(queue: VkQueue, submitCount: u32, pSubmits: nullable *const VkSubmitInfo, fence: VkFence) VkResult; +export type fp_vkQueueSubmit2 = fn(queue: VkQueue, submitCount: u32, pSubmits: nullable *const VkSubmitInfo2, fence: VkFence) VkResult; +export type fp_vkQueueWaitIdle = fn(queue: VkQueue) VkResult; +export type fp_vkResetCommandBuffer = fn(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) VkResult; +export type fp_vkResetCommandPool = fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) VkResult; +export type fp_vkResetDescriptorPool = fn(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) VkResult; +export type fp_vkResetEvent = fn(device: VkDevice, event: VkEvent) VkResult; +export type fp_vkResetFences = fn(device: VkDevice, fenceCount: u32, pFences: nullable *const VkFence) VkResult; +export type fp_vkResetQueryPool = fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32) void; +export type fp_vkSetEvent = fn(device: VkDevice, event: VkEvent) VkResult; +export type fp_vkSetPrivateData = fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) VkResult; +export type fp_vkSignalSemaphore = fn(device: VkDevice, pSignalInfo: nullable *const VkSemaphoreSignalInfo) VkResult; +export type fp_vkTrimCommandPool = fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags) void; +export type fp_vkUnmapMemory = fn(device: VkDevice, memory: VkDeviceMemory) void; +export type fp_vkUpdateDescriptorSetWithTemplate = fn(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: nullable *const void) void; +export type fp_vkUpdateDescriptorSets = fn(device: VkDevice, descriptorWriteCount: u32, pDescriptorWrites: nullable *const VkWriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: nullable *const VkCopyDescriptorSet) void; +export type fp_vkWaitForFences = fn(device: VkDevice, fenceCount: u32, pFences: nullable *const VkFence, waitAll: VkBool32, timeout: u64) VkResult; +export type fp_vkWaitSemaphores = fn(device: VkDevice, pWaitInfo: nullable *const VkSemaphoreWaitInfo, timeout: u64) VkResult; + +// Functions +export let vkAllocateCommandBuffers: *fp_vkAllocateCommandBuffers = + null: *fp_vkAllocateCommandBuffers; +export let vkAllocateDescriptorSets: *fp_vkAllocateDescriptorSets = + null: *fp_vkAllocateDescriptorSets; +export let vkAllocateMemory: *fp_vkAllocateMemory = + null: *fp_vkAllocateMemory; +export let vkBeginCommandBuffer: *fp_vkBeginCommandBuffer = + null: *fp_vkBeginCommandBuffer; +export let vkBindBufferMemory: *fp_vkBindBufferMemory = + null: *fp_vkBindBufferMemory; +export let vkBindBufferMemory2: *fp_vkBindBufferMemory2 = + null: *fp_vkBindBufferMemory2; +export let vkBindImageMemory: *fp_vkBindImageMemory = + null: *fp_vkBindImageMemory; +export let vkBindImageMemory2: *fp_vkBindImageMemory2 = + null: *fp_vkBindImageMemory2; +export let vkCmdBeginQuery: *fp_vkCmdBeginQuery = + null: *fp_vkCmdBeginQuery; +export let vkCmdBeginRenderPass: *fp_vkCmdBeginRenderPass = + null: *fp_vkCmdBeginRenderPass; +export let vkCmdBeginRenderPass2: *fp_vkCmdBeginRenderPass2 = + null: *fp_vkCmdBeginRenderPass2; +export let vkCmdBeginRendering: *fp_vkCmdBeginRendering = + null: *fp_vkCmdBeginRendering; +export let vkCmdBindDescriptorSets: *fp_vkCmdBindDescriptorSets = + null: *fp_vkCmdBindDescriptorSets; +export let vkCmdBindIndexBuffer: *fp_vkCmdBindIndexBuffer = + null: *fp_vkCmdBindIndexBuffer; +export let vkCmdBindPipeline: *fp_vkCmdBindPipeline = + null: *fp_vkCmdBindPipeline; +export let vkCmdBindVertexBuffers: *fp_vkCmdBindVertexBuffers = + null: *fp_vkCmdBindVertexBuffers; +export let vkCmdBindVertexBuffers2: *fp_vkCmdBindVertexBuffers2 = + null: *fp_vkCmdBindVertexBuffers2; +export let vkCmdBlitImage: *fp_vkCmdBlitImage = + null: *fp_vkCmdBlitImage; +export let vkCmdBlitImage2: *fp_vkCmdBlitImage2 = + null: *fp_vkCmdBlitImage2; +export let vkCmdClearAttachments: *fp_vkCmdClearAttachments = + null: *fp_vkCmdClearAttachments; +export let vkCmdClearColorImage: *fp_vkCmdClearColorImage = + null: *fp_vkCmdClearColorImage; +export let vkCmdClearDepthStencilImage: *fp_vkCmdClearDepthStencilImage = + null: *fp_vkCmdClearDepthStencilImage; +export let vkCmdCopyBuffer: *fp_vkCmdCopyBuffer = + null: *fp_vkCmdCopyBuffer; +export let vkCmdCopyBuffer2: *fp_vkCmdCopyBuffer2 = + null: *fp_vkCmdCopyBuffer2; +export let vkCmdCopyBufferToImage: *fp_vkCmdCopyBufferToImage = + null: *fp_vkCmdCopyBufferToImage; +export let vkCmdCopyBufferToImage2: *fp_vkCmdCopyBufferToImage2 = + null: *fp_vkCmdCopyBufferToImage2; +export let vkCmdCopyImage: *fp_vkCmdCopyImage = + null: *fp_vkCmdCopyImage; +export let vkCmdCopyImage2: *fp_vkCmdCopyImage2 = + null: *fp_vkCmdCopyImage2; +export let vkCmdCopyImageToBuffer: *fp_vkCmdCopyImageToBuffer = + null: *fp_vkCmdCopyImageToBuffer; +export let vkCmdCopyImageToBuffer2: *fp_vkCmdCopyImageToBuffer2 = + null: *fp_vkCmdCopyImageToBuffer2; +export let vkCmdCopyQueryPoolResults: *fp_vkCmdCopyQueryPoolResults = + null: *fp_vkCmdCopyQueryPoolResults; +export let vkCmdDispatch: *fp_vkCmdDispatch = + null: *fp_vkCmdDispatch; +export let vkCmdDispatchBase: *fp_vkCmdDispatchBase = + null: *fp_vkCmdDispatchBase; +export let vkCmdDispatchIndirect: *fp_vkCmdDispatchIndirect = + null: *fp_vkCmdDispatchIndirect; +export let vkCmdDraw: *fp_vkCmdDraw = + null: *fp_vkCmdDraw; +export let vkCmdDrawIndexed: *fp_vkCmdDrawIndexed = + null: *fp_vkCmdDrawIndexed; +export let vkCmdDrawIndexedIndirect: *fp_vkCmdDrawIndexedIndirect = + null: *fp_vkCmdDrawIndexedIndirect; +export let vkCmdDrawIndexedIndirectCount: *fp_vkCmdDrawIndexedIndirectCount = + null: *fp_vkCmdDrawIndexedIndirectCount; +export let vkCmdDrawIndirect: *fp_vkCmdDrawIndirect = + null: *fp_vkCmdDrawIndirect; +export let vkCmdDrawIndirectCount: *fp_vkCmdDrawIndirectCount = + null: *fp_vkCmdDrawIndirectCount; +export let vkCmdEndQuery: *fp_vkCmdEndQuery = + null: *fp_vkCmdEndQuery; +export let vkCmdEndRenderPass: *fp_vkCmdEndRenderPass = + null: *fp_vkCmdEndRenderPass; +export let vkCmdEndRenderPass2: *fp_vkCmdEndRenderPass2 = + null: *fp_vkCmdEndRenderPass2; +export let vkCmdEndRendering: *fp_vkCmdEndRendering = + null: *fp_vkCmdEndRendering; +export let vkCmdExecuteCommands: *fp_vkCmdExecuteCommands = + null: *fp_vkCmdExecuteCommands; +export let vkCmdFillBuffer: *fp_vkCmdFillBuffer = + null: *fp_vkCmdFillBuffer; +export let vkCmdNextSubpass: *fp_vkCmdNextSubpass = + null: *fp_vkCmdNextSubpass; +export let vkCmdNextSubpass2: *fp_vkCmdNextSubpass2 = + null: *fp_vkCmdNextSubpass2; +export let vkCmdPipelineBarrier: *fp_vkCmdPipelineBarrier = + null: *fp_vkCmdPipelineBarrier; +export let vkCmdPipelineBarrier2: *fp_vkCmdPipelineBarrier2 = + null: *fp_vkCmdPipelineBarrier2; +export let vkCmdPushConstants: *fp_vkCmdPushConstants = + null: *fp_vkCmdPushConstants; +export let vkCmdResetEvent: *fp_vkCmdResetEvent = + null: *fp_vkCmdResetEvent; +export let vkCmdResetEvent2: *fp_vkCmdResetEvent2 = + null: *fp_vkCmdResetEvent2; +export let vkCmdResetQueryPool: *fp_vkCmdResetQueryPool = + null: *fp_vkCmdResetQueryPool; +export let vkCmdResolveImage: *fp_vkCmdResolveImage = + null: *fp_vkCmdResolveImage; +export let vkCmdResolveImage2: *fp_vkCmdResolveImage2 = + null: *fp_vkCmdResolveImage2; +export let vkCmdSetBlendConstants: *fp_vkCmdSetBlendConstants = + null: *fp_vkCmdSetBlendConstants; +export let vkCmdSetCullMode: *fp_vkCmdSetCullMode = + null: *fp_vkCmdSetCullMode; +export let vkCmdSetDepthBias: *fp_vkCmdSetDepthBias = + null: *fp_vkCmdSetDepthBias; +export let vkCmdSetDepthBiasEnable: *fp_vkCmdSetDepthBiasEnable = + null: *fp_vkCmdSetDepthBiasEnable; +export let vkCmdSetDepthBounds: *fp_vkCmdSetDepthBounds = + null: *fp_vkCmdSetDepthBounds; +export let vkCmdSetDepthBoundsTestEnable: *fp_vkCmdSetDepthBoundsTestEnable = + null: *fp_vkCmdSetDepthBoundsTestEnable; +export let vkCmdSetDepthCompareOp: *fp_vkCmdSetDepthCompareOp = + null: *fp_vkCmdSetDepthCompareOp; +export let vkCmdSetDepthTestEnable: *fp_vkCmdSetDepthTestEnable = + null: *fp_vkCmdSetDepthTestEnable; +export let vkCmdSetDepthWriteEnable: *fp_vkCmdSetDepthWriteEnable = + null: *fp_vkCmdSetDepthWriteEnable; +export let vkCmdSetDeviceMask: *fp_vkCmdSetDeviceMask = + null: *fp_vkCmdSetDeviceMask; +export let vkCmdSetEvent: *fp_vkCmdSetEvent = + null: *fp_vkCmdSetEvent; +export let vkCmdSetEvent2: *fp_vkCmdSetEvent2 = + null: *fp_vkCmdSetEvent2; +export let vkCmdSetFrontFace: *fp_vkCmdSetFrontFace = + null: *fp_vkCmdSetFrontFace; +export let vkCmdSetLineWidth: *fp_vkCmdSetLineWidth = + null: *fp_vkCmdSetLineWidth; +export let vkCmdSetPrimitiveRestartEnable: *fp_vkCmdSetPrimitiveRestartEnable = + null: *fp_vkCmdSetPrimitiveRestartEnable; +export let vkCmdSetPrimitiveTopology: *fp_vkCmdSetPrimitiveTopology = + null: *fp_vkCmdSetPrimitiveTopology; +export let vkCmdSetRasterizerDiscardEnable: *fp_vkCmdSetRasterizerDiscardEnable = + null: *fp_vkCmdSetRasterizerDiscardEnable; +export let vkCmdSetScissor: *fp_vkCmdSetScissor = + null: *fp_vkCmdSetScissor; +export let vkCmdSetScissorWithCount: *fp_vkCmdSetScissorWithCount = + null: *fp_vkCmdSetScissorWithCount; +export let vkCmdSetStencilCompareMask: *fp_vkCmdSetStencilCompareMask = + null: *fp_vkCmdSetStencilCompareMask; +export let vkCmdSetStencilOp: *fp_vkCmdSetStencilOp = + null: *fp_vkCmdSetStencilOp; +export let vkCmdSetStencilReference: *fp_vkCmdSetStencilReference = + null: *fp_vkCmdSetStencilReference; +export let vkCmdSetStencilTestEnable: *fp_vkCmdSetStencilTestEnable = + null: *fp_vkCmdSetStencilTestEnable; +export let vkCmdSetStencilWriteMask: *fp_vkCmdSetStencilWriteMask = + null: *fp_vkCmdSetStencilWriteMask; +export let vkCmdSetViewport: *fp_vkCmdSetViewport = + null: *fp_vkCmdSetViewport; +export let vkCmdSetViewportWithCount: *fp_vkCmdSetViewportWithCount = + null: *fp_vkCmdSetViewportWithCount; +export let vkCmdUpdateBuffer: *fp_vkCmdUpdateBuffer = + null: *fp_vkCmdUpdateBuffer; +export let vkCmdWaitEvents: *fp_vkCmdWaitEvents = + null: *fp_vkCmdWaitEvents; +export let vkCmdWaitEvents2: *fp_vkCmdWaitEvents2 = + null: *fp_vkCmdWaitEvents2; +export let vkCmdWriteTimestamp: *fp_vkCmdWriteTimestamp = + null: *fp_vkCmdWriteTimestamp; +export let vkCmdWriteTimestamp2: *fp_vkCmdWriteTimestamp2 = + null: *fp_vkCmdWriteTimestamp2; +export let vkCreateBuffer: *fp_vkCreateBuffer = + null: *fp_vkCreateBuffer; +export let vkCreateBufferView: *fp_vkCreateBufferView = + null: *fp_vkCreateBufferView; +export let vkCreateCommandPool: *fp_vkCreateCommandPool = + null: *fp_vkCreateCommandPool; +export let vkCreateComputePipelines: *fp_vkCreateComputePipelines = + null: *fp_vkCreateComputePipelines; +export let vkCreateDescriptorPool: *fp_vkCreateDescriptorPool = + null: *fp_vkCreateDescriptorPool; +export let vkCreateDescriptorSetLayout: *fp_vkCreateDescriptorSetLayout = + null: *fp_vkCreateDescriptorSetLayout; +export let vkCreateDescriptorUpdateTemplate: *fp_vkCreateDescriptorUpdateTemplate = + null: *fp_vkCreateDescriptorUpdateTemplate; +export let vkCreateDevice: *fp_vkCreateDevice = + null: *fp_vkCreateDevice; +export let vkCreateEvent: *fp_vkCreateEvent = + null: *fp_vkCreateEvent; +export let vkCreateFence: *fp_vkCreateFence = + null: *fp_vkCreateFence; +export let vkCreateFramebuffer: *fp_vkCreateFramebuffer = + null: *fp_vkCreateFramebuffer; +export let vkCreateGraphicsPipelines: *fp_vkCreateGraphicsPipelines = + null: *fp_vkCreateGraphicsPipelines; +export let vkCreateImage: *fp_vkCreateImage = + null: *fp_vkCreateImage; +export let vkCreateImageView: *fp_vkCreateImageView = + null: *fp_vkCreateImageView; +export let vkCreateInstance: *fp_vkCreateInstance = + null: *fp_vkCreateInstance; +export let vkCreatePipelineCache: *fp_vkCreatePipelineCache = + null: *fp_vkCreatePipelineCache; +export let vkCreatePipelineLayout: *fp_vkCreatePipelineLayout = + null: *fp_vkCreatePipelineLayout; +export let vkCreatePrivateDataSlot: *fp_vkCreatePrivateDataSlot = + null: *fp_vkCreatePrivateDataSlot; +export let vkCreateQueryPool: *fp_vkCreateQueryPool = + null: *fp_vkCreateQueryPool; +export let vkCreateRenderPass: *fp_vkCreateRenderPass = + null: *fp_vkCreateRenderPass; +export let vkCreateRenderPass2: *fp_vkCreateRenderPass2 = + null: *fp_vkCreateRenderPass2; +export let vkCreateSampler: *fp_vkCreateSampler = + null: *fp_vkCreateSampler; +export let vkCreateSamplerYcbcrConversion: *fp_vkCreateSamplerYcbcrConversion = + null: *fp_vkCreateSamplerYcbcrConversion; +export let vkCreateSemaphore: *fp_vkCreateSemaphore = + null: *fp_vkCreateSemaphore; +export let vkCreateShaderModule: *fp_vkCreateShaderModule = + null: *fp_vkCreateShaderModule; +export let vkDestroyBuffer: *fp_vkDestroyBuffer = + null: *fp_vkDestroyBuffer; +export let vkDestroyBufferView: *fp_vkDestroyBufferView = + null: *fp_vkDestroyBufferView; +export let vkDestroyCommandPool: *fp_vkDestroyCommandPool = + null: *fp_vkDestroyCommandPool; +export let vkDestroyDescriptorPool: *fp_vkDestroyDescriptorPool = + null: *fp_vkDestroyDescriptorPool; +export let vkDestroyDescriptorSetLayout: *fp_vkDestroyDescriptorSetLayout = + null: *fp_vkDestroyDescriptorSetLayout; +export let vkDestroyDescriptorUpdateTemplate: *fp_vkDestroyDescriptorUpdateTemplate = + null: *fp_vkDestroyDescriptorUpdateTemplate; +export let vkDestroyDevice: *fp_vkDestroyDevice = + null: *fp_vkDestroyDevice; +export let vkDestroyEvent: *fp_vkDestroyEvent = + null: *fp_vkDestroyEvent; +export let vkDestroyFence: *fp_vkDestroyFence = + null: *fp_vkDestroyFence; +export let vkDestroyFramebuffer: *fp_vkDestroyFramebuffer = + null: *fp_vkDestroyFramebuffer; +export let vkDestroyImage: *fp_vkDestroyImage = + null: *fp_vkDestroyImage; +export let vkDestroyImageView: *fp_vkDestroyImageView = + null: *fp_vkDestroyImageView; +export let vkDestroyInstance: *fp_vkDestroyInstance = + null: *fp_vkDestroyInstance; +export let vkDestroyPipeline: *fp_vkDestroyPipeline = + null: *fp_vkDestroyPipeline; +export let vkDestroyPipelineCache: *fp_vkDestroyPipelineCache = + null: *fp_vkDestroyPipelineCache; +export let vkDestroyPipelineLayout: *fp_vkDestroyPipelineLayout = + null: *fp_vkDestroyPipelineLayout; +export let vkDestroyPrivateDataSlot: *fp_vkDestroyPrivateDataSlot = + null: *fp_vkDestroyPrivateDataSlot; +export let vkDestroyQueryPool: *fp_vkDestroyQueryPool = + null: *fp_vkDestroyQueryPool; +export let vkDestroyRenderPass: *fp_vkDestroyRenderPass = + null: *fp_vkDestroyRenderPass; +export let vkDestroySampler: *fp_vkDestroySampler = + null: *fp_vkDestroySampler; +export let vkDestroySamplerYcbcrConversion: *fp_vkDestroySamplerYcbcrConversion = + null: *fp_vkDestroySamplerYcbcrConversion; +export let vkDestroySemaphore: *fp_vkDestroySemaphore = + null: *fp_vkDestroySemaphore; +export let vkDestroyShaderModule: *fp_vkDestroyShaderModule = + null: *fp_vkDestroyShaderModule; +export let vkDeviceWaitIdle: *fp_vkDeviceWaitIdle = + null: *fp_vkDeviceWaitIdle; +export let vkEndCommandBuffer: *fp_vkEndCommandBuffer = + null: *fp_vkEndCommandBuffer; +export let vkEnumerateDeviceExtensionProperties: *fp_vkEnumerateDeviceExtensionProperties = + null: *fp_vkEnumerateDeviceExtensionProperties; +export let vkEnumerateDeviceLayerProperties: *fp_vkEnumerateDeviceLayerProperties = + null: *fp_vkEnumerateDeviceLayerProperties; +export let vkEnumerateInstanceExtensionProperties: *fp_vkEnumerateInstanceExtensionProperties = + null: *fp_vkEnumerateInstanceExtensionProperties; +export let vkEnumerateInstanceLayerProperties: *fp_vkEnumerateInstanceLayerProperties = + null: *fp_vkEnumerateInstanceLayerProperties; +export let vkEnumerateInstanceVersion: *fp_vkEnumerateInstanceVersion = + null: *fp_vkEnumerateInstanceVersion; +export let vkEnumeratePhysicalDeviceGroups: *fp_vkEnumeratePhysicalDeviceGroups = + null: *fp_vkEnumeratePhysicalDeviceGroups; +export let vkEnumeratePhysicalDevices: *fp_vkEnumeratePhysicalDevices = + null: *fp_vkEnumeratePhysicalDevices; +export let vkFlushMappedMemoryRanges: *fp_vkFlushMappedMemoryRanges = + null: *fp_vkFlushMappedMemoryRanges; +export let vkFreeCommandBuffers: *fp_vkFreeCommandBuffers = + null: *fp_vkFreeCommandBuffers; +export let vkFreeDescriptorSets: *fp_vkFreeDescriptorSets = + null: *fp_vkFreeDescriptorSets; +export let vkFreeMemory: *fp_vkFreeMemory = + null: *fp_vkFreeMemory; +export let vkGetBufferDeviceAddress: *fp_vkGetBufferDeviceAddress = + null: *fp_vkGetBufferDeviceAddress; +export let vkGetBufferMemoryRequirements: *fp_vkGetBufferMemoryRequirements = + null: *fp_vkGetBufferMemoryRequirements; +export let vkGetBufferMemoryRequirements2: *fp_vkGetBufferMemoryRequirements2 = + null: *fp_vkGetBufferMemoryRequirements2; +export let vkGetBufferOpaqueCaptureAddress: *fp_vkGetBufferOpaqueCaptureAddress = + null: *fp_vkGetBufferOpaqueCaptureAddress; +export let vkGetDescriptorSetLayoutSupport: *fp_vkGetDescriptorSetLayoutSupport = + null: *fp_vkGetDescriptorSetLayoutSupport; +export let vkGetDeviceBufferMemoryRequirements: *fp_vkGetDeviceBufferMemoryRequirements = + null: *fp_vkGetDeviceBufferMemoryRequirements; +export let vkGetDeviceGroupPeerMemoryFeatures: *fp_vkGetDeviceGroupPeerMemoryFeatures = + null: *fp_vkGetDeviceGroupPeerMemoryFeatures; +export let vkGetDeviceImageMemoryRequirements: *fp_vkGetDeviceImageMemoryRequirements = + null: *fp_vkGetDeviceImageMemoryRequirements; +export let vkGetDeviceImageSparseMemoryRequirements: *fp_vkGetDeviceImageSparseMemoryRequirements = + null: *fp_vkGetDeviceImageSparseMemoryRequirements; +export let vkGetDeviceMemoryCommitment: *fp_vkGetDeviceMemoryCommitment = + null: *fp_vkGetDeviceMemoryCommitment; +export let vkGetDeviceMemoryOpaqueCaptureAddress: *fp_vkGetDeviceMemoryOpaqueCaptureAddress = + null: *fp_vkGetDeviceMemoryOpaqueCaptureAddress; +export let vkGetDeviceProcAddr: *fp_vkGetDeviceProcAddr = + null: *fp_vkGetDeviceProcAddr; +export let vkGetDeviceQueue: *fp_vkGetDeviceQueue = + null: *fp_vkGetDeviceQueue; +export let vkGetDeviceQueue2: *fp_vkGetDeviceQueue2 = + null: *fp_vkGetDeviceQueue2; +export let vkGetEventStatus: *fp_vkGetEventStatus = + null: *fp_vkGetEventStatus; +export let vkGetFenceStatus: *fp_vkGetFenceStatus = + null: *fp_vkGetFenceStatus; +export let vkGetImageMemoryRequirements: *fp_vkGetImageMemoryRequirements = + null: *fp_vkGetImageMemoryRequirements; +export let vkGetImageMemoryRequirements2: *fp_vkGetImageMemoryRequirements2 = + null: *fp_vkGetImageMemoryRequirements2; +export let vkGetImageSparseMemoryRequirements: *fp_vkGetImageSparseMemoryRequirements = + null: *fp_vkGetImageSparseMemoryRequirements; +export let vkGetImageSparseMemoryRequirements2: *fp_vkGetImageSparseMemoryRequirements2 = + null: *fp_vkGetImageSparseMemoryRequirements2; +export let vkGetImageSubresourceLayout: *fp_vkGetImageSubresourceLayout = + null: *fp_vkGetImageSubresourceLayout; +export let vkGetInstanceProcAddr: *fp_vkGetInstanceProcAddr = + null: *fp_vkGetInstanceProcAddr; +export let vkGetPhysicalDeviceExternalBufferProperties: *fp_vkGetPhysicalDeviceExternalBufferProperties = + null: *fp_vkGetPhysicalDeviceExternalBufferProperties; +export let vkGetPhysicalDeviceExternalFenceProperties: *fp_vkGetPhysicalDeviceExternalFenceProperties = + null: *fp_vkGetPhysicalDeviceExternalFenceProperties; +export let vkGetPhysicalDeviceExternalSemaphoreProperties: *fp_vkGetPhysicalDeviceExternalSemaphoreProperties = + null: *fp_vkGetPhysicalDeviceExternalSemaphoreProperties; +export let vkGetPhysicalDeviceFeatures: *fp_vkGetPhysicalDeviceFeatures = + null: *fp_vkGetPhysicalDeviceFeatures; +export let vkGetPhysicalDeviceFeatures2: *fp_vkGetPhysicalDeviceFeatures2 = + null: *fp_vkGetPhysicalDeviceFeatures2; +export let vkGetPhysicalDeviceFormatProperties: *fp_vkGetPhysicalDeviceFormatProperties = + null: *fp_vkGetPhysicalDeviceFormatProperties; +export let vkGetPhysicalDeviceFormatProperties2: *fp_vkGetPhysicalDeviceFormatProperties2 = + null: *fp_vkGetPhysicalDeviceFormatProperties2; +export let vkGetPhysicalDeviceImageFormatProperties: *fp_vkGetPhysicalDeviceImageFormatProperties = + null: *fp_vkGetPhysicalDeviceImageFormatProperties; +export let vkGetPhysicalDeviceImageFormatProperties2: *fp_vkGetPhysicalDeviceImageFormatProperties2 = + null: *fp_vkGetPhysicalDeviceImageFormatProperties2; +export let vkGetPhysicalDeviceMemoryProperties: *fp_vkGetPhysicalDeviceMemoryProperties = + null: *fp_vkGetPhysicalDeviceMemoryProperties; +export let vkGetPhysicalDeviceMemoryProperties2: *fp_vkGetPhysicalDeviceMemoryProperties2 = + null: *fp_vkGetPhysicalDeviceMemoryProperties2; +export let vkGetPhysicalDeviceProperties: *fp_vkGetPhysicalDeviceProperties = + null: *fp_vkGetPhysicalDeviceProperties; +export let vkGetPhysicalDeviceProperties2: *fp_vkGetPhysicalDeviceProperties2 = + null: *fp_vkGetPhysicalDeviceProperties2; +export let vkGetPhysicalDeviceQueueFamilyProperties: *fp_vkGetPhysicalDeviceQueueFamilyProperties = + null: *fp_vkGetPhysicalDeviceQueueFamilyProperties; +export let vkGetPhysicalDeviceQueueFamilyProperties2: *fp_vkGetPhysicalDeviceQueueFamilyProperties2 = + null: *fp_vkGetPhysicalDeviceQueueFamilyProperties2; +export let vkGetPhysicalDeviceSparseImageFormatProperties: *fp_vkGetPhysicalDeviceSparseImageFormatProperties = + null: *fp_vkGetPhysicalDeviceSparseImageFormatProperties; +export let vkGetPhysicalDeviceSparseImageFormatProperties2: *fp_vkGetPhysicalDeviceSparseImageFormatProperties2 = + null: *fp_vkGetPhysicalDeviceSparseImageFormatProperties2; +export let vkGetPhysicalDeviceToolProperties: *fp_vkGetPhysicalDeviceToolProperties = + null: *fp_vkGetPhysicalDeviceToolProperties; +export let vkGetPipelineCacheData: *fp_vkGetPipelineCacheData = + null: *fp_vkGetPipelineCacheData; +export let vkGetPrivateData: *fp_vkGetPrivateData = + null: *fp_vkGetPrivateData; +export let vkGetQueryPoolResults: *fp_vkGetQueryPoolResults = + null: *fp_vkGetQueryPoolResults; +export let vkGetRenderAreaGranularity: *fp_vkGetRenderAreaGranularity = + null: *fp_vkGetRenderAreaGranularity; +export let vkGetSemaphoreCounterValue: *fp_vkGetSemaphoreCounterValue = + null: *fp_vkGetSemaphoreCounterValue; +export let vkInvalidateMappedMemoryRanges: *fp_vkInvalidateMappedMemoryRanges = + null: *fp_vkInvalidateMappedMemoryRanges; +export let vkMapMemory: *fp_vkMapMemory = + null: *fp_vkMapMemory; +export let vkMergePipelineCaches: *fp_vkMergePipelineCaches = + null: *fp_vkMergePipelineCaches; +export let vkQueueBindSparse: *fp_vkQueueBindSparse = + null: *fp_vkQueueBindSparse; +export let vkQueueSubmit: *fp_vkQueueSubmit = + null: *fp_vkQueueSubmit; +export let vkQueueSubmit2: *fp_vkQueueSubmit2 = + null: *fp_vkQueueSubmit2; +export let vkQueueWaitIdle: *fp_vkQueueWaitIdle = + null: *fp_vkQueueWaitIdle; +export let vkResetCommandBuffer: *fp_vkResetCommandBuffer = + null: *fp_vkResetCommandBuffer; +export let vkResetCommandPool: *fp_vkResetCommandPool = + null: *fp_vkResetCommandPool; +export let vkResetDescriptorPool: *fp_vkResetDescriptorPool = + null: *fp_vkResetDescriptorPool; +export let vkResetEvent: *fp_vkResetEvent = + null: *fp_vkResetEvent; +export let vkResetFences: *fp_vkResetFences = + null: *fp_vkResetFences; +export let vkResetQueryPool: *fp_vkResetQueryPool = + null: *fp_vkResetQueryPool; +export let vkSetEvent: *fp_vkSetEvent = + null: *fp_vkSetEvent; +export let vkSetPrivateData: *fp_vkSetPrivateData = + null: *fp_vkSetPrivateData; +export let vkSignalSemaphore: *fp_vkSignalSemaphore = + null: *fp_vkSignalSemaphore; +export let vkTrimCommandPool: *fp_vkTrimCommandPool = + null: *fp_vkTrimCommandPool; +export let vkUnmapMemory: *fp_vkUnmapMemory = + null: *fp_vkUnmapMemory; +export let vkUpdateDescriptorSetWithTemplate: *fp_vkUpdateDescriptorSetWithTemplate = + null: *fp_vkUpdateDescriptorSetWithTemplate; +export let vkUpdateDescriptorSets: *fp_vkUpdateDescriptorSets = + null: *fp_vkUpdateDescriptorSets; +export let vkWaitForFences: *fp_vkWaitForFences = + null: *fp_vkWaitForFences; +export let vkWaitSemaphores: *fp_vkWaitSemaphores = + null: *fp_vkWaitSemaphores; + +// Function loading with built-in loader +export fn load_loader() void = { + vkCreateInstance = get_instance_proc_address(null, "vkCreateInstance\0"): *fp_vkCreateInstance; + vkEnumerateInstanceExtensionProperties = get_instance_proc_address(null, "vkEnumerateInstanceExtensionProperties\0"): *fp_vkEnumerateInstanceExtensionProperties; + vkEnumerateInstanceLayerProperties = get_instance_proc_address(null, "vkEnumerateInstanceLayerProperties\0"): *fp_vkEnumerateInstanceLayerProperties; + vkEnumerateInstanceVersion = get_instance_proc_address(null, "vkEnumerateInstanceVersion\0"): *fp_vkEnumerateInstanceVersion; +}; + +export fn load_instance(instance: VkInstance) void = { + vkCreateDevice = get_instance_proc_address(instance, "vkCreateDevice\0"): *fp_vkCreateDevice; + vkDestroyInstance = get_instance_proc_address(instance, "vkDestroyInstance\0"): *fp_vkDestroyInstance; + vkEnumerateDeviceExtensionProperties = get_instance_proc_address(instance, "vkEnumerateDeviceExtensionProperties\0"): *fp_vkEnumerateDeviceExtensionProperties; + vkEnumerateDeviceLayerProperties = get_instance_proc_address(instance, "vkEnumerateDeviceLayerProperties\0"): *fp_vkEnumerateDeviceLayerProperties; + vkEnumeratePhysicalDeviceGroups = get_instance_proc_address(instance, "vkEnumeratePhysicalDeviceGroups\0"): *fp_vkEnumeratePhysicalDeviceGroups; + vkEnumeratePhysicalDevices = get_instance_proc_address(instance, "vkEnumeratePhysicalDevices\0"): *fp_vkEnumeratePhysicalDevices; + vkGetInstanceProcAddr = get_instance_proc_address(instance, "vkGetInstanceProcAddr\0"): *fp_vkGetInstanceProcAddr; + vkGetPhysicalDeviceExternalBufferProperties = get_instance_proc_address(instance, "vkGetPhysicalDeviceExternalBufferProperties\0"): *fp_vkGetPhysicalDeviceExternalBufferProperties; + vkGetPhysicalDeviceExternalFenceProperties = get_instance_proc_address(instance, "vkGetPhysicalDeviceExternalFenceProperties\0"): *fp_vkGetPhysicalDeviceExternalFenceProperties; + vkGetPhysicalDeviceExternalSemaphoreProperties = get_instance_proc_address(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties\0"): *fp_vkGetPhysicalDeviceExternalSemaphoreProperties; + vkGetPhysicalDeviceFeatures = get_instance_proc_address(instance, "vkGetPhysicalDeviceFeatures\0"): *fp_vkGetPhysicalDeviceFeatures; + vkGetPhysicalDeviceFeatures2 = get_instance_proc_address(instance, "vkGetPhysicalDeviceFeatures2\0"): *fp_vkGetPhysicalDeviceFeatures2; + vkGetPhysicalDeviceFormatProperties = get_instance_proc_address(instance, "vkGetPhysicalDeviceFormatProperties\0"): *fp_vkGetPhysicalDeviceFormatProperties; + vkGetPhysicalDeviceFormatProperties2 = get_instance_proc_address(instance, "vkGetPhysicalDeviceFormatProperties2\0"): *fp_vkGetPhysicalDeviceFormatProperties2; + vkGetPhysicalDeviceImageFormatProperties = get_instance_proc_address(instance, "vkGetPhysicalDeviceImageFormatProperties\0"): *fp_vkGetPhysicalDeviceImageFormatProperties; + vkGetPhysicalDeviceImageFormatProperties2 = get_instance_proc_address(instance, "vkGetPhysicalDeviceImageFormatProperties2\0"): *fp_vkGetPhysicalDeviceImageFormatProperties2; + vkGetPhysicalDeviceMemoryProperties = get_instance_proc_address(instance, "vkGetPhysicalDeviceMemoryProperties\0"): *fp_vkGetPhysicalDeviceMemoryProperties; + vkGetPhysicalDeviceMemoryProperties2 = get_instance_proc_address(instance, "vkGetPhysicalDeviceMemoryProperties2\0"): *fp_vkGetPhysicalDeviceMemoryProperties2; + vkGetPhysicalDeviceProperties = get_instance_proc_address(instance, "vkGetPhysicalDeviceProperties\0"): *fp_vkGetPhysicalDeviceProperties; + vkGetPhysicalDeviceProperties2 = get_instance_proc_address(instance, "vkGetPhysicalDeviceProperties2\0"): *fp_vkGetPhysicalDeviceProperties2; + vkGetPhysicalDeviceQueueFamilyProperties = get_instance_proc_address(instance, "vkGetPhysicalDeviceQueueFamilyProperties\0"): *fp_vkGetPhysicalDeviceQueueFamilyProperties; + vkGetPhysicalDeviceQueueFamilyProperties2 = get_instance_proc_address(instance, "vkGetPhysicalDeviceQueueFamilyProperties2\0"): *fp_vkGetPhysicalDeviceQueueFamilyProperties2; + vkGetPhysicalDeviceSparseImageFormatProperties = get_instance_proc_address(instance, "vkGetPhysicalDeviceSparseImageFormatProperties\0"): *fp_vkGetPhysicalDeviceSparseImageFormatProperties; + vkGetPhysicalDeviceSparseImageFormatProperties2 = get_instance_proc_address(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2\0"): *fp_vkGetPhysicalDeviceSparseImageFormatProperties2; + vkGetPhysicalDeviceToolProperties = get_instance_proc_address(instance, "vkGetPhysicalDeviceToolProperties\0"): *fp_vkGetPhysicalDeviceToolProperties; +}; + +export fn load_device(device: VkDevice) void = { + vkAllocateCommandBuffers = get_device_proc_address(device, "vkAllocateCommandBuffers\0"): *fp_vkAllocateCommandBuffers; + vkAllocateDescriptorSets = get_device_proc_address(device, "vkAllocateDescriptorSets\0"): *fp_vkAllocateDescriptorSets; + vkAllocateMemory = get_device_proc_address(device, "vkAllocateMemory\0"): *fp_vkAllocateMemory; + vkBeginCommandBuffer = get_device_proc_address(device, "vkBeginCommandBuffer\0"): *fp_vkBeginCommandBuffer; + vkBindBufferMemory = get_device_proc_address(device, "vkBindBufferMemory\0"): *fp_vkBindBufferMemory; + vkBindBufferMemory2 = get_device_proc_address(device, "vkBindBufferMemory2\0"): *fp_vkBindBufferMemory2; + vkBindImageMemory = get_device_proc_address(device, "vkBindImageMemory\0"): *fp_vkBindImageMemory; + vkBindImageMemory2 = get_device_proc_address(device, "vkBindImageMemory2\0"): *fp_vkBindImageMemory2; + vkCmdBeginQuery = get_device_proc_address(device, "vkCmdBeginQuery\0"): *fp_vkCmdBeginQuery; + vkCmdBeginRenderPass = get_device_proc_address(device, "vkCmdBeginRenderPass\0"): *fp_vkCmdBeginRenderPass; + vkCmdBeginRenderPass2 = get_device_proc_address(device, "vkCmdBeginRenderPass2\0"): *fp_vkCmdBeginRenderPass2; + vkCmdBeginRendering = get_device_proc_address(device, "vkCmdBeginRendering\0"): *fp_vkCmdBeginRendering; + vkCmdBindDescriptorSets = get_device_proc_address(device, "vkCmdBindDescriptorSets\0"): *fp_vkCmdBindDescriptorSets; + vkCmdBindIndexBuffer = get_device_proc_address(device, "vkCmdBindIndexBuffer\0"): *fp_vkCmdBindIndexBuffer; + vkCmdBindPipeline = get_device_proc_address(device, "vkCmdBindPipeline\0"): *fp_vkCmdBindPipeline; + vkCmdBindVertexBuffers = get_device_proc_address(device, "vkCmdBindVertexBuffers\0"): *fp_vkCmdBindVertexBuffers; + vkCmdBindVertexBuffers2 = get_device_proc_address(device, "vkCmdBindVertexBuffers2\0"): *fp_vkCmdBindVertexBuffers2; + vkCmdBlitImage = get_device_proc_address(device, "vkCmdBlitImage\0"): *fp_vkCmdBlitImage; + vkCmdBlitImage2 = get_device_proc_address(device, "vkCmdBlitImage2\0"): *fp_vkCmdBlitImage2; + vkCmdClearAttachments = get_device_proc_address(device, "vkCmdClearAttachments\0"): *fp_vkCmdClearAttachments; + vkCmdClearColorImage = get_device_proc_address(device, "vkCmdClearColorImage\0"): *fp_vkCmdClearColorImage; + vkCmdClearDepthStencilImage = get_device_proc_address(device, "vkCmdClearDepthStencilImage\0"): *fp_vkCmdClearDepthStencilImage; + vkCmdCopyBuffer = get_device_proc_address(device, "vkCmdCopyBuffer\0"): *fp_vkCmdCopyBuffer; + vkCmdCopyBuffer2 = get_device_proc_address(device, "vkCmdCopyBuffer2\0"): *fp_vkCmdCopyBuffer2; + vkCmdCopyBufferToImage = get_device_proc_address(device, "vkCmdCopyBufferToImage\0"): *fp_vkCmdCopyBufferToImage; + vkCmdCopyBufferToImage2 = get_device_proc_address(device, "vkCmdCopyBufferToImage2\0"): *fp_vkCmdCopyBufferToImage2; + vkCmdCopyImage = get_device_proc_address(device, "vkCmdCopyImage\0"): *fp_vkCmdCopyImage; + vkCmdCopyImage2 = get_device_proc_address(device, "vkCmdCopyImage2\0"): *fp_vkCmdCopyImage2; + vkCmdCopyImageToBuffer = get_device_proc_address(device, "vkCmdCopyImageToBuffer\0"): *fp_vkCmdCopyImageToBuffer; + vkCmdCopyImageToBuffer2 = get_device_proc_address(device, "vkCmdCopyImageToBuffer2\0"): *fp_vkCmdCopyImageToBuffer2; + vkCmdCopyQueryPoolResults = get_device_proc_address(device, "vkCmdCopyQueryPoolResults\0"): *fp_vkCmdCopyQueryPoolResults; + vkCmdDispatch = get_device_proc_address(device, "vkCmdDispatch\0"): *fp_vkCmdDispatch; + vkCmdDispatchBase = get_device_proc_address(device, "vkCmdDispatchBase\0"): *fp_vkCmdDispatchBase; + vkCmdDispatchIndirect = get_device_proc_address(device, "vkCmdDispatchIndirect\0"): *fp_vkCmdDispatchIndirect; + vkCmdDraw = get_device_proc_address(device, "vkCmdDraw\0"): *fp_vkCmdDraw; + vkCmdDrawIndexed = get_device_proc_address(device, "vkCmdDrawIndexed\0"): *fp_vkCmdDrawIndexed; + vkCmdDrawIndexedIndirect = get_device_proc_address(device, "vkCmdDrawIndexedIndirect\0"): *fp_vkCmdDrawIndexedIndirect; + vkCmdDrawIndexedIndirectCount = get_device_proc_address(device, "vkCmdDrawIndexedIndirectCount\0"): *fp_vkCmdDrawIndexedIndirectCount; + vkCmdDrawIndirect = get_device_proc_address(device, "vkCmdDrawIndirect\0"): *fp_vkCmdDrawIndirect; + vkCmdDrawIndirectCount = get_device_proc_address(device, "vkCmdDrawIndirectCount\0"): *fp_vkCmdDrawIndirectCount; + vkCmdEndQuery = get_device_proc_address(device, "vkCmdEndQuery\0"): *fp_vkCmdEndQuery; + vkCmdEndRenderPass = get_device_proc_address(device, "vkCmdEndRenderPass\0"): *fp_vkCmdEndRenderPass; + vkCmdEndRenderPass2 = get_device_proc_address(device, "vkCmdEndRenderPass2\0"): *fp_vkCmdEndRenderPass2; + vkCmdEndRendering = get_device_proc_address(device, "vkCmdEndRendering\0"): *fp_vkCmdEndRendering; + vkCmdExecuteCommands = get_device_proc_address(device, "vkCmdExecuteCommands\0"): *fp_vkCmdExecuteCommands; + vkCmdFillBuffer = get_device_proc_address(device, "vkCmdFillBuffer\0"): *fp_vkCmdFillBuffer; + vkCmdNextSubpass = get_device_proc_address(device, "vkCmdNextSubpass\0"): *fp_vkCmdNextSubpass; + vkCmdNextSubpass2 = get_device_proc_address(device, "vkCmdNextSubpass2\0"): *fp_vkCmdNextSubpass2; + vkCmdPipelineBarrier = get_device_proc_address(device, "vkCmdPipelineBarrier\0"): *fp_vkCmdPipelineBarrier; + vkCmdPipelineBarrier2 = get_device_proc_address(device, "vkCmdPipelineBarrier2\0"): *fp_vkCmdPipelineBarrier2; + vkCmdPushConstants = get_device_proc_address(device, "vkCmdPushConstants\0"): *fp_vkCmdPushConstants; + vkCmdResetEvent = get_device_proc_address(device, "vkCmdResetEvent\0"): *fp_vkCmdResetEvent; + vkCmdResetEvent2 = get_device_proc_address(device, "vkCmdResetEvent2\0"): *fp_vkCmdResetEvent2; + vkCmdResetQueryPool = get_device_proc_address(device, "vkCmdResetQueryPool\0"): *fp_vkCmdResetQueryPool; + vkCmdResolveImage = get_device_proc_address(device, "vkCmdResolveImage\0"): *fp_vkCmdResolveImage; + vkCmdResolveImage2 = get_device_proc_address(device, "vkCmdResolveImage2\0"): *fp_vkCmdResolveImage2; + vkCmdSetBlendConstants = get_device_proc_address(device, "vkCmdSetBlendConstants\0"): *fp_vkCmdSetBlendConstants; + vkCmdSetCullMode = get_device_proc_address(device, "vkCmdSetCullMode\0"): *fp_vkCmdSetCullMode; + vkCmdSetDepthBias = get_device_proc_address(device, "vkCmdSetDepthBias\0"): *fp_vkCmdSetDepthBias; + vkCmdSetDepthBiasEnable = get_device_proc_address(device, "vkCmdSetDepthBiasEnable\0"): *fp_vkCmdSetDepthBiasEnable; + vkCmdSetDepthBounds = get_device_proc_address(device, "vkCmdSetDepthBounds\0"): *fp_vkCmdSetDepthBounds; + vkCmdSetDepthBoundsTestEnable = get_device_proc_address(device, "vkCmdSetDepthBoundsTestEnable\0"): *fp_vkCmdSetDepthBoundsTestEnable; + vkCmdSetDepthCompareOp = get_device_proc_address(device, "vkCmdSetDepthCompareOp\0"): *fp_vkCmdSetDepthCompareOp; + vkCmdSetDepthTestEnable = get_device_proc_address(device, "vkCmdSetDepthTestEnable\0"): *fp_vkCmdSetDepthTestEnable; + vkCmdSetDepthWriteEnable = get_device_proc_address(device, "vkCmdSetDepthWriteEnable\0"): *fp_vkCmdSetDepthWriteEnable; + vkCmdSetDeviceMask = get_device_proc_address(device, "vkCmdSetDeviceMask\0"): *fp_vkCmdSetDeviceMask; + vkCmdSetEvent = get_device_proc_address(device, "vkCmdSetEvent\0"): *fp_vkCmdSetEvent; + vkCmdSetEvent2 = get_device_proc_address(device, "vkCmdSetEvent2\0"): *fp_vkCmdSetEvent2; + vkCmdSetFrontFace = get_device_proc_address(device, "vkCmdSetFrontFace\0"): *fp_vkCmdSetFrontFace; + vkCmdSetLineWidth = get_device_proc_address(device, "vkCmdSetLineWidth\0"): *fp_vkCmdSetLineWidth; + vkCmdSetPrimitiveRestartEnable = get_device_proc_address(device, "vkCmdSetPrimitiveRestartEnable\0"): *fp_vkCmdSetPrimitiveRestartEnable; + vkCmdSetPrimitiveTopology = get_device_proc_address(device, "vkCmdSetPrimitiveTopology\0"): *fp_vkCmdSetPrimitiveTopology; + vkCmdSetRasterizerDiscardEnable = get_device_proc_address(device, "vkCmdSetRasterizerDiscardEnable\0"): *fp_vkCmdSetRasterizerDiscardEnable; + vkCmdSetScissor = get_device_proc_address(device, "vkCmdSetScissor\0"): *fp_vkCmdSetScissor; + vkCmdSetScissorWithCount = get_device_proc_address(device, "vkCmdSetScissorWithCount\0"): *fp_vkCmdSetScissorWithCount; + vkCmdSetStencilCompareMask = get_device_proc_address(device, "vkCmdSetStencilCompareMask\0"): *fp_vkCmdSetStencilCompareMask; + vkCmdSetStencilOp = get_device_proc_address(device, "vkCmdSetStencilOp\0"): *fp_vkCmdSetStencilOp; + vkCmdSetStencilReference = get_device_proc_address(device, "vkCmdSetStencilReference\0"): *fp_vkCmdSetStencilReference; + vkCmdSetStencilTestEnable = get_device_proc_address(device, "vkCmdSetStencilTestEnable\0"): *fp_vkCmdSetStencilTestEnable; + vkCmdSetStencilWriteMask = get_device_proc_address(device, "vkCmdSetStencilWriteMask\0"): *fp_vkCmdSetStencilWriteMask; + vkCmdSetViewport = get_device_proc_address(device, "vkCmdSetViewport\0"): *fp_vkCmdSetViewport; + vkCmdSetViewportWithCount = get_device_proc_address(device, "vkCmdSetViewportWithCount\0"): *fp_vkCmdSetViewportWithCount; + vkCmdUpdateBuffer = get_device_proc_address(device, "vkCmdUpdateBuffer\0"): *fp_vkCmdUpdateBuffer; + vkCmdWaitEvents = get_device_proc_address(device, "vkCmdWaitEvents\0"): *fp_vkCmdWaitEvents; + vkCmdWaitEvents2 = get_device_proc_address(device, "vkCmdWaitEvents2\0"): *fp_vkCmdWaitEvents2; + vkCmdWriteTimestamp = get_device_proc_address(device, "vkCmdWriteTimestamp\0"): *fp_vkCmdWriteTimestamp; + vkCmdWriteTimestamp2 = get_device_proc_address(device, "vkCmdWriteTimestamp2\0"): *fp_vkCmdWriteTimestamp2; + vkCreateBuffer = get_device_proc_address(device, "vkCreateBuffer\0"): *fp_vkCreateBuffer; + vkCreateBufferView = get_device_proc_address(device, "vkCreateBufferView\0"): *fp_vkCreateBufferView; + vkCreateCommandPool = get_device_proc_address(device, "vkCreateCommandPool\0"): *fp_vkCreateCommandPool; + vkCreateComputePipelines = get_device_proc_address(device, "vkCreateComputePipelines\0"): *fp_vkCreateComputePipelines; + vkCreateDescriptorPool = get_device_proc_address(device, "vkCreateDescriptorPool\0"): *fp_vkCreateDescriptorPool; + vkCreateDescriptorSetLayout = get_device_proc_address(device, "vkCreateDescriptorSetLayout\0"): *fp_vkCreateDescriptorSetLayout; + vkCreateDescriptorUpdateTemplate = get_device_proc_address(device, "vkCreateDescriptorUpdateTemplate\0"): *fp_vkCreateDescriptorUpdateTemplate; + vkCreateEvent = get_device_proc_address(device, "vkCreateEvent\0"): *fp_vkCreateEvent; + vkCreateFence = get_device_proc_address(device, "vkCreateFence\0"): *fp_vkCreateFence; + vkCreateFramebuffer = get_device_proc_address(device, "vkCreateFramebuffer\0"): *fp_vkCreateFramebuffer; + vkCreateGraphicsPipelines = get_device_proc_address(device, "vkCreateGraphicsPipelines\0"): *fp_vkCreateGraphicsPipelines; + vkCreateImage = get_device_proc_address(device, "vkCreateImage\0"): *fp_vkCreateImage; + vkCreateImageView = get_device_proc_address(device, "vkCreateImageView\0"): *fp_vkCreateImageView; + vkCreatePipelineCache = get_device_proc_address(device, "vkCreatePipelineCache\0"): *fp_vkCreatePipelineCache; + vkCreatePipelineLayout = get_device_proc_address(device, "vkCreatePipelineLayout\0"): *fp_vkCreatePipelineLayout; + vkCreatePrivateDataSlot = get_device_proc_address(device, "vkCreatePrivateDataSlot\0"): *fp_vkCreatePrivateDataSlot; + vkCreateQueryPool = get_device_proc_address(device, "vkCreateQueryPool\0"): *fp_vkCreateQueryPool; + vkCreateRenderPass = get_device_proc_address(device, "vkCreateRenderPass\0"): *fp_vkCreateRenderPass; + vkCreateRenderPass2 = get_device_proc_address(device, "vkCreateRenderPass2\0"): *fp_vkCreateRenderPass2; + vkCreateSampler = get_device_proc_address(device, "vkCreateSampler\0"): *fp_vkCreateSampler; + vkCreateSamplerYcbcrConversion = get_device_proc_address(device, "vkCreateSamplerYcbcrConversion\0"): *fp_vkCreateSamplerYcbcrConversion; + vkCreateSemaphore = get_device_proc_address(device, "vkCreateSemaphore\0"): *fp_vkCreateSemaphore; + vkCreateShaderModule = get_device_proc_address(device, "vkCreateShaderModule\0"): *fp_vkCreateShaderModule; + vkDestroyBuffer = get_device_proc_address(device, "vkDestroyBuffer\0"): *fp_vkDestroyBuffer; + vkDestroyBufferView = get_device_proc_address(device, "vkDestroyBufferView\0"): *fp_vkDestroyBufferView; + vkDestroyCommandPool = get_device_proc_address(device, "vkDestroyCommandPool\0"): *fp_vkDestroyCommandPool; + vkDestroyDescriptorPool = get_device_proc_address(device, "vkDestroyDescriptorPool\0"): *fp_vkDestroyDescriptorPool; + vkDestroyDescriptorSetLayout = get_device_proc_address(device, "vkDestroyDescriptorSetLayout\0"): *fp_vkDestroyDescriptorSetLayout; + vkDestroyDescriptorUpdateTemplate = get_device_proc_address(device, "vkDestroyDescriptorUpdateTemplate\0"): *fp_vkDestroyDescriptorUpdateTemplate; + vkDestroyDevice = get_device_proc_address(device, "vkDestroyDevice\0"): *fp_vkDestroyDevice; + vkDestroyEvent = get_device_proc_address(device, "vkDestroyEvent\0"): *fp_vkDestroyEvent; + vkDestroyFence = get_device_proc_address(device, "vkDestroyFence\0"): *fp_vkDestroyFence; + vkDestroyFramebuffer = get_device_proc_address(device, "vkDestroyFramebuffer\0"): *fp_vkDestroyFramebuffer; + vkDestroyImage = get_device_proc_address(device, "vkDestroyImage\0"): *fp_vkDestroyImage; + vkDestroyImageView = get_device_proc_address(device, "vkDestroyImageView\0"): *fp_vkDestroyImageView; + vkDestroyPipeline = get_device_proc_address(device, "vkDestroyPipeline\0"): *fp_vkDestroyPipeline; + vkDestroyPipelineCache = get_device_proc_address(device, "vkDestroyPipelineCache\0"): *fp_vkDestroyPipelineCache; + vkDestroyPipelineLayout = get_device_proc_address(device, "vkDestroyPipelineLayout\0"): *fp_vkDestroyPipelineLayout; + vkDestroyPrivateDataSlot = get_device_proc_address(device, "vkDestroyPrivateDataSlot\0"): *fp_vkDestroyPrivateDataSlot; + vkDestroyQueryPool = get_device_proc_address(device, "vkDestroyQueryPool\0"): *fp_vkDestroyQueryPool; + vkDestroyRenderPass = get_device_proc_address(device, "vkDestroyRenderPass\0"): *fp_vkDestroyRenderPass; + vkDestroySampler = get_device_proc_address(device, "vkDestroySampler\0"): *fp_vkDestroySampler; + vkDestroySamplerYcbcrConversion = get_device_proc_address(device, "vkDestroySamplerYcbcrConversion\0"): *fp_vkDestroySamplerYcbcrConversion; + vkDestroySemaphore = get_device_proc_address(device, "vkDestroySemaphore\0"): *fp_vkDestroySemaphore; + vkDestroyShaderModule = get_device_proc_address(device, "vkDestroyShaderModule\0"): *fp_vkDestroyShaderModule; + vkDeviceWaitIdle = get_device_proc_address(device, "vkDeviceWaitIdle\0"): *fp_vkDeviceWaitIdle; + vkEndCommandBuffer = get_device_proc_address(device, "vkEndCommandBuffer\0"): *fp_vkEndCommandBuffer; + vkFlushMappedMemoryRanges = get_device_proc_address(device, "vkFlushMappedMemoryRanges\0"): *fp_vkFlushMappedMemoryRanges; + vkFreeCommandBuffers = get_device_proc_address(device, "vkFreeCommandBuffers\0"): *fp_vkFreeCommandBuffers; + vkFreeDescriptorSets = get_device_proc_address(device, "vkFreeDescriptorSets\0"): *fp_vkFreeDescriptorSets; + vkFreeMemory = get_device_proc_address(device, "vkFreeMemory\0"): *fp_vkFreeMemory; + vkGetBufferDeviceAddress = get_device_proc_address(device, "vkGetBufferDeviceAddress\0"): *fp_vkGetBufferDeviceAddress; + vkGetBufferMemoryRequirements = get_device_proc_address(device, "vkGetBufferMemoryRequirements\0"): *fp_vkGetBufferMemoryRequirements; + vkGetBufferMemoryRequirements2 = get_device_proc_address(device, "vkGetBufferMemoryRequirements2\0"): *fp_vkGetBufferMemoryRequirements2; + vkGetBufferOpaqueCaptureAddress = get_device_proc_address(device, "vkGetBufferOpaqueCaptureAddress\0"): *fp_vkGetBufferOpaqueCaptureAddress; + vkGetDescriptorSetLayoutSupport = get_device_proc_address(device, "vkGetDescriptorSetLayoutSupport\0"): *fp_vkGetDescriptorSetLayoutSupport; + vkGetDeviceBufferMemoryRequirements = get_device_proc_address(device, "vkGetDeviceBufferMemoryRequirements\0"): *fp_vkGetDeviceBufferMemoryRequirements; + vkGetDeviceGroupPeerMemoryFeatures = get_device_proc_address(device, "vkGetDeviceGroupPeerMemoryFeatures\0"): *fp_vkGetDeviceGroupPeerMemoryFeatures; + vkGetDeviceImageMemoryRequirements = get_device_proc_address(device, "vkGetDeviceImageMemoryRequirements\0"): *fp_vkGetDeviceImageMemoryRequirements; + vkGetDeviceImageSparseMemoryRequirements = get_device_proc_address(device, "vkGetDeviceImageSparseMemoryRequirements\0"): *fp_vkGetDeviceImageSparseMemoryRequirements; + vkGetDeviceMemoryCommitment = get_device_proc_address(device, "vkGetDeviceMemoryCommitment\0"): *fp_vkGetDeviceMemoryCommitment; + vkGetDeviceMemoryOpaqueCaptureAddress = get_device_proc_address(device, "vkGetDeviceMemoryOpaqueCaptureAddress\0"): *fp_vkGetDeviceMemoryOpaqueCaptureAddress; + vkGetDeviceProcAddr = get_device_proc_address(device, "vkGetDeviceProcAddr\0"): *fp_vkGetDeviceProcAddr; + vkGetDeviceQueue = get_device_proc_address(device, "vkGetDeviceQueue\0"): *fp_vkGetDeviceQueue; + vkGetDeviceQueue2 = get_device_proc_address(device, "vkGetDeviceQueue2\0"): *fp_vkGetDeviceQueue2; + vkGetEventStatus = get_device_proc_address(device, "vkGetEventStatus\0"): *fp_vkGetEventStatus; + vkGetFenceStatus = get_device_proc_address(device, "vkGetFenceStatus\0"): *fp_vkGetFenceStatus; + vkGetImageMemoryRequirements = get_device_proc_address(device, "vkGetImageMemoryRequirements\0"): *fp_vkGetImageMemoryRequirements; + vkGetImageMemoryRequirements2 = get_device_proc_address(device, "vkGetImageMemoryRequirements2\0"): *fp_vkGetImageMemoryRequirements2; + vkGetImageSparseMemoryRequirements = get_device_proc_address(device, "vkGetImageSparseMemoryRequirements\0"): *fp_vkGetImageSparseMemoryRequirements; + vkGetImageSparseMemoryRequirements2 = get_device_proc_address(device, "vkGetImageSparseMemoryRequirements2\0"): *fp_vkGetImageSparseMemoryRequirements2; + vkGetImageSubresourceLayout = get_device_proc_address(device, "vkGetImageSubresourceLayout\0"): *fp_vkGetImageSubresourceLayout; + vkGetPipelineCacheData = get_device_proc_address(device, "vkGetPipelineCacheData\0"): *fp_vkGetPipelineCacheData; + vkGetPrivateData = get_device_proc_address(device, "vkGetPrivateData\0"): *fp_vkGetPrivateData; + vkGetQueryPoolResults = get_device_proc_address(device, "vkGetQueryPoolResults\0"): *fp_vkGetQueryPoolResults; + vkGetRenderAreaGranularity = get_device_proc_address(device, "vkGetRenderAreaGranularity\0"): *fp_vkGetRenderAreaGranularity; + vkGetSemaphoreCounterValue = get_device_proc_address(device, "vkGetSemaphoreCounterValue\0"): *fp_vkGetSemaphoreCounterValue; + vkInvalidateMappedMemoryRanges = get_device_proc_address(device, "vkInvalidateMappedMemoryRanges\0"): *fp_vkInvalidateMappedMemoryRanges; + vkMapMemory = get_device_proc_address(device, "vkMapMemory\0"): *fp_vkMapMemory; + vkMergePipelineCaches = get_device_proc_address(device, "vkMergePipelineCaches\0"): *fp_vkMergePipelineCaches; + vkQueueBindSparse = get_device_proc_address(device, "vkQueueBindSparse\0"): *fp_vkQueueBindSparse; + vkQueueSubmit = get_device_proc_address(device, "vkQueueSubmit\0"): *fp_vkQueueSubmit; + vkQueueSubmit2 = get_device_proc_address(device, "vkQueueSubmit2\0"): *fp_vkQueueSubmit2; + vkQueueWaitIdle = get_device_proc_address(device, "vkQueueWaitIdle\0"): *fp_vkQueueWaitIdle; + vkResetCommandBuffer = get_device_proc_address(device, "vkResetCommandBuffer\0"): *fp_vkResetCommandBuffer; + vkResetCommandPool = get_device_proc_address(device, "vkResetCommandPool\0"): *fp_vkResetCommandPool; + vkResetDescriptorPool = get_device_proc_address(device, "vkResetDescriptorPool\0"): *fp_vkResetDescriptorPool; + vkResetEvent = get_device_proc_address(device, "vkResetEvent\0"): *fp_vkResetEvent; + vkResetFences = get_device_proc_address(device, "vkResetFences\0"): *fp_vkResetFences; + vkResetQueryPool = get_device_proc_address(device, "vkResetQueryPool\0"): *fp_vkResetQueryPool; + vkSetEvent = get_device_proc_address(device, "vkSetEvent\0"): *fp_vkSetEvent; + vkSetPrivateData = get_device_proc_address(device, "vkSetPrivateData\0"): *fp_vkSetPrivateData; + vkSignalSemaphore = get_device_proc_address(device, "vkSignalSemaphore\0"): *fp_vkSignalSemaphore; + vkTrimCommandPool = get_device_proc_address(device, "vkTrimCommandPool\0"): *fp_vkTrimCommandPool; + vkUnmapMemory = get_device_proc_address(device, "vkUnmapMemory\0"): *fp_vkUnmapMemory; + vkUpdateDescriptorSetWithTemplate = get_device_proc_address(device, "vkUpdateDescriptorSetWithTemplate\0"): *fp_vkUpdateDescriptorSetWithTemplate; + vkUpdateDescriptorSets = get_device_proc_address(device, "vkUpdateDescriptorSets\0"): *fp_vkUpdateDescriptorSets; + vkWaitForFences = get_device_proc_address(device, "vkWaitForFences\0"): *fp_vkWaitForFences; + vkWaitSemaphores = get_device_proc_address(device, "vkWaitSemaphores\0"): *fp_vkWaitSemaphores; +}; -- 2.45.2