From 8c0eda686d87e99ddcf5fa33bdb8e5cd7fc5e775 Mon Sep 17 00:00:00 2001 From: ellipse12 Date: Sat, 14 Sep 2024 19:32:44 -0600 Subject: [PATCH] Added vulkan bindings for versions 1.0 - 1.3 --- libraries/vulkan.c3l/README.md | 15 + libraries/vulkan.c3l/manifest.json | 117 + libraries/vulkan.c3l/vk10.c3i | 2374 +++++++++++++ libraries/vulkan.c3l/vk11.c3i | 3241 ++++++++++++++++++ libraries/vulkan.c3l/vk12.c3i | 4012 ++++++++++++++++++++++ libraries/vulkan.c3l/vk13.c3i | 4951 ++++++++++++++++++++++++++++ libraries/vulkan.c3l/vulkan.c3i | 31 + 7 files changed, 14741 insertions(+) create mode 100644 libraries/vulkan.c3l/README.md create mode 100644 libraries/vulkan.c3l/manifest.json create mode 100644 libraries/vulkan.c3l/vk10.c3i create mode 100644 libraries/vulkan.c3l/vk11.c3i create mode 100644 libraries/vulkan.c3l/vk12.c3i create mode 100644 libraries/vulkan.c3l/vk13.c3i create mode 100644 libraries/vulkan.c3l/vulkan.c3i diff --git a/libraries/vulkan.c3l/README.md b/libraries/vulkan.c3l/README.md new file mode 100644 index 0000000..f5c9462 --- /dev/null +++ b/libraries/vulkan.c3l/README.md @@ -0,0 +1,15 @@ +# Vulkan Bindings FAQ +* Vulkan functions are renamed as follows: `vkFunctionName` -> `vk::functionName` +* Constant definitions (`#define ... ...` in C) keep the same name and value +* C's fixed length types are converted to C3 types, and if there are any variable length types they are converted to C3's standard library equivalent: `int`->`CInt` +* Most vulkan typedefs are converted to distinct types. +* all string equivalents (e.g. `const char *`) are converted to ZStrings + +# Choosing a Version +* Vulkan versions 1.0 - 1.3 are currently supported, by default the most current version is used (1.3) +* If an older version is needed it can be set like: +```C3 +module vulkan; +const VK_VERSION = VK_API_VERSION_1_0; //supported versions are 1_0, 1_1, 1_2, and 1_3 +``` +* Only the functions and definitions from the set version are defined. diff --git a/libraries/vulkan.c3l/manifest.json b/libraries/vulkan.c3l/manifest.json new file mode 100644 index 0000000..a74a229 --- /dev/null +++ b/libraries/vulkan.c3l/manifest.json @@ -0,0 +1,117 @@ +{ + "provides" : "vulkan", + "targets" : { + "freebsd-x64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "linux-aarch64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "linux-riscv32" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "linux-riscv64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "linux-x86" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "linux-x64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "macos-aarch64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "macos-x64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "netbsd-x64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "openbsd-x64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "wasm32" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "wasm64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "windows-aarch64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + "windows-x64" : { + // Extra flags to the linker for this target: + "link-args" : [], + // C3 libraries this target depends on: + "dependencies" : [], + // The external libraries to link for this target: + "linked-libraries" : ["vulkan"] + }, + } +} diff --git a/libraries/vulkan.c3l/vk10.c3i b/libraries/vulkan.c3l/vk10.c3i new file mode 100644 index 0000000..b0dab5f --- /dev/null +++ b/libraries/vulkan.c3l/vk10.c3i @@ -0,0 +1,2374 @@ +module vulkan::vk @if(internal::vk_version() == VK_API_VERSION_1_0); +import vulkan; + +//Adapted from the glad loader generator at: https://gen.glad.sh. +//License/ Information: +/** + * Loader generated by glad 2.0.6 on Mon Aug 19 01:58:01 2024 + * + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + * + * Generator: C/C++ + * Specification: vk + * Extensions: 0 + * + * APIs: + * - vulkan=1.0 + * + * Options: + * - ALIAS = False + * - DEBUG = False + * - HEADER_ONLY = False + * - LOADER = False + * - MX = False + * - ON_DEMAND = False + * + * Commandline: + * --api='vulkan=1.0' --extensions='' c + * + * Online: + * http://glad.sh/#api=vulkan%3D1.0&extensions=&generator=c&options= + * + */ + +const VK_ATTACHMENT_UNUSED = (~0U); +const VK_FALSE = 0; +const VK_LOD_CLAMP_NONE = 1000.0F; +const VK_MAX_DESCRIPTION_SIZE = 256; +const VK_MAX_EXTENSION_NAME_SIZE = 256; +const VK_MAX_MEMORY_HEAPS = 16; +const VK_MAX_MEMORY_TYPES = 32; +const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256; +const VK_QUEUE_FAMILY_IGNORED = (~0U); +const VK_REMAINING_ARRAY_LAYERS = (~0U); +const VK_REMAINING_MIP_LEVELS = (~0U); +const VK_SUBPASS_EXTERNAL = (~0U); +const VK_TRUE = 1; +const VK_UUID_SIZE = 16; +const ulong VK_WHOLE_SIZE = (~0); + +distinct VkInstance = uptr; +distinct VkPhysicalDevice = uptr; +distinct VkDevice = uptr; +distinct VkQueue = uptr; +distinct VkCommandBuffer = uptr; +distinct VkDeviceMemory = uptr; +distinct VkCommandPool = uptr; +distinct VkBuffer = uptr; +distinct VkBufferView = uptr; +distinct VkImage = uptr; +distinct VkImageView = uptr; +distinct VkShaderModule = uptr; +distinct VkPipeline = uptr; +distinct VkPipelineLayout = uptr; +distinct VkSampler = uptr; +distinct VkDescriptorSet = uptr; +distinct VkDescriptorSetLayout = uptr; +distinct VkDescriptorPool = uptr; +distinct VkFence = uptr; +distinct VkSemaphore = uptr; +distinct VkEvent = uptr; +distinct VkQueryPool = uptr; +distinct VkFramebuffer = uptr; +distinct VkRenderPass = uptr; +distinct VkPipelineCache = uptr; +enum VkAttachmentLoadOp : int (int value) +{ + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkAttachmentStoreOp : int (int value) +{ + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkBlendFactor : int (int value) +{ + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkBlendOp : int (int value) +{ + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkBorderColor : int (int value) +{ + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineCacheHeaderVersion : int (int value) +{ + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} +enum VkBufferCreateFlagBits : int (int value) +{ + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 4, + VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkBufferUsageFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkColorComponentFlagBits : int (int value) +{ + VK_COLOR_COMPONENT_R_BIT = 1, + VK_COLOR_COMPONENT_G_BIT = 2, + VK_COLOR_COMPONENT_B_BIT = 4, + VK_COLOR_COMPONENT_A_BIT = 8, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkComponentSwizzle : int (int value) +{ + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandPoolCreateFlagBits : int (int value) +{ + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandPoolResetFlagBits : int (int value) +{ + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferResetFlagBits : int (int value) +{ + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferLevel : int (int value) +{ + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferUsageFlagBits : int (int value) +{ + 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, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCompareOp : int (int value) +{ + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkCullModeFlagBits : int (int value) +{ + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 1, + VK_CULL_MODE_BACK_BIT = 2, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorType : int (int value) +{ + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkDynamicState : int (int value) +{ + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} +enum VkFenceCreateFlagBits : int (int value) +{ + VK_FENCE_CREATE_SIGNALED_BIT = 1, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPolygonMode : int (int value) +{ + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkFormat : int (int value) +{ + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4X4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4X4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5X4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5X4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5X5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5X5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6X5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6X5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6X6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6X6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8X5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8X5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8X6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8X6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8X8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8X8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10X5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10X5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10X6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10X6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10X8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10X8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10X10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10X10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12X10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12X10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12X12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12X12_SRGB_BLOCK = 184, + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} +enum VkFormatFeatureFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkFrontFace : int (int value) +{ + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageAspectFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageCreateFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageLayout : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageTiling : int (int value) +{ + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageType : int (int value) +{ + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageUsageFlagBits : int (int value) +{ + 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, + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageViewType : int (int value) +{ + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSharingMode : int (int value) +{ + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkIndexType : int (int value) +{ + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkLogicOp : int (int value) +{ + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryHeapFlagBits : int (int value) +{ + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkAccessFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryPropertyFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPhysicalDeviceType : int (int value) +{ + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineBindPoint : int (int value) +{ + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineCreateFlagBits : int (int value) +{ + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 4, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPrimitiveTopology : int (int value) +{ + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryControlFlagBits : int (int value) +{ + VK_QUERY_CONTROL_PRECISE_BIT = 1, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryPipelineStatisticFlagBits : int (int value) +{ + 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, + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryResultFlagBits : int (int value) +{ + 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, + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryType : int (int value) +{ + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueueFlagBits : int (int value) +{ + VK_QUEUE_GRAPHICS_BIT = 1, + VK_QUEUE_COMPUTE_BIT = 2, + VK_QUEUE_TRANSFER_BIT = 4, + VK_QUEUE_SPARSE_BINDING_BIT = 8, + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSubpassContents : int (int value) +{ + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} +enum VkResult : int (int value) +{ + 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_RESULT_MAX_ENUM = 0x7FFFFFFF +} +enum VkShaderStageFlagBits : int (int value) +{ + 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, + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSparseMemoryBindFlagBits : int (int value) +{ + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkStencilFaceFlagBits : int (int value) +{ + 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, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkStencilOp : int (int value) +{ + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkStructureType : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkSystemAllocationScope : int (int value) +{ + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkInternalAllocationType : int (int value) +{ + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerAddressMode : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkFilter : int (int value) +{ + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerMipmapMode : int (int value) +{ + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkVertexInputRate : int (int value) +{ + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineStageFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSparseImageFormatFlagBits : int (int value) +{ + 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, + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSampleCountFlagBits : int (int value) +{ + 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, + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkAttachmentDescriptionFlagBits : int (int value) +{ + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorPoolCreateFlagBits : int (int value) +{ + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDependencyFlagBits : int (int value) +{ + VK_DEPENDENCY_BY_REGION_BIT = 1, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkObjectType : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkVendorId : int (int value) +{ + VK_VENDOR_ID_KHRONOS = 0x10000, + 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, + VK_VENDOR_ID_MOBILEYE = 0x10007, + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} +def PFN_vkInternalAllocationNotification = fn void ( + void* pUserData, + usz size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); +def PFN_vkInternalFreeNotification = fn void ( + void* pUserData, + usz size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); +def PFN_vkReallocationFunction = fn void* ( + void* pUserData, + void* pOriginal, + usz size, + usz alignment, + VkSystemAllocationScope allocationScope); +def PFN_vkAllocationFunction = fn void* ( + void* pUserData, + usz size, + usz alignment, + VkSystemAllocationScope allocationScope); +def PFN_vkFreeFunction = fn void ( + void* pUserData, + void* pMemory); +def PFN_vkVoidFunction = fn void (); +struct VkBaseOutStructure +{ + VkStructureType sType; + VkBaseOutStructure * pNext; +} + +struct VkBaseInStructure +{ + VkStructureType sType; + VkBaseInStructure * pNext; +} + +struct VkOffset2D +{ + int x; + int y; +} + +struct VkOffset3D +{ + int x; + int y; + int z; +} + +struct VkExtent2D +{ + uint width; + uint height; +} + +struct VkExtent3D +{ + uint width; + uint height; + uint depth; +} + +struct VkViewport +{ + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} + +struct VkRect2D +{ + VkOffset2D offset; + VkExtent2D extent; +} + +struct VkClearRect +{ + VkRect2D rect; + uint baseArrayLayer; + uint layerCount; +} + +struct VkComponentMapping +{ + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} + +struct VkExtensionProperties +{ + char[ VK_MAX_EXTENSION_NAME_SIZE ] extensionName; + uint specVersion; +} + +struct VkLayerProperties +{ + char[ VK_MAX_EXTENSION_NAME_SIZE ] layerName; + uint specVersion; + uint implementationVersion; + char[ VK_MAX_DESCRIPTION_SIZE ] description; +} + +struct VkApplicationInfo +{ + VkStructureType sType; + void * pNext; + char * pApplicationName; + uint applicationVersion; + char * pEngineName; + uint engineVersion; + uint apiVersion; +} + +struct VkAllocationCallbacks +{ + void * pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} + +struct VkDescriptorImageInfo +{ + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} + +struct VkCopyDescriptorSet +{ + VkStructureType sType; + void * pNext; + VkDescriptorSet srcSet; + uint srcBinding; + uint srcArrayElement; + VkDescriptorSet dstSet; + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; +} + +struct VkDescriptorPoolSize +{ + VkDescriptorType type; + uint descriptorCount; +} + +struct VkDescriptorSetAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorPool descriptorPool; + uint descriptorSetCount; + VkDescriptorSetLayout * pSetLayouts; +} + +struct VkSpecializationMapEntry +{ + uint constantID; + uint offset; + usz size; +} + +struct VkSpecializationInfo +{ + uint mapEntryCount; + VkSpecializationMapEntry * pMapEntries; + usz dataSize; + void * pData; +} + +struct VkVertexInputBindingDescription +{ + uint binding; + uint stride; + VkVertexInputRate inputRate; +} + +struct VkVertexInputAttributeDescription +{ + uint location; + uint binding; + VkFormat format; + uint offset; +} + +struct VkStencilOpState +{ + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint compareMask; + uint writeMask; + uint reference; +} + +struct VkPipelineCacheHeaderVersionOne +{ + uint headerSize; + VkPipelineCacheHeaderVersion headerVersion; + uint vendorID; + uint deviceID; + char[ VK_UUID_SIZE ] pipelineCacheUUID; +} + +struct VkCommandBufferAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint commandBufferCount; +} + +union VkClearColorValue { + float[4] float32; + int[4] int32; + uint[4] uint32; +} + +struct VkClearDepthStencilValue +{ + float depth; + uint stencil; +} + +union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} + +struct VkAttachmentReference +{ + uint attachment; + VkImageLayout layout; +} + +struct VkDrawIndirectCommand +{ + uint vertexCount; + uint instanceCount; + uint firstVertex; + uint firstInstance; +} + +struct VkDrawIndexedIndirectCommand +{ + uint indexCount; + uint instanceCount; + uint firstIndex; + int vertexOffset; + uint firstInstance; +} + +struct VkDispatchIndirectCommand +{ + uint x; + uint y; + uint z; +} + +def VkSampleMask = uint; +def VkBool32 = uint; +def VkFlags = uint; +def VkDeviceSize = ulong; +def VkDeviceAddress = ulong; +def VkFramebufferCreateFlags = VkFlags; +def VkQueryPoolCreateFlags = VkFlags; +def VkRenderPassCreateFlags = VkFlags; +def VkSamplerCreateFlags = VkFlags; +def VkPipelineLayoutCreateFlags = VkFlags; +def VkPipelineCacheCreateFlags = VkFlags; +def VkPipelineDepthStencilStateCreateFlags = VkFlags; +def VkPipelineDynamicStateCreateFlags = VkFlags; +def VkPipelineColorBlendStateCreateFlags = VkFlags; +def VkPipelineMultisampleStateCreateFlags = VkFlags; +def VkPipelineRasterizationStateCreateFlags = VkFlags; +def VkPipelineViewportStateCreateFlags = VkFlags; +def VkPipelineTessellationStateCreateFlags = VkFlags; +def VkPipelineInputAssemblyStateCreateFlags = VkFlags; +def VkPipelineVertexInputStateCreateFlags = VkFlags; +def VkPipelineShaderStageCreateFlags = VkFlags; +def VkDescriptorSetLayoutCreateFlags = VkFlags; +def VkBufferViewCreateFlags = VkFlags; +def VkInstanceCreateFlags = VkFlags; +def VkDeviceCreateFlags = VkFlags; +def VkDeviceQueueCreateFlags = VkFlags; +def VkQueueFlags = VkFlags; +def VkMemoryPropertyFlags = VkFlags; +def VkMemoryHeapFlags = VkFlags; +def VkAccessFlags = VkFlags; +def VkBufferUsageFlags = VkFlags; +def VkBufferCreateFlags = VkFlags; +def VkShaderStageFlags = VkFlags; +def VkImageUsageFlags = VkFlags; +def VkImageCreateFlags = VkFlags; +def VkImageViewCreateFlags = VkFlags; +def VkPipelineCreateFlags = VkFlags; +def VkColorComponentFlags = VkFlags; +def VkFenceCreateFlags = VkFlags; +def VkSemaphoreCreateFlags = VkFlags; +def VkFormatFeatureFlags = VkFlags; +def VkQueryControlFlags = VkFlags; +def VkQueryResultFlags = VkFlags; +def VkShaderModuleCreateFlags = VkFlags; +def VkEventCreateFlags = VkFlags; +def VkCommandPoolCreateFlags = VkFlags; +def VkCommandPoolResetFlags = VkFlags; +def VkCommandBufferResetFlags = VkFlags; +def VkCommandBufferUsageFlags = VkFlags; +def VkQueryPipelineStatisticFlags = VkFlags; +def VkMemoryMapFlags = VkFlags; +def VkImageAspectFlags = VkFlags; +def VkSparseMemoryBindFlags = VkFlags; +def VkSparseImageFormatFlags = VkFlags; +def VkSubpassDescriptionFlags = VkFlags; +def VkPipelineStageFlags = VkFlags; +def VkSampleCountFlags = VkFlags; +def VkAttachmentDescriptionFlags = VkFlags; +def VkStencilFaceFlags = VkFlags; +def VkCullModeFlags = VkFlags; +def VkDescriptorPoolCreateFlags = VkFlags; +def VkDescriptorPoolResetFlags = VkFlags; +def VkDependencyFlags = VkFlags; +struct VkDeviceQueueCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceQueueCreateFlags flags; + uint queueFamilyIndex; + uint queueCount; + float * pQueuePriorities; +} + +struct VkInstanceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkInstanceCreateFlags flags; + VkApplicationInfo * pApplicationInfo; + uint enabledLayerCount; + ZString ppEnabledLayerNames; + uint enabledExtensionCount; + ZString ppEnabledExtensionNames; +} + +struct VkQueueFamilyProperties +{ + VkQueueFlags queueFlags; + uint queueCount; + uint timestampValidBits; + VkExtent3D minImageTransferGranularity; +} + +struct VkMemoryAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceSize allocationSize; + uint memoryTypeIndex; +} + +struct VkMemoryRequirements +{ + VkDeviceSize size; + VkDeviceSize alignment; + uint memoryTypeBits; +} + +struct VkSparseImageFormatProperties +{ + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} + +struct VkSparseImageMemoryRequirements +{ + VkSparseImageFormatProperties formatProperties; + uint imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} + +struct VkMemoryType +{ + VkMemoryPropertyFlags propertyFlags; + uint heapIndex; +} + +struct VkMemoryHeap +{ + VkDeviceSize size; + VkMemoryHeapFlags flags; +} + +struct VkMappedMemoryRange +{ + VkStructureType sType; + void * pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} + +struct VkFormatProperties +{ + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} + +struct VkImageFormatProperties +{ + VkExtent3D maxExtent; + uint maxMipLevels; + uint maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} + +struct VkDescriptorBufferInfo +{ + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} + +struct VkWriteDescriptorSet +{ + VkStructureType sType; + void * pNext; + VkDescriptorSet dstSet; + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; + VkDescriptorType descriptorType; + VkDescriptorImageInfo * pImageInfo; + VkDescriptorBufferInfo * pBufferInfo; + VkBufferView * pTexelBufferView; +} + +struct VkBufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint queueFamilyIndexCount; + uint * pQueueFamilyIndices; +} + +struct VkBufferViewCreateInfo +{ + VkStructureType sType; + void * pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} + +struct VkImageSubresource +{ + VkImageAspectFlags aspectMask; + uint mipLevel; + uint arrayLayer; +} + +struct VkImageSubresourceLayers +{ + VkImageAspectFlags aspectMask; + uint mipLevel; + uint baseArrayLayer; + uint layerCount; +} + +struct VkImageSubresourceRange +{ + VkImageAspectFlags aspectMask; + uint baseMipLevel; + uint levelCount; + uint baseArrayLayer; + uint layerCount; +} + +struct VkMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} + +struct VkBufferMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint srcQueueFamilyIndex; + uint dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} + +struct VkImageMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint srcQueueFamilyIndex; + uint dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} + +struct VkImageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint mipLevels; + uint arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint queueFamilyIndexCount; + uint * pQueueFamilyIndices; + VkImageLayout initialLayout; +} + +struct VkSubresourceLayout +{ + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} + +struct VkImageViewCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} + +struct VkBufferCopy +{ + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} + +struct VkSparseMemoryBind +{ + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} + +struct VkSparseImageMemoryBind +{ + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} + +struct VkSparseBufferMemoryBindInfo +{ + VkBuffer buffer; + uint bindCount; + VkSparseMemoryBind * pBinds; +} + +struct VkSparseImageOpaqueMemoryBindInfo +{ + VkImage image; + uint bindCount; + VkSparseMemoryBind * pBinds; +} + +struct VkSparseImageMemoryBindInfo +{ + VkImage image; + uint bindCount; + VkSparseImageMemoryBind * pBinds; +} + +struct VkBindSparseInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + VkSemaphore * pWaitSemaphores; + uint bufferBindCount; + VkSparseBufferMemoryBindInfo * pBufferBinds; + uint imageOpaqueBindCount; + VkSparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds; + uint imageBindCount; + VkSparseImageMemoryBindInfo * pImageBinds; + uint signalSemaphoreCount; + VkSemaphore * pSignalSemaphores; +} + +struct VkImageCopy +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} + +struct VkImageBlit +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D[2] srcOffsets; + VkImageSubresourceLayers dstSubresource; + VkOffset3D[2] dstOffsets; +} + +struct VkBufferImageCopy +{ + VkDeviceSize bufferOffset; + uint bufferRowLength; + uint bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} + +struct VkImageResolve +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} + +struct VkShaderModuleCreateInfo +{ + VkStructureType sType; + void * pNext; + VkShaderModuleCreateFlags flags; + usz codeSize; + uint * pCode; +} + +struct VkDescriptorSetLayoutBinding +{ + uint binding; + VkDescriptorType descriptorType; + uint descriptorCount; + VkShaderStageFlags stageFlags; + VkSampler * pImmutableSamplers; +} + +struct VkDescriptorSetLayoutCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint bindingCount; + VkDescriptorSetLayoutBinding * pBindings; +} + +struct VkDescriptorPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorPoolCreateFlags flags; + uint maxSets; + uint poolSizeCount; + VkDescriptorPoolSize * pPoolSizes; +} + +struct VkPipelineShaderStageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule vkmodule; + char * pName; + VkSpecializationInfo * pSpecializationInfo; +} + +struct VkComputePipelineCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int basePipelineIndex; +} + +struct VkPipelineVertexInputStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint vertexBindingDescriptionCount; + VkVertexInputBindingDescription * pVertexBindingDescriptions; + uint vertexAttributeDescriptionCount; + VkVertexInputAttributeDescription * pVertexAttributeDescriptions; +} + +struct VkPipelineInputAssemblyStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} + +struct VkPipelineTessellationStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineTessellationStateCreateFlags flags; + uint patchControlPoints; +} + +struct VkPipelineViewportStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineViewportStateCreateFlags flags; + uint viewportCount; + VkViewport * pViewports; + uint scissorCount; + VkRect2D * pScissors; +} + +struct VkPipelineRasterizationStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} + +struct VkPipelineMultisampleStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + VkSampleMask * pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} + +struct VkPipelineColorBlendAttachmentState +{ + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} + +struct VkPipelineColorBlendStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint attachmentCount; + VkPipelineColorBlendAttachmentState * pAttachments; + float[4] blendConstants; +} + +struct VkPipelineDynamicStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineDynamicStateCreateFlags flags; + uint dynamicStateCount; + VkDynamicState * pDynamicStates; +} + +struct VkPipelineDepthStencilStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} + +struct VkGraphicsPipelineCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCreateFlags flags; + uint stageCount; + VkPipelineShaderStageCreateInfo * pStages; + VkPipelineVertexInputStateCreateInfo * pVertexInputState; + VkPipelineInputAssemblyStateCreateInfo * pInputAssemblyState; + VkPipelineTessellationStateCreateInfo * pTessellationState; + VkPipelineViewportStateCreateInfo * pViewportState; + VkPipelineRasterizationStateCreateInfo * pRasterizationState; + VkPipelineMultisampleStateCreateInfo * pMultisampleState; + VkPipelineDepthStencilStateCreateInfo * pDepthStencilState; + VkPipelineColorBlendStateCreateInfo * pColorBlendState; + VkPipelineDynamicStateCreateInfo * pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint subpass; + VkPipeline basePipelineHandle; + int basePipelineIndex; +} + +struct VkPipelineCacheCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCacheCreateFlags flags; + usz initialDataSize; + void * pInitialData; +} + +struct VkPushConstantRange +{ + VkShaderStageFlags stageFlags; + uint offset; + uint size; +} + +struct VkPipelineLayoutCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineLayoutCreateFlags flags; + uint setLayoutCount; + VkDescriptorSetLayout * pSetLayouts; + uint pushConstantRangeCount; + VkPushConstantRange * pPushConstantRanges; +} + +struct VkSamplerCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} + +struct VkCommandPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkCommandPoolCreateFlags flags; + uint queueFamilyIndex; +} + +struct VkCommandBufferInheritanceInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPass renderPass; + uint subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} + +struct VkCommandBufferBeginInfo +{ + VkStructureType sType; + void * pNext; + VkCommandBufferUsageFlags flags; + VkCommandBufferInheritanceInfo * pInheritanceInfo; +} + +struct VkRenderPassBeginInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint clearValueCount; + VkClearValue * pClearValues; +} + +struct VkClearAttachment +{ + VkImageAspectFlags aspectMask; + uint colorAttachment; + VkClearValue clearValue; +} + +struct VkAttachmentDescription +{ + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} + +struct VkSubpassDescription +{ + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint inputAttachmentCount; + VkAttachmentReference * pInputAttachments; + uint colorAttachmentCount; + VkAttachmentReference * pColorAttachments; + VkAttachmentReference * pResolveAttachments; + VkAttachmentReference * pDepthStencilAttachment; + uint preserveAttachmentCount; + uint * pPreserveAttachments; +} + +struct VkSubpassDependency +{ + uint srcSubpass; + uint dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} + +struct VkRenderPassCreateInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPassCreateFlags flags; + uint attachmentCount; + VkAttachmentDescription * pAttachments; + uint subpassCount; + VkSubpassDescription * pSubpasses; + uint dependencyCount; + VkSubpassDependency * pDependencies; +} + +struct VkEventCreateInfo +{ + VkStructureType sType; + void * pNext; + VkEventCreateFlags flags; +} + +struct VkFenceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFenceCreateFlags flags; +} + +struct VkPhysicalDeviceFeatures +{ + VkBool32 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; +} + +struct VkPhysicalDeviceSparseProperties +{ + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} + +struct VkPhysicalDeviceLimits +{ + uint maxImageDimension1D; + uint maxImageDimension2D; + uint maxImageDimension3D; + uint maxImageDimensionCube; + uint maxImageArrayLayers; + uint maxTexelBufferElements; + uint maxUniformBufferRange; + uint maxStorageBufferRange; + uint maxPushConstantsSize; + uint maxMemoryAllocationCount; + uint maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint maxBoundDescriptorSets; + uint maxPerStageDescriptorSamplers; + uint maxPerStageDescriptorUniformBuffers; + uint maxPerStageDescriptorStorageBuffers; + uint maxPerStageDescriptorSampledImages; + uint maxPerStageDescriptorStorageImages; + uint maxPerStageDescriptorInputAttachments; + uint maxPerStageResources; + uint maxDescriptorSetSamplers; + uint maxDescriptorSetUniformBuffers; + uint maxDescriptorSetUniformBuffersDynamic; + uint maxDescriptorSetStorageBuffers; + uint maxDescriptorSetStorageBuffersDynamic; + uint maxDescriptorSetSampledImages; + uint maxDescriptorSetStorageImages; + uint maxDescriptorSetInputAttachments; + uint maxVertexInputAttributes; + uint maxVertexInputBindings; + uint maxVertexInputAttributeOffset; + uint maxVertexInputBindingStride; + uint maxVertexOutputComponents; + uint maxTessellationGenerationLevel; + uint maxTessellationPatchSize; + uint maxTessellationControlPerVertexInputComponents; + uint maxTessellationControlPerVertexOutputComponents; + uint maxTessellationControlPerPatchOutputComponents; + uint maxTessellationControlTotalOutputComponents; + uint maxTessellationEvaluationInputComponents; + uint maxTessellationEvaluationOutputComponents; + uint maxGeometryShaderInvocations; + uint maxGeometryInputComponents; + uint maxGeometryOutputComponents; + uint maxGeometryOutputVertices; + uint maxGeometryTotalOutputComponents; + uint maxFragmentInputComponents; + uint maxFragmentOutputAttachments; + uint maxFragmentDualSrcAttachments; + uint maxFragmentCombinedOutputResources; + uint maxComputeSharedMemorySize; + uint[3] maxComputeWorkGroupCount; + uint maxComputeWorkGroupInvocations; + uint[3] maxComputeWorkGroupSize; + uint subPixelPrecisionBits; + uint subTexelPrecisionBits; + uint mipmapPrecisionBits; + uint maxDrawIndexedIndexValue; + uint maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint maxViewports; + uint[2] maxViewportDimensions; + float[2] viewportBoundsRange; + uint viewportSubPixelBits; + usz minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int minTexelOffset; + uint maxTexelOffset; + int minTexelGatherOffset; + uint maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint subPixelInterpolationOffsetBits; + uint maxFramebufferWidth; + uint maxFramebufferHeight; + uint maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint maxClipDistances; + uint maxCullDistances; + uint maxCombinedClipAndCullDistances; + uint discreteQueuePriorities; + float[2] pointSizeRange; + float[2] lineWidthRange; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} + +struct VkSemaphoreCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphoreCreateFlags flags; +} + +struct VkQueryPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} + +struct VkFramebufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint attachmentCount; + VkImageView * pAttachments; + uint width; + uint height; + uint layers; +} + +struct VkSubmitInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + VkSemaphore * pWaitSemaphores; + VkPipelineStageFlags * pWaitDstStageMask; + uint commandBufferCount; + VkCommandBuffer * pCommandBuffers; + uint signalSemaphoreCount; + VkSemaphore * pSignalSemaphores; +} + +struct VkPhysicalDeviceProperties +{ + uint apiVersion; + uint driverVersion; + uint vendorID; + uint deviceID; + VkPhysicalDeviceType deviceType; + char[ VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ] deviceName; + char[ VK_UUID_SIZE ] pipelineCacheUUID; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} + +struct VkDeviceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceCreateFlags flags; + uint queueCreateInfoCount; + VkDeviceQueueCreateInfo * pQueueCreateInfos; + uint enabledLayerCount; + ZString ppEnabledLayerNames; + uint enabledExtensionCount; + ZString ppEnabledExtensionNames; + VkPhysicalDeviceFeatures * pEnabledFeatures; +} + +struct VkPhysicalDeviceMemoryProperties +{ + uint memoryTypeCount; + VkMemoryType[ VK_MAX_MEMORY_TYPES ] memoryTypes; + uint memoryHeapCount; + VkMemoryHeap[ VK_MAX_MEMORY_HEAPS ] memoryHeaps; +} + + + +const VK_VERSION_1_0 = 1; + + + +fn VkResult allocateCommandBuffers (VkDevice device, VkCommandBufferAllocateInfo * pAllocateInfo, VkCommandBuffer * pCommandBuffers) @extern("vkAllocateCommandBuffers"); +fn VkResult allocateDescriptorSets (VkDevice device, VkDescriptorSetAllocateInfo * pAllocateInfo, VkDescriptorSet * pDescriptorSets) @extern("vkAllocateDescriptorSets"); +fn VkResult allocateMemory (VkDevice device, VkMemoryAllocateInfo * pAllocateInfo, VkAllocationCallbacks * pAllocator, VkDeviceMemory * pMemory) @extern("vkAllocateMemory"); +fn VkResult beginCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo * pBeginInfo) @extern("vkBeginCommandBuffer"); +fn VkResult bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) @extern("vkBindBufferMemory"); +fn VkResult bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) @extern("vkBindImageMemory"); +fn void cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query, VkQueryControlFlags flags) @extern("vkCmdBeginQuery"); +fn void cmdBeginRenderPass (VkCommandBuffer commandBuffer, VkRenderPassBeginInfo * pRenderPassBegin, VkSubpassContents contents) @extern("vkCmdBeginRenderPass"); +fn void cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint firstSet, uint descriptorSetCount, VkDescriptorSet * pDescriptorSets, uint dynamicOffsetCount, uint * pDynamicOffsets) @extern("vkCmdBindDescriptorSets"); +fn void cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) @extern("vkCmdBindIndexBuffer"); +fn void cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) @extern("vkCmdBindPipeline"); +fn void cmdBindVertexBuffers (VkCommandBuffer commandBuffer, uint firstBinding, uint bindingCount, VkBuffer * pBuffers, VkDeviceSize * pOffsets) @extern("vkCmdBindVertexBuffers"); +fn void cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageBlit * pRegions, VkFilter filter) @extern("vkCmdBlitImage"); +fn void cmdClearAttachments (VkCommandBuffer commandBuffer, uint attachmentCount, VkClearAttachment * pAttachments, uint rectCount, VkClearRect * pRects) @extern("vkCmdClearAttachments"); +fn void cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue * pColor, uint rangeCount, VkImageSubresourceRange * pRanges) @extern("vkCmdClearColorImage"); +fn void cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue * pDepthStencil, uint rangeCount, VkImageSubresourceRange * pRanges) @extern("vkCmdClearDepthStencilImage"); +fn void cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint regionCount, VkBufferCopy * pRegions) @extern("vkCmdCopyBuffer"); +fn void cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkBufferImageCopy * pRegions) @extern("vkCmdCopyBufferToImage"); +fn void cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageCopy * pRegions) @extern("vkCmdCopyImage"); +fn void cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint regionCount, VkBufferImageCopy * pRegions) @extern("vkCmdCopyImageToBuffer"); +fn void cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) @extern("vkCmdCopyQueryPoolResults"); +fn void cmdDispatch (VkCommandBuffer commandBuffer, uint groupCountX, uint groupCountY, uint groupCountZ) @extern("vkCmdDispatch"); +fn void cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) @extern("vkCmdDispatchIndirect"); +fn void cmdDraw (VkCommandBuffer commandBuffer, uint vertexCount, uint instanceCount, uint firstVertex, uint firstInstance) @extern("vkCmdDraw"); +fn void cmdDrawIndexed (VkCommandBuffer commandBuffer, uint indexCount, uint instanceCount, uint firstIndex, int vertexOffset, uint firstInstance) @extern("vkCmdDrawIndexed"); +fn void cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride) @extern("vkCmdDrawIndexedIndirect"); +fn void cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride) @extern("vkCmdDrawIndirect"); +fn void cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query) @extern("vkCmdEndQuery"); +fn void cmdEndRenderPass (VkCommandBuffer commandBuffer) @extern("vkCmdEndRenderPass"); +fn void cmdExecuteCommands (VkCommandBuffer commandBuffer, uint commandBufferCount, VkCommandBuffer * pCommandBuffers) @extern("vkCmdExecuteCommands"); +fn void cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint data) @extern("vkCmdFillBuffer"); +fn void cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents) @extern("vkCmdNextSubpass"); +fn void cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint memoryBarrierCount, VkMemoryBarrier * pMemoryBarriers, uint bufferMemoryBarrierCount, VkBufferMemoryBarrier * pBufferMemoryBarriers, uint imageMemoryBarrierCount, VkImageMemoryBarrier * pImageMemoryBarriers) @extern("vkCmdPipelineBarrier"); +fn void cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint offset, uint size, void * pValues) @extern("vkCmdPushConstants"); +fn void cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) @extern("vkCmdResetEvent"); +fn void cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount) @extern("vkCmdResetQueryPool"); +fn void cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageResolve * pRegions) @extern("vkCmdResolveImage"); +fn void cmdSetBlendConstants (VkCommandBuffer commandBuffer, float[4] blendConstants) @extern("vkCmdSetBlendConstants"); +fn void cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) @extern("vkCmdSetDepthBias"); +fn void cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) @extern("vkCmdSetDepthBounds"); +fn void cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) @extern("vkCmdSetEvent"); +fn void cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth) @extern("vkCmdSetLineWidth"); +fn void cmdSetScissor (VkCommandBuffer commandBuffer, uint firstScissor, uint scissorCount, VkRect2D * pScissors) @extern("vkCmdSetScissor"); +fn void cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint compareMask) @extern("vkCmdSetStencilCompareMask"); +fn void cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint reference) @extern("vkCmdSetStencilReference"); +fn void cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint writeMask) @extern("vkCmdSetStencilWriteMask"); +fn void cmdSetViewport (VkCommandBuffer commandBuffer, uint firstViewport, uint viewportCount, VkViewport * pViewports) @extern("vkCmdSetViewport"); +fn void cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, void * pData) @extern("vkCmdUpdateBuffer"); +fn void cmdWaitEvents (VkCommandBuffer commandBuffer, uint eventCount, VkEvent * pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint memoryBarrierCount, VkMemoryBarrier * pMemoryBarriers, uint bufferMemoryBarrierCount, VkBufferMemoryBarrier * pBufferMemoryBarriers, uint imageMemoryBarrierCount, VkImageMemoryBarrier * pImageMemoryBarriers) @extern("vkCmdWaitEvents"); +fn void cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint query) @extern("vkCmdWriteTimestamp"); +fn VkResult createBuffer (VkDevice device, VkBufferCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkBuffer * pBuffer) @extern("vkCreateBuffer"); +fn VkResult createBufferView (VkDevice device, VkBufferViewCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkBufferView * pView) @extern("vkCreateBufferView"); +fn VkResult createCommandPool (VkDevice device, VkCommandPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkCommandPool * pCommandPool) @extern("vkCreateCommandPool"); +fn VkResult createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkComputePipelineCreateInfo * pCreateInfos, VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines) @extern("vkCreateComputePipelines"); +fn VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorPool * pDescriptorPool) @extern("vkCreateDescriptorPool"); +fn VkResult createDescriptorSetLayout (VkDevice device, VkDescriptorSetLayoutCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorSetLayout * pSetLayout) @extern("vkCreateDescriptorSetLayout"); +fn VkResult createDevice (VkPhysicalDevice physicalDevice, VkDeviceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDevice * pDevice) @extern("vkCreateDevice"); +fn VkResult createEvent (VkDevice device, VkEventCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkEvent * pEvent) @extern("vkCreateEvent"); +fn VkResult createFence (VkDevice device, VkFenceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkFence * pFence) @extern("vkCreateFence"); +fn VkResult createFramebuffer (VkDevice device, VkFramebufferCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkFramebuffer * pFramebuffer) @extern("vkCreateFramebuffer"); +fn VkResult createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkGraphicsPipelineCreateInfo * pCreateInfos, VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines) @extern("vkCreateGraphicsPipelines"); +fn VkResult createImage (VkDevice device, VkImageCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkImage * pImage) @extern("vkCreateImage"); +fn VkResult createImageView (VkDevice device, VkImageViewCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkImageView * pView) @extern("vkCreateImageView"); +fn VkResult createInstance (VkInstanceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkInstance * pInstance) @extern("vkCreateInstance"); +fn VkResult createPipelineCache (VkDevice device, VkPipelineCacheCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkPipelineCache * pPipelineCache) @extern("vkCreatePipelineCache"); +fn VkResult createPipelineLayout (VkDevice device, VkPipelineLayoutCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkPipelineLayout * pPipelineLayout) @extern("vkCreatePipelineLayout"); +fn VkResult createQueryPool (VkDevice device, VkQueryPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkQueryPool * pQueryPool) @extern("vkCreateQueryPool"); +fn VkResult createRenderPass (VkDevice device, VkRenderPassCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass) @extern("vkCreateRenderPass"); +fn VkResult createSampler (VkDevice device, VkSamplerCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSampler * pSampler) @extern("vkCreateSampler"); +fn VkResult createSemaphore (VkDevice device, VkSemaphoreCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSemaphore * pSemaphore) @extern("vkCreateSemaphore"); +fn VkResult createShaderModule (VkDevice device, VkShaderModuleCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkShaderModule * pShaderModule) @extern("vkCreateShaderModule"); +fn void destroyBuffer (VkDevice device, VkBuffer buffer, VkAllocationCallbacks * pAllocator) @extern("vkDestroyBuffer"); +fn void destroyBufferView (VkDevice device, VkBufferView bufferView, VkAllocationCallbacks * pAllocator) @extern("vkDestroyBufferView"); +fn void destroyCommandPool (VkDevice device, VkCommandPool commandPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyCommandPool"); +fn void destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorPool"); +fn void destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorSetLayout"); +fn void destroyDevice (VkDevice device, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDevice"); +fn void destroyEvent (VkDevice device, VkEvent event, VkAllocationCallbacks * pAllocator) @extern("vkDestroyEvent"); +fn void destroyFence (VkDevice device, VkFence fence, VkAllocationCallbacks * pAllocator) @extern("vkDestroyFence"); +fn void destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, VkAllocationCallbacks * pAllocator) @extern("vkDestroyFramebuffer"); +fn void destroyImage (VkDevice device, VkImage image, VkAllocationCallbacks * pAllocator) @extern("vkDestroyImage"); +fn void destroyImageView (VkDevice device, VkImageView imageView, VkAllocationCallbacks * pAllocator) @extern("vkDestroyImageView"); +fn void destroyInstance (VkInstance instance, VkAllocationCallbacks * pAllocator) @extern("vkDestroyInstance"); +fn void destroyPipeline (VkDevice device, VkPipeline pipeline, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipeline"); +fn void destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipelineCache"); +fn void destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipelineLayout"); +fn void destroyQueryPool (VkDevice device, VkQueryPool queryPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyQueryPool"); +fn void destroyRenderPass (VkDevice device, VkRenderPass renderPass, VkAllocationCallbacks * pAllocator) @extern("vkDestroyRenderPass"); +fn void destroySampler (VkDevice device, VkSampler sampler, VkAllocationCallbacks * pAllocator) @extern("vkDestroySampler"); +fn void destroySemaphore (VkDevice device, VkSemaphore semaphore, VkAllocationCallbacks * pAllocator) @extern("vkDestroySemaphore"); +fn void destroyShaderModule (VkDevice device, VkShaderModule shaderModule, VkAllocationCallbacks * pAllocator) @extern("vkDestroyShaderModule"); +fn VkResult deviceWaitIdle (VkDevice device) @extern("vkDeviceWaitIdle"); +fn VkResult endCommandBuffer (VkCommandBuffer commandBuffer) @extern("vkEndCommandBuffer"); +fn VkResult enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, ZString pLayerName, uint * pPropertyCount, VkExtensionProperties * pProperties) @extern("vkEnumerateDeviceExtensionProperties"); +fn VkResult enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, uint * pPropertyCount, VkLayerProperties * pProperties) @extern("vkEnumerateDeviceLayerProperties"); +fn VkResult enumerateInstanceExtensionProperties (ZString pLayerName, uint * pPropertyCount, VkExtensionProperties * pProperties) @extern("vkEnumerateInstanceExtensionProperties"); +fn VkResult enumerateInstanceLayerProperties (uint * pPropertyCount, VkLayerProperties * pProperties) @extern("vkEnumerateInstanceLayerProperties"); +fn VkResult enumeratePhysicalDevices (VkInstance instance, uint * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices) @extern("vkEnumeratePhysicalDevices"); +fn VkResult flushMappedMemoryRanges (VkDevice device, uint memoryRangeCount, VkMappedMemoryRange * pMemoryRanges) @extern("vkFlushMappedMemoryRanges"); +fn void freeCommandBuffers (VkDevice device, VkCommandPool commandPool, uint commandBufferCount, VkCommandBuffer * pCommandBuffers) @extern("vkFreeCommandBuffers"); +fn VkResult freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, uint descriptorSetCount, VkDescriptorSet * pDescriptorSets) @extern("vkFreeDescriptorSets"); +fn void freeMemory (VkDevice device, VkDeviceMemory memory, VkAllocationCallbacks * pAllocator) @extern("vkFreeMemory"); +fn void getBufferMemoryRequirements (VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements) @extern("vkGetBufferMemoryRequirements"); +fn void getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes) @extern("vkGetDeviceMemoryCommitment"); +fn PFN_vkVoidFunction getDeviceProcAddr (VkDevice device, ZString pName) @extern("vkGetDeviceProcAddr"); +fn void getDeviceQueue (VkDevice device, uint queueFamilyIndex, uint queueIndex, VkQueue * pQueue) @extern("vkGetDeviceQueue"); +fn VkResult getEventStatus (VkDevice device, VkEvent event) @extern("vkGetEventStatus"); +fn VkResult getFenceStatus (VkDevice device, VkFence fence) @extern("vkGetFenceStatus"); +fn void getImageMemoryRequirements (VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements) @extern("vkGetImageMemoryRequirements"); +fn void getImageSparseMemoryRequirements (VkDevice device, VkImage image, uint * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements * pSparseMemoryRequirements) @extern("vkGetImageSparseMemoryRequirements"); +fn void getImageSubresourceLayout (VkDevice device, VkImage image, VkImageSubresource * pSubresource, VkSubresourceLayout * pLayout) @extern("vkGetImageSubresourceLayout"); +fn PFN_vkVoidFunction getInstanceProcAddr (VkInstance instance, ZString pName) @extern("vkGetInstanceProcAddr"); +fn void getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures) @extern("vkGetPhysicalDeviceFeatures"); +fn void getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties) @extern("vkGetPhysicalDeviceFormatProperties"); +fn VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties * pImageFormatProperties) @extern("vkGetPhysicalDeviceImageFormatProperties"); +fn void getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties) @extern("vkGetPhysicalDeviceMemoryProperties"); +fn void getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties) @extern("vkGetPhysicalDeviceProperties"); +fn void getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice physicalDevice, uint * pQueueFamilyPropertyCount, VkQueueFamilyProperties * pQueueFamilyProperties) @extern("vkGetPhysicalDeviceQueueFamilyProperties"); +fn void getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint * pPropertyCount, VkSparseImageFormatProperties * pProperties) @extern("vkGetPhysicalDeviceSparseImageFormatProperties"); +fn VkResult getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, usz * pDataSize, void * pData) @extern("vkGetPipelineCacheData"); +fn VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, uint firstQuery, uint queryCount, usz dataSize, void * pData, VkDeviceSize stride, VkQueryResultFlags flags) @extern("vkGetQueryPoolResults"); +fn void getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity) @extern("vkGetRenderAreaGranularity"); +fn VkResult invalidateMappedMemoryRanges (VkDevice device, uint memoryRangeCount, VkMappedMemoryRange * pMemoryRanges) @extern("vkInvalidateMappedMemoryRanges"); +fn VkResult mapMemory (VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData) @extern("vkMapMemory"); +fn VkResult mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, uint srcCacheCount, VkPipelineCache * pSrcCaches) @extern("vkMergePipelineCaches"); +fn VkResult queueBindSparse (VkQueue queue, uint bindInfoCount, VkBindSparseInfo * pBindInfo, VkFence fence) @extern("vkQueueBindSparse"); +fn VkResult queueSubmit (VkQueue queue, uint submitCount, VkSubmitInfo * pSubmits, VkFence fence) @extern("vkQueueSubmit"); +fn VkResult queueWaitIdle (VkQueue queue) @extern("vkQueueWaitIdle"); +fn VkResult resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) @extern("vkResetCommandBuffer"); +fn VkResult resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) @extern("vkResetCommandPool"); +fn VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) @extern("vkResetDescriptorPool"); +fn VkResult resetEvent (VkDevice device, VkEvent event) @extern("vkResetEvent"); +fn VkResult resetFences (VkDevice device, uint fenceCount, VkFence * pFences) @extern("vkResetFences"); +fn VkResult setEvent (VkDevice device, VkEvent event) @extern("vkSetEvent"); +fn void unmapMemory (VkDevice device, VkDeviceMemory memory) @extern("vkUnmapMemory"); +fn void updateDescriptorSets (VkDevice device, uint descriptorWriteCount, VkWriteDescriptorSet * pDescriptorWrites, uint descriptorCopyCount, VkCopyDescriptorSet * pDescriptorCopies) @extern("vkUpdateDescriptorSets"); +fn VkResult waitForFences (VkDevice device, uint fenceCount, VkFence * pFences, VkBool32 waitAll, ulong timeout) @extern("vkWaitForFences"); diff --git a/libraries/vulkan.c3l/vk11.c3i b/libraries/vulkan.c3l/vk11.c3i new file mode 100644 index 0000000..c90bea4 --- /dev/null +++ b/libraries/vulkan.c3l/vk11.c3i @@ -0,0 +1,3241 @@ +module vulkan::vk @if(internal::vk_version() == VK_API_VERSION_1_1); +import vulkan; + +//Adapted from the glad loader generator at: https://gen.glad.sh. +//License/ Information: +/** + * Loader generated by glad 2.0.7 on Sat Sep 14 23:09:25 2024 + * + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + * + * Generator: C/C++ + * Specification: vk + * Extensions: 0 + * + * APIs: + * - vulkan=1.1 + * + * Options: + * - ALIAS = False + * - DEBUG = False + * - HEADER_ONLY = False + * - LOADER = False + * - MX = False + * - ON_DEMAND = False + * + * Commandline: + * --api='vulkan=1.1' --extensions='' c + * + * Online: + * http://glad.sh/#api=vulkan%3D1.1&extensions=&generator=c&options= + * + */ + + +const VK_ATTACHMENT_UNUSED = (~0U); +const VK_FALSE = 0; +const VK_LOD_CLAMP_NONE = 1000.0F; +const VK_LUID_SIZE = 8; +const VK_MAX_DESCRIPTION_SIZE = 256; +const VK_MAX_DEVICE_GROUP_SIZE = 32; +const VK_MAX_EXTENSION_NAME_SIZE = 256; +const VK_MAX_MEMORY_HEAPS = 16; +const VK_MAX_MEMORY_TYPES = 32; +const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256; +const VK_QUEUE_FAMILY_EXTERNAL = (~1U); +const VK_QUEUE_FAMILY_IGNORED = (~0U); +const VK_REMAINING_ARRAY_LAYERS = (~0U); +const VK_REMAINING_MIP_LEVELS = (~0U); +const VK_SUBPASS_EXTERNAL = (~0U); +const VK_TRUE = 1; +const VK_UUID_SIZE = 16; +const ulong VK_WHOLE_SIZE = (~0); + + +distinct VkInstance = uptr; +distinct VkPhysicalDevice = uptr; +distinct VkDevice = uptr; +distinct VkQueue = uptr; +distinct VkCommandBuffer = uptr; +distinct VkDeviceMemory = uptr; +distinct VkCommandPool = uptr; +distinct VkBuffer = uptr; +distinct VkBufferView = uptr; +distinct VkImage = uptr; +distinct VkImageView = uptr; +distinct VkShaderModule = uptr; +distinct VkPipeline = uptr; +distinct VkPipelineLayout = uptr; +distinct VkSampler = uptr; +distinct VkDescriptorSet = uptr; +distinct VkDescriptorSetLayout = uptr; +distinct VkDescriptorPool = uptr; +distinct VkFence = uptr; +distinct VkSemaphore = uptr; +distinct VkEvent = uptr; +distinct VkQueryPool = uptr; +distinct VkFramebuffer = uptr; +distinct VkRenderPass = uptr; +distinct VkPipelineCache = uptr; +distinct VkDescriptorUpdateTemplate = uptr; +distinct VkSamplerYcbcrConversion = uptr; +enum VkAttachmentLoadOp : int (int value) +{ + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkAttachmentStoreOp : int (int value) +{ + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkBlendFactor : int (int value) +{ + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkBlendOp : int (int value) +{ + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkBorderColor : int (int value) +{ + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineCacheHeaderVersion : int (int value) +{ + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} +enum VkDeviceQueueCreateFlagBits : int (int value) +{ + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 1, + VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkBufferCreateFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkBufferUsageFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkColorComponentFlagBits : int (int value) +{ + VK_COLOR_COMPONENT_R_BIT = 1, + VK_COLOR_COMPONENT_G_BIT = 2, + VK_COLOR_COMPONENT_B_BIT = 4, + VK_COLOR_COMPONENT_A_BIT = 8, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkComponentSwizzle : int (int value) +{ + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandPoolCreateFlagBits : int (int value) +{ + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 4, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandPoolResetFlagBits : int (int value) +{ + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferResetFlagBits : int (int value) +{ + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferLevel : int (int value) +{ + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferUsageFlagBits : int (int value) +{ + 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, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCompareOp : int (int value) +{ + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkCullModeFlagBits : int (int value) +{ + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 1, + VK_CULL_MODE_BACK_BIT = 2, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorType : int (int value) +{ + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkDynamicState : int (int value) +{ + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} +enum VkFenceCreateFlagBits : int (int value) +{ + VK_FENCE_CREATE_SIGNALED_BIT = 1, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPolygonMode : int (int value) +{ + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkFormat : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkFormatFeatureFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkFrontFace : int (int value) +{ + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageAspectFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageCreateFlagBits : int (int value) +{ + 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, + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageLayout : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageTiling : int (int value) +{ + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageType : int (int value) +{ + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageUsageFlagBits : int (int value) +{ + 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, + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageViewType : int (int value) +{ + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSharingMode : int (int value) +{ + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkIndexType : int (int value) +{ + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkLogicOp : int (int value) +{ + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryHeapFlagBits : int (int value) +{ + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 2, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkAccessFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryPropertyFlagBits : int (int value) +{ + 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, + VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPhysicalDeviceType : int (int value) +{ + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineBindPoint : int (int value) +{ + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineCreateFlagBits : int (int value) +{ + 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 = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPrimitiveTopology : int (int value) +{ + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryControlFlagBits : int (int value) +{ + VK_QUERY_CONTROL_PRECISE_BIT = 1, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryPipelineStatisticFlagBits : int (int value) +{ + 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, + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryResultFlagBits : int (int value) +{ + 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, + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryType : int (int value) +{ + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueueFlagBits : int (int value) +{ + 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, + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSubpassContents : int (int value) +{ + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} +enum VkResult : int (int value) +{ + 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_RESULT_MAX_ENUM = 0x7FFFFFFF +} +enum VkShaderStageFlagBits : int (int value) +{ + 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, + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSparseMemoryBindFlagBits : int (int value) +{ + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkStencilFaceFlagBits : int (int value) +{ + VK_STENCIL_FACE_FRONT_BIT = 1, + VK_STENCIL_FACE_BACK_BIT = 2, + VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, + VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkStencilOp : int (int value) +{ + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkStructureType : int (int value) +{ + 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 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + 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 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSystemAllocationScope : int (int value) +{ + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkInternalAllocationType : int (int value) +{ + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerAddressMode : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkFilter : int (int value) +{ + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerMipmapMode : int (int value) +{ + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkVertexInputRate : int (int value) +{ + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineStageFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSparseImageFormatFlagBits : int (int value) +{ + 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, + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSampleCountFlagBits : int (int value) +{ + 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, + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkAttachmentDescriptionFlagBits : int (int value) +{ + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorPoolCreateFlagBits : int (int value) +{ + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDependencyFlagBits : int (int value) +{ + VK_DEPENDENCY_BY_REGION_BIT = 1, + VK_DEPENDENCY_DEVICE_GROUP_BIT = 4, + VK_DEPENDENCY_VIEW_LOCAL_BIT = 2, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkObjectType : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorUpdateTemplateType : int (int value) +{ + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPointClippingBehavior : int (int value) +{ + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalMemoryHandleTypeFlagBits : int (int value) +{ + 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, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalMemoryFeatureFlagBits : int (int value) +{ + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalSemaphoreHandleTypeFlagBits : int (int value) +{ + 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 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 16, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalSemaphoreFeatureFlagBits : int (int value) +{ + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSemaphoreImportFlagBits : int (int value) +{ + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalFenceHandleTypeFlagBits : int (int value) +{ + 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, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalFenceFeatureFlagBits : int (int value) +{ + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkFenceImportFlagBits : int (int value) +{ + VK_FENCE_IMPORT_TEMPORARY_BIT = 1, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPeerMemoryFeatureFlagBits : int (int value) +{ + 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, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryAllocateFlagBits : int (int value) +{ + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSubgroupFeatureFlagBits : int (int value) +{ + 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, + VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkTessellationDomainOrigin : int (int value) +{ + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerYcbcrModelConversion : int (int value) +{ + 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, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerYcbcrRange : int (int value) +{ + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF +} +enum VkChromaLocation : int (int value) +{ + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, + VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF +} +enum VkVendorId : int (int value) +{ + VK_VENDOR_ID_KHRONOS = 0x10000, + 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, + VK_VENDOR_ID_MOBILEYE = 0x10007, + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} +def PFN_vkInternalAllocationNotification = fn void ( + void* pUserData, + usz size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); +def PFN_vkInternalFreeNotification = fn void ( + void* pUserData, + usz size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); +def PFN_vkReallocationFunction = fn void* ( + void* pUserData, + void* pOriginal, + usz size, + usz alignment, + VkSystemAllocationScope allocationScope); +def PFN_vkAllocationFunction = fn void* ( + void* pUserData, + usz size, + usz alignment, + VkSystemAllocationScope allocationScope); +def PFN_vkFreeFunction = fn void ( + void* pUserData, + void* pMemory); +def PFN_vkVoidFunction = fn void (); +struct VkBaseOutStructure +{ + VkStructureType sType; + VkBaseOutStructure * pNext; +} + +struct VkBaseInStructure +{ + VkStructureType sType; + VkBaseInStructure * pNext; +} + +struct VkOffset2D +{ + int x; + int y; +} + +struct VkOffset3D +{ + int x; + int y; + int z; +} + +struct VkExtent2D +{ + uint width; + uint height; +} + +struct VkExtent3D +{ + uint width; + uint height; + uint depth; +} + +struct VkViewport +{ + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} + +struct VkRect2D +{ + VkOffset2D offset; + VkExtent2D extent; +} + +struct VkClearRect +{ + VkRect2D rect; + uint baseArrayLayer; + uint layerCount; +} + +struct VkComponentMapping +{ + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} + +struct VkExtensionProperties +{ + char[ VK_MAX_EXTENSION_NAME_SIZE ] extensionName; + uint specVersion; +} + +struct VkLayerProperties +{ + char[ VK_MAX_EXTENSION_NAME_SIZE ] layerName; + uint specVersion; + uint implementationVersion; + char[ VK_MAX_DESCRIPTION_SIZE ] description; +} + +struct VkApplicationInfo +{ + VkStructureType sType; + void * pNext; + char * pApplicationName; + uint applicationVersion; + char * pEngineName; + uint engineVersion; + uint apiVersion; +} + +struct VkAllocationCallbacks +{ + void * pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} + +struct VkDescriptorImageInfo +{ + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} + +struct VkCopyDescriptorSet +{ + VkStructureType sType; + void * pNext; + VkDescriptorSet srcSet; + uint srcBinding; + uint srcArrayElement; + VkDescriptorSet dstSet; + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; +} + +struct VkDescriptorPoolSize +{ + VkDescriptorType type; + uint descriptorCount; +} + +struct VkDescriptorSetAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorPool descriptorPool; + uint descriptorSetCount; + VkDescriptorSetLayout * pSetLayouts; +} + +struct VkSpecializationMapEntry +{ + uint constantID; + uint offset; + usz size; +} + +struct VkSpecializationInfo +{ + uint mapEntryCount; + VkSpecializationMapEntry * pMapEntries; + usz dataSize; + void * pData; +} + +struct VkVertexInputBindingDescription +{ + uint binding; + uint stride; + VkVertexInputRate inputRate; +} + +struct VkVertexInputAttributeDescription +{ + uint location; + uint binding; + VkFormat format; + uint offset; +} + +struct VkStencilOpState +{ + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint compareMask; + uint writeMask; + uint reference; +} + +struct VkPipelineCacheHeaderVersionOne +{ + uint headerSize; + VkPipelineCacheHeaderVersion headerVersion; + uint vendorID; + uint deviceID; + char[ VK_UUID_SIZE ] pipelineCacheUUID; +} + +struct VkCommandBufferAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint commandBufferCount; +} + +union VkClearColorValue { + float[4] float32; + int[4] int32; + uint[4] uint32; +} + +struct VkClearDepthStencilValue +{ + float depth; + uint stencil; +} + +union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} + +struct VkAttachmentReference +{ + uint attachment; + VkImageLayout layout; +} + +struct VkDrawIndirectCommand +{ + uint vertexCount; + uint instanceCount; + uint firstVertex; + uint firstInstance; +} + +struct VkDrawIndexedIndirectCommand +{ + uint indexCount; + uint instanceCount; + uint firstIndex; + int vertexOffset; + uint firstInstance; +} + +struct VkDispatchIndirectCommand +{ + uint x; + uint y; + uint z; +} + +struct VkPhysicalDeviceExternalImageFormatInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} + +struct VkPhysicalDeviceExternalSemaphoreInfo +{ + VkStructureType sType; + void * pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} + +struct VkPhysicalDeviceExternalFenceInfo +{ + VkStructureType sType; + void * pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} + +struct VkPhysicalDeviceMultiviewProperties +{ + VkStructureType sType; + void * pNext; + uint maxMultiviewViewCount; + uint maxMultiviewInstanceIndex; +} + +struct VkRenderPassMultiviewCreateInfo +{ + VkStructureType sType; + void * pNext; + uint subpassCount; + uint * pViewMasks; + uint dependencyCount; + int * pViewOffsets; + uint correlationMaskCount; + uint * pCorrelationMasks; +} + +struct VkBindBufferMemoryDeviceGroupInfo +{ + VkStructureType sType; + void * pNext; + uint deviceIndexCount; + uint * pDeviceIndices; +} + +struct VkBindImageMemoryDeviceGroupInfo +{ + VkStructureType sType; + void * pNext; + uint deviceIndexCount; + uint * pDeviceIndices; + uint splitInstanceBindRegionCount; + VkRect2D * pSplitInstanceBindRegions; +} + +struct VkDeviceGroupRenderPassBeginInfo +{ + VkStructureType sType; + void * pNext; + uint deviceMask; + uint deviceRenderAreaCount; + VkRect2D * pDeviceRenderAreas; +} + +struct VkDeviceGroupCommandBufferBeginInfo +{ + VkStructureType sType; + void * pNext; + uint deviceMask; +} + +struct VkDeviceGroupSubmitInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + uint * pWaitSemaphoreDeviceIndices; + uint commandBufferCount; + uint * pCommandBufferDeviceMasks; + uint signalSemaphoreCount; + uint * pSignalSemaphoreDeviceIndices; +} + +struct VkDeviceGroupBindSparseInfo +{ + VkStructureType sType; + void * pNext; + uint resourceDeviceIndex; + uint memoryDeviceIndex; +} + +struct VkDeviceGroupDeviceCreateInfo +{ + VkStructureType sType; + void * pNext; + uint physicalDeviceCount; + VkPhysicalDevice * pPhysicalDevices; +} + +struct VkDescriptorUpdateTemplateEntry +{ + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; + VkDescriptorType descriptorType; + usz offset; + usz stride; +} + +struct VkBufferMemoryRequirementsInfo2 +{ + VkStructureType sType; + void * pNext; + VkBuffer buffer; +} + +struct VkImageMemoryRequirementsInfo2 +{ + VkStructureType sType; + void * pNext; + VkImage image; +} + +struct VkImageSparseMemoryRequirementsInfo2 +{ + VkStructureType sType; + void * pNext; + VkImage image; +} + +struct VkPhysicalDevicePointClippingProperties +{ + VkStructureType sType; + void * pNext; + VkPointClippingBehavior pointClippingBehavior; +} + +struct VkMemoryDedicatedAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkImage image; + VkBuffer buffer; +} + +struct VkPipelineTessellationDomainOriginStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkTessellationDomainOrigin domainOrigin; +} + +struct VkSamplerYcbcrConversionInfo +{ + VkStructureType sType; + void * pNext; + VkSamplerYcbcrConversion conversion; +} + +struct VkBindImagePlaneMemoryInfo +{ + VkStructureType sType; + void * pNext; + VkImageAspectFlagBits planeAspect; +} + +struct VkImagePlaneMemoryRequirementsInfo +{ + VkStructureType sType; + void * pNext; + VkImageAspectFlagBits planeAspect; +} + +struct VkSamplerYcbcrConversionImageFormatProperties +{ + VkStructureType sType; + void * pNext; + uint combinedImageSamplerDescriptorCount; +} + +def VkSampleMask = uint; +def VkBool32 = uint; +def VkFlags = uint; +def VkDeviceSize = ulong; +def VkDeviceAddress = ulong; +def VkFramebufferCreateFlags = VkFlags; +def VkQueryPoolCreateFlags = VkFlags; +def VkRenderPassCreateFlags = VkFlags; +def VkSamplerCreateFlags = VkFlags; +def VkPipelineLayoutCreateFlags = VkFlags; +def VkPipelineCacheCreateFlags = VkFlags; +def VkPipelineDepthStencilStateCreateFlags = VkFlags; +def VkPipelineDynamicStateCreateFlags = VkFlags; +def VkPipelineColorBlendStateCreateFlags = VkFlags; +def VkPipelineMultisampleStateCreateFlags = VkFlags; +def VkPipelineRasterizationStateCreateFlags = VkFlags; +def VkPipelineViewportStateCreateFlags = VkFlags; +def VkPipelineTessellationStateCreateFlags = VkFlags; +def VkPipelineInputAssemblyStateCreateFlags = VkFlags; +def VkPipelineVertexInputStateCreateFlags = VkFlags; +def VkPipelineShaderStageCreateFlags = VkFlags; +def VkDescriptorSetLayoutCreateFlags = VkFlags; +def VkBufferViewCreateFlags = VkFlags; +def VkInstanceCreateFlags = VkFlags; +def VkDeviceCreateFlags = VkFlags; +def VkDeviceQueueCreateFlags = VkFlags; +def VkQueueFlags = VkFlags; +def VkMemoryPropertyFlags = VkFlags; +def VkMemoryHeapFlags = VkFlags; +def VkAccessFlags = VkFlags; +def VkBufferUsageFlags = VkFlags; +def VkBufferCreateFlags = VkFlags; +def VkShaderStageFlags = VkFlags; +def VkImageUsageFlags = VkFlags; +def VkImageCreateFlags = VkFlags; +def VkImageViewCreateFlags = VkFlags; +def VkPipelineCreateFlags = VkFlags; +def VkColorComponentFlags = VkFlags; +def VkFenceCreateFlags = VkFlags; +def VkSemaphoreCreateFlags = VkFlags; +def VkFormatFeatureFlags = VkFlags; +def VkQueryControlFlags = VkFlags; +def VkQueryResultFlags = VkFlags; +def VkShaderModuleCreateFlags = VkFlags; +def VkEventCreateFlags = VkFlags; +def VkCommandPoolCreateFlags = VkFlags; +def VkCommandPoolResetFlags = VkFlags; +def VkCommandBufferResetFlags = VkFlags; +def VkCommandBufferUsageFlags = VkFlags; +def VkQueryPipelineStatisticFlags = VkFlags; +def VkMemoryMapFlags = VkFlags; +def VkImageAspectFlags = VkFlags; +def VkSparseMemoryBindFlags = VkFlags; +def VkSparseImageFormatFlags = VkFlags; +def VkSubpassDescriptionFlags = VkFlags; +def VkPipelineStageFlags = VkFlags; +def VkSampleCountFlags = VkFlags; +def VkAttachmentDescriptionFlags = VkFlags; +def VkStencilFaceFlags = VkFlags; +def VkCullModeFlags = VkFlags; +def VkDescriptorPoolCreateFlags = VkFlags; +def VkDescriptorPoolResetFlags = VkFlags; +def VkDependencyFlags = VkFlags; +def VkSubgroupFeatureFlags = VkFlags; +def VkDescriptorUpdateTemplateCreateFlags = VkFlags; +def VkPeerMemoryFeatureFlags = VkFlags; +def VkMemoryAllocateFlags = VkFlags; +def VkCommandPoolTrimFlags = VkFlags; +def VkExternalMemoryHandleTypeFlags = VkFlags; +def VkExternalMemoryFeatureFlags = VkFlags; +def VkExternalSemaphoreHandleTypeFlags = VkFlags; +def VkExternalSemaphoreFeatureFlags = VkFlags; +def VkSemaphoreImportFlags = VkFlags; +def VkExternalFenceHandleTypeFlags = VkFlags; +def VkExternalFenceFeatureFlags = VkFlags; +def VkFenceImportFlags = VkFlags; +struct VkDeviceQueueCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceQueueCreateFlags flags; + uint queueFamilyIndex; + uint queueCount; + float * pQueuePriorities; +} + +struct VkInstanceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkInstanceCreateFlags flags; + VkApplicationInfo * pApplicationInfo; + uint enabledLayerCount; + ZString ppEnabledLayerNames; + uint enabledExtensionCount; + ZString ppEnabledExtensionNames; +} + +struct VkQueueFamilyProperties +{ + VkQueueFlags queueFlags; + uint queueCount; + uint timestampValidBits; + VkExtent3D minImageTransferGranularity; +} + +struct VkMemoryAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceSize allocationSize; + uint memoryTypeIndex; +} + +struct VkMemoryRequirements +{ + VkDeviceSize size; + VkDeviceSize alignment; + uint memoryTypeBits; +} + +struct VkSparseImageFormatProperties +{ + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} + +struct VkSparseImageMemoryRequirements +{ + VkSparseImageFormatProperties formatProperties; + uint imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} + +struct VkMemoryType +{ + VkMemoryPropertyFlags propertyFlags; + uint heapIndex; +} + +struct VkMemoryHeap +{ + VkDeviceSize size; + VkMemoryHeapFlags flags; +} + +struct VkMappedMemoryRange +{ + VkStructureType sType; + void * pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} + +struct VkFormatProperties +{ + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} + +struct VkImageFormatProperties +{ + VkExtent3D maxExtent; + uint maxMipLevels; + uint maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} + +struct VkDescriptorBufferInfo +{ + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} + +struct VkWriteDescriptorSet +{ + VkStructureType sType; + void * pNext; + VkDescriptorSet dstSet; + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; + VkDescriptorType descriptorType; + VkDescriptorImageInfo * pImageInfo; + VkDescriptorBufferInfo * pBufferInfo; + VkBufferView * pTexelBufferView; +} + +struct VkBufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint queueFamilyIndexCount; + uint * pQueueFamilyIndices; +} + +struct VkBufferViewCreateInfo +{ + VkStructureType sType; + void * pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} + +struct VkImageSubresource +{ + VkImageAspectFlags aspectMask; + uint mipLevel; + uint arrayLayer; +} + +struct VkImageSubresourceLayers +{ + VkImageAspectFlags aspectMask; + uint mipLevel; + uint baseArrayLayer; + uint layerCount; +} + +struct VkImageSubresourceRange +{ + VkImageAspectFlags aspectMask; + uint baseMipLevel; + uint levelCount; + uint baseArrayLayer; + uint layerCount; +} + +struct VkMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} + +struct VkBufferMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint srcQueueFamilyIndex; + uint dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} + +struct VkImageMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint srcQueueFamilyIndex; + uint dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} + +struct VkImageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint mipLevels; + uint arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint queueFamilyIndexCount; + uint * pQueueFamilyIndices; + VkImageLayout initialLayout; +} + +struct VkSubresourceLayout +{ + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} + +struct VkImageViewCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} + +struct VkBufferCopy +{ + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} + +struct VkSparseMemoryBind +{ + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} + +struct VkSparseImageMemoryBind +{ + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} + +struct VkSparseBufferMemoryBindInfo +{ + VkBuffer buffer; + uint bindCount; + VkSparseMemoryBind * pBinds; +} + +struct VkSparseImageOpaqueMemoryBindInfo +{ + VkImage image; + uint bindCount; + VkSparseMemoryBind * pBinds; +} + +struct VkSparseImageMemoryBindInfo +{ + VkImage image; + uint bindCount; + VkSparseImageMemoryBind * pBinds; +} + +struct VkBindSparseInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + VkSemaphore * pWaitSemaphores; + uint bufferBindCount; + VkSparseBufferMemoryBindInfo * pBufferBinds; + uint imageOpaqueBindCount; + VkSparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds; + uint imageBindCount; + VkSparseImageMemoryBindInfo * pImageBinds; + uint signalSemaphoreCount; + VkSemaphore * pSignalSemaphores; +} + +struct VkImageCopy +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} + +struct VkImageBlit +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D[2] srcOffsets; + VkImageSubresourceLayers dstSubresource; + VkOffset3D[2] dstOffsets; +} + +struct VkBufferImageCopy +{ + VkDeviceSize bufferOffset; + uint bufferRowLength; + uint bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} + +struct VkImageResolve +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} + +struct VkShaderModuleCreateInfo +{ + VkStructureType sType; + void * pNext; + VkShaderModuleCreateFlags flags; + usz codeSize; + uint * pCode; +} + +struct VkDescriptorSetLayoutBinding +{ + uint binding; + VkDescriptorType descriptorType; + uint descriptorCount; + VkShaderStageFlags stageFlags; + VkSampler * pImmutableSamplers; +} + +struct VkDescriptorSetLayoutCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint bindingCount; + VkDescriptorSetLayoutBinding * pBindings; +} + +struct VkDescriptorPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorPoolCreateFlags flags; + uint maxSets; + uint poolSizeCount; + VkDescriptorPoolSize * pPoolSizes; +} + +struct VkPipelineShaderStageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule vkmodule; + char * pName; + VkSpecializationInfo * pSpecializationInfo; +} + +struct VkComputePipelineCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int basePipelineIndex; +} + +struct VkPipelineVertexInputStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint vertexBindingDescriptionCount; + VkVertexInputBindingDescription * pVertexBindingDescriptions; + uint vertexAttributeDescriptionCount; + VkVertexInputAttributeDescription * pVertexAttributeDescriptions; +} + +struct VkPipelineInputAssemblyStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} + +struct VkPipelineTessellationStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineTessellationStateCreateFlags flags; + uint patchControlPoints; +} + +struct VkPipelineViewportStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineViewportStateCreateFlags flags; + uint viewportCount; + VkViewport * pViewports; + uint scissorCount; + VkRect2D * pScissors; +} + +struct VkPipelineRasterizationStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} + +struct VkPipelineMultisampleStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + VkSampleMask * pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} + +struct VkPipelineColorBlendAttachmentState +{ + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} + +struct VkPipelineColorBlendStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint attachmentCount; + VkPipelineColorBlendAttachmentState * pAttachments; + float[4] blendConstants; +} + +struct VkPipelineDynamicStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineDynamicStateCreateFlags flags; + uint dynamicStateCount; + VkDynamicState * pDynamicStates; +} + +struct VkPipelineDepthStencilStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} + +struct VkGraphicsPipelineCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCreateFlags flags; + uint stageCount; + VkPipelineShaderStageCreateInfo * pStages; + VkPipelineVertexInputStateCreateInfo * pVertexInputState; + VkPipelineInputAssemblyStateCreateInfo * pInputAssemblyState; + VkPipelineTessellationStateCreateInfo * pTessellationState; + VkPipelineViewportStateCreateInfo * pViewportState; + VkPipelineRasterizationStateCreateInfo * pRasterizationState; + VkPipelineMultisampleStateCreateInfo * pMultisampleState; + VkPipelineDepthStencilStateCreateInfo * pDepthStencilState; + VkPipelineColorBlendStateCreateInfo * pColorBlendState; + VkPipelineDynamicStateCreateInfo * pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint subpass; + VkPipeline basePipelineHandle; + int basePipelineIndex; +} + +struct VkPipelineCacheCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCacheCreateFlags flags; + usz initialDataSize; + void * pInitialData; +} + +struct VkPushConstantRange +{ + VkShaderStageFlags stageFlags; + uint offset; + uint size; +} + +struct VkPipelineLayoutCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineLayoutCreateFlags flags; + uint setLayoutCount; + VkDescriptorSetLayout * pSetLayouts; + uint pushConstantRangeCount; + VkPushConstantRange * pPushConstantRanges; +} + +struct VkSamplerCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} + +struct VkCommandPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkCommandPoolCreateFlags flags; + uint queueFamilyIndex; +} + +struct VkCommandBufferInheritanceInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPass renderPass; + uint subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} + +struct VkCommandBufferBeginInfo +{ + VkStructureType sType; + void * pNext; + VkCommandBufferUsageFlags flags; + VkCommandBufferInheritanceInfo * pInheritanceInfo; +} + +struct VkRenderPassBeginInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint clearValueCount; + VkClearValue * pClearValues; +} + +struct VkClearAttachment +{ + VkImageAspectFlags aspectMask; + uint colorAttachment; + VkClearValue clearValue; +} + +struct VkAttachmentDescription +{ + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} + +struct VkSubpassDescription +{ + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint inputAttachmentCount; + VkAttachmentReference * pInputAttachments; + uint colorAttachmentCount; + VkAttachmentReference * pColorAttachments; + VkAttachmentReference * pResolveAttachments; + VkAttachmentReference * pDepthStencilAttachment; + uint preserveAttachmentCount; + uint * pPreserveAttachments; +} + +struct VkSubpassDependency +{ + uint srcSubpass; + uint dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} + +struct VkRenderPassCreateInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPassCreateFlags flags; + uint attachmentCount; + VkAttachmentDescription * pAttachments; + uint subpassCount; + VkSubpassDescription * pSubpasses; + uint dependencyCount; + VkSubpassDependency * pDependencies; +} + +struct VkEventCreateInfo +{ + VkStructureType sType; + void * pNext; + VkEventCreateFlags flags; +} + +struct VkFenceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFenceCreateFlags flags; +} + +struct VkPhysicalDeviceFeatures +{ + VkBool32 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; +} + +struct VkPhysicalDeviceSparseProperties +{ + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} + +struct VkPhysicalDeviceLimits +{ + uint maxImageDimension1D; + uint maxImageDimension2D; + uint maxImageDimension3D; + uint maxImageDimensionCube; + uint maxImageArrayLayers; + uint maxTexelBufferElements; + uint maxUniformBufferRange; + uint maxStorageBufferRange; + uint maxPushConstantsSize; + uint maxMemoryAllocationCount; + uint maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint maxBoundDescriptorSets; + uint maxPerStageDescriptorSamplers; + uint maxPerStageDescriptorUniformBuffers; + uint maxPerStageDescriptorStorageBuffers; + uint maxPerStageDescriptorSampledImages; + uint maxPerStageDescriptorStorageImages; + uint maxPerStageDescriptorInputAttachments; + uint maxPerStageResources; + uint maxDescriptorSetSamplers; + uint maxDescriptorSetUniformBuffers; + uint maxDescriptorSetUniformBuffersDynamic; + uint maxDescriptorSetStorageBuffers; + uint maxDescriptorSetStorageBuffersDynamic; + uint maxDescriptorSetSampledImages; + uint maxDescriptorSetStorageImages; + uint maxDescriptorSetInputAttachments; + uint maxVertexInputAttributes; + uint maxVertexInputBindings; + uint maxVertexInputAttributeOffset; + uint maxVertexInputBindingStride; + uint maxVertexOutputComponents; + uint maxTessellationGenerationLevel; + uint maxTessellationPatchSize; + uint maxTessellationControlPerVertexInputComponents; + uint maxTessellationControlPerVertexOutputComponents; + uint maxTessellationControlPerPatchOutputComponents; + uint maxTessellationControlTotalOutputComponents; + uint maxTessellationEvaluationInputComponents; + uint maxTessellationEvaluationOutputComponents; + uint maxGeometryShaderInvocations; + uint maxGeometryInputComponents; + uint maxGeometryOutputComponents; + uint maxGeometryOutputVertices; + uint maxGeometryTotalOutputComponents; + uint maxFragmentInputComponents; + uint maxFragmentOutputAttachments; + uint maxFragmentDualSrcAttachments; + uint maxFragmentCombinedOutputResources; + uint maxComputeSharedMemorySize; + uint[3] maxComputeWorkGroupCount; + uint maxComputeWorkGroupInvocations; + uint[3] maxComputeWorkGroupSize; + uint subPixelPrecisionBits; + uint subTexelPrecisionBits; + uint mipmapPrecisionBits; + uint maxDrawIndexedIndexValue; + uint maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint maxViewports; + uint[2] maxViewportDimensions; + float[2] viewportBoundsRange; + uint viewportSubPixelBits; + usz minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int minTexelOffset; + uint maxTexelOffset; + int minTexelGatherOffset; + uint maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint subPixelInterpolationOffsetBits; + uint maxFramebufferWidth; + uint maxFramebufferHeight; + uint maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint maxClipDistances; + uint maxCullDistances; + uint maxCombinedClipAndCullDistances; + uint discreteQueuePriorities; + float[2] pointSizeRange; + float[2] lineWidthRange; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} + +struct VkSemaphoreCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphoreCreateFlags flags; +} + +struct VkQueryPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} + +struct VkFramebufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint attachmentCount; + VkImageView * pAttachments; + uint width; + uint height; + uint layers; +} + +struct VkSubmitInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + VkSemaphore * pWaitSemaphores; + VkPipelineStageFlags * pWaitDstStageMask; + uint commandBufferCount; + VkCommandBuffer * pCommandBuffers; + uint signalSemaphoreCount; + VkSemaphore * pSignalSemaphores; +} + +struct VkPhysicalDeviceFeatures2 +{ + VkStructureType sType; + void * pNext; + VkPhysicalDeviceFeatures features; +} + +struct VkFormatProperties2 +{ + VkStructureType sType; + void * pNext; + VkFormatProperties formatProperties; +} + +struct VkImageFormatProperties2 +{ + VkStructureType sType; + void * pNext; + VkImageFormatProperties imageFormatProperties; +} + +struct VkPhysicalDeviceImageFormatInfo2 +{ + VkStructureType sType; + void * pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} + +struct VkQueueFamilyProperties2 +{ + VkStructureType sType; + void * pNext; + VkQueueFamilyProperties queueFamilyProperties; +} + +struct VkSparseImageFormatProperties2 +{ + VkStructureType sType; + void * pNext; + VkSparseImageFormatProperties properties; +} + +struct VkPhysicalDeviceSparseImageFormatInfo2 +{ + VkStructureType sType; + void * pNext; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; +} + +struct VkPhysicalDeviceVariablePointersFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} + +def VkPhysicalDeviceVariablePointerFeatures = VkPhysicalDeviceVariablePointersFeatures; + +struct VkExternalMemoryProperties +{ + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} + +struct VkExternalImageFormatProperties +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryProperties externalMemoryProperties; +} + +struct VkPhysicalDeviceExternalBufferInfo +{ + VkStructureType sType; + void * pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} + +struct VkExternalBufferProperties +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryProperties externalMemoryProperties; +} + +struct VkPhysicalDeviceIDProperties +{ + VkStructureType sType; + void * pNext; + char[ VK_UUID_SIZE ] deviceUUID; + char[ VK_UUID_SIZE ] driverUUID; + char[ VK_LUID_SIZE ] deviceLUID; + uint deviceNodeMask; + VkBool32 deviceLUIDValid; +} + +struct VkExternalMemoryImageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} + +struct VkExternalMemoryBufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} + +struct VkExportMemoryAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} + +struct VkExternalSemaphoreProperties +{ + VkStructureType sType; + void * pNext; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} + +struct VkExportSemaphoreCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} + +struct VkExternalFenceProperties +{ + VkStructureType sType; + void * pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} + +struct VkExportFenceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} + +struct VkPhysicalDeviceMultiviewFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} + +struct VkPhysicalDeviceGroupProperties +{ + VkStructureType sType; + void * pNext; + uint physicalDeviceCount; + VkPhysicalDevice[ VK_MAX_DEVICE_GROUP_SIZE ] physicalDevices; + VkBool32 subsetAllocation; +} + +struct VkMemoryAllocateFlagsInfo +{ + VkStructureType sType; + void * pNext; + VkMemoryAllocateFlags flags; + uint deviceMask; +} + +struct VkBindBufferMemoryInfo +{ + VkStructureType sType; + void * pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} + +struct VkBindImageMemoryInfo +{ + VkStructureType sType; + void * pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} + +struct VkDescriptorUpdateTemplateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorUpdateTemplateCreateFlags flags; + uint descriptorUpdateEntryCount; + VkDescriptorUpdateTemplateEntry * pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint set; +} + +struct VkInputAttachmentAspectReference +{ + uint subpass; + uint inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} + +struct VkRenderPassInputAttachmentAspectCreateInfo +{ + VkStructureType sType; + void * pNext; + uint aspectReferenceCount; + VkInputAttachmentAspectReference * pAspectReferences; +} + +struct VkPhysicalDevice16BitStorageFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} + +struct VkPhysicalDeviceSubgroupProperties +{ + VkStructureType sType; + void * pNext; + uint subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} + +struct VkMemoryRequirements2 +{ + VkStructureType sType; + void * pNext; + VkMemoryRequirements memoryRequirements; +} + +struct VkSparseImageMemoryRequirements2 +{ + VkStructureType sType; + void * pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} + +struct VkMemoryDedicatedRequirements +{ + VkStructureType sType; + void * pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} + +struct VkImageViewUsageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageUsageFlags usage; +} + +struct VkSamplerYcbcrConversionCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} + +struct VkPhysicalDeviceSamplerYcbcrConversionFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 samplerYcbcrConversion; +} + +struct VkProtectedSubmitInfo +{ + VkStructureType sType; + void * pNext; + VkBool32 protectedSubmit; +} + +struct VkPhysicalDeviceProtectedMemoryFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 protectedMemory; +} + +struct VkPhysicalDeviceProtectedMemoryProperties +{ + VkStructureType sType; + void * pNext; + VkBool32 protectedNoFault; +} + +struct VkDeviceQueueInfo2 +{ + VkStructureType sType; + void * pNext; + VkDeviceQueueCreateFlags flags; + uint queueFamilyIndex; + uint queueIndex; +} + +struct VkPhysicalDeviceMaintenance3Properties +{ + VkStructureType sType; + void * pNext; + uint maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} + +struct VkDescriptorSetLayoutSupport +{ + VkStructureType sType; + void * pNext; + VkBool32 supported; +} + +struct VkPhysicalDeviceShaderDrawParametersFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderDrawParameters; +} + +def VkPhysicalDeviceShaderDrawParameterFeatures = VkPhysicalDeviceShaderDrawParametersFeatures; + +struct VkPhysicalDeviceProperties +{ + uint apiVersion; + uint driverVersion; + uint vendorID; + uint deviceID; + VkPhysicalDeviceType deviceType; + char[ VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ] deviceName; + char[ VK_UUID_SIZE ] pipelineCacheUUID; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} + +struct VkDeviceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceCreateFlags flags; + uint queueCreateInfoCount; + VkDeviceQueueCreateInfo * pQueueCreateInfos; + uint enabledLayerCount; + ZString ppEnabledLayerNames; + uint enabledExtensionCount; + ZString ppEnabledExtensionNames; + VkPhysicalDeviceFeatures * pEnabledFeatures; +} + +struct VkPhysicalDeviceMemoryProperties +{ + uint memoryTypeCount; + VkMemoryType[ VK_MAX_MEMORY_TYPES ] memoryTypes; + uint memoryHeapCount; + VkMemoryHeap[ VK_MAX_MEMORY_HEAPS ] memoryHeaps; +} + +struct VkPhysicalDeviceProperties2 +{ + VkStructureType sType; + void * pNext; + VkPhysicalDeviceProperties properties; +} + +struct VkPhysicalDeviceMemoryProperties2 +{ + VkStructureType sType; + void * pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} + + + +const VK_VERSION_1_0 = 1; +const VK_VERSION_1_1 = 1; + + + +fn VkResult allocateCommandBuffers (VkDevice device, VkCommandBufferAllocateInfo * pAllocateInfo, VkCommandBuffer * pCommandBuffers) @extern("vkAllocateCommandBuffers"); +fn VkResult allocateDescriptorSets (VkDevice device, VkDescriptorSetAllocateInfo * pAllocateInfo, VkDescriptorSet * pDescriptorSets) @extern("vkAllocateDescriptorSets"); +fn VkResult allocateMemory (VkDevice device, VkMemoryAllocateInfo * pAllocateInfo, VkAllocationCallbacks * pAllocator, VkDeviceMemory * pMemory) @extern("vkAllocateMemory"); +fn VkResult beginCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo * pBeginInfo) @extern("vkBeginCommandBuffer"); +fn VkResult bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) @extern("vkBindBufferMemory"); +fn VkResult bindBufferMemory2 (VkDevice device, uint bindInfoCount, VkBindBufferMemoryInfo * pBindInfos) @extern("vkBindBufferMemory2"); +fn VkResult bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) @extern("vkBindImageMemory"); +fn VkResult bindImageMemory2 (VkDevice device, uint bindInfoCount, VkBindImageMemoryInfo * pBindInfos) @extern("vkBindImageMemory2"); +fn void cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query, VkQueryControlFlags flags) @extern("vkCmdBeginQuery"); +fn void cmdBeginRenderPass (VkCommandBuffer commandBuffer, VkRenderPassBeginInfo * pRenderPassBegin, VkSubpassContents contents) @extern("vkCmdBeginRenderPass"); +fn void cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint firstSet, uint descriptorSetCount, VkDescriptorSet * pDescriptorSets, uint dynamicOffsetCount, uint * pDynamicOffsets) @extern("vkCmdBindDescriptorSets"); +fn void cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) @extern("vkCmdBindIndexBuffer"); +fn void cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) @extern("vkCmdBindPipeline"); +fn void cmdBindVertexBuffers (VkCommandBuffer commandBuffer, uint firstBinding, uint bindingCount, VkBuffer * pBuffers, VkDeviceSize * pOffsets) @extern("vkCmdBindVertexBuffers"); +fn void cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageBlit * pRegions, VkFilter filter) @extern("vkCmdBlitImage"); +fn void cmdClearAttachments (VkCommandBuffer commandBuffer, uint attachmentCount, VkClearAttachment * pAttachments, uint rectCount, VkClearRect * pRects) @extern("vkCmdClearAttachments"); +fn void cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue * pColor, uint rangeCount, VkImageSubresourceRange * pRanges) @extern("vkCmdClearColorImage"); +fn void cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue * pDepthStencil, uint rangeCount, VkImageSubresourceRange * pRanges) @extern("vkCmdClearDepthStencilImage"); +fn void cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint regionCount, VkBufferCopy * pRegions) @extern("vkCmdCopyBuffer"); +fn void cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkBufferImageCopy * pRegions) @extern("vkCmdCopyBufferToImage"); +fn void cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageCopy * pRegions) @extern("vkCmdCopyImage"); +fn void cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint regionCount, VkBufferImageCopy * pRegions) @extern("vkCmdCopyImageToBuffer"); +fn void cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) @extern("vkCmdCopyQueryPoolResults"); +fn void cmdDispatch (VkCommandBuffer commandBuffer, uint groupCountX, uint groupCountY, uint groupCountZ) @extern("vkCmdDispatch"); +fn void cmdDispatchBase (VkCommandBuffer commandBuffer, uint baseGroupX, uint baseGroupY, uint baseGroupZ, uint groupCountX, uint groupCountY, uint groupCountZ) @extern("vkCmdDispatchBase"); +fn void cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) @extern("vkCmdDispatchIndirect"); +fn void cmdDraw (VkCommandBuffer commandBuffer, uint vertexCount, uint instanceCount, uint firstVertex, uint firstInstance) @extern("vkCmdDraw"); +fn void cmdDrawIndexed (VkCommandBuffer commandBuffer, uint indexCount, uint instanceCount, uint firstIndex, int vertexOffset, uint firstInstance) @extern("vkCmdDrawIndexed"); +fn void cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride) @extern("vkCmdDrawIndexedIndirect"); +fn void cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride) @extern("vkCmdDrawIndirect"); +fn void cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query) @extern("vkCmdEndQuery"); +fn void cmdEndRenderPass (VkCommandBuffer commandBuffer) @extern("vkCmdEndRenderPass"); +fn void cmdExecuteCommands (VkCommandBuffer commandBuffer, uint commandBufferCount, VkCommandBuffer * pCommandBuffers) @extern("vkCmdExecuteCommands"); +fn void cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint data) @extern("vkCmdFillBuffer"); +fn void cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents) @extern("vkCmdNextSubpass"); +fn void cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint memoryBarrierCount, VkMemoryBarrier * pMemoryBarriers, uint bufferMemoryBarrierCount, VkBufferMemoryBarrier * pBufferMemoryBarriers, uint imageMemoryBarrierCount, VkImageMemoryBarrier * pImageMemoryBarriers) @extern("vkCmdPipelineBarrier"); +fn void cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint offset, uint size, void * pValues) @extern("vkCmdPushConstants"); +fn void cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) @extern("vkCmdResetEvent"); +fn void cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount) @extern("vkCmdResetQueryPool"); +fn void cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageResolve * pRegions) @extern("vkCmdResolveImage"); +fn void cmdSetBlendConstants (VkCommandBuffer commandBuffer, float[4] blendConstants) @extern("vkCmdSetBlendConstants"); +fn void cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) @extern("vkCmdSetDepthBias"); +fn void cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) @extern("vkCmdSetDepthBounds"); +fn void cmdSetDeviceMask (VkCommandBuffer commandBuffer, uint deviceMask) @extern("vkCmdSetDeviceMask"); +fn void cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) @extern("vkCmdSetEvent"); +fn void cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth) @extern("vkCmdSetLineWidth"); +fn void cmdSetScissor (VkCommandBuffer commandBuffer, uint firstScissor, uint scissorCount, VkRect2D * pScissors) @extern("vkCmdSetScissor"); +fn void cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint compareMask) @extern("vkCmdSetStencilCompareMask"); +fn void cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint reference) @extern("vkCmdSetStencilReference"); +fn void cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint writeMask) @extern("vkCmdSetStencilWriteMask"); +fn void cmdSetViewport (VkCommandBuffer commandBuffer, uint firstViewport, uint viewportCount, VkViewport * pViewports) @extern("vkCmdSetViewport"); +fn void cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, void * pData) @extern("vkCmdUpdateBuffer"); +fn void cmdWaitEvents (VkCommandBuffer commandBuffer, uint eventCount, VkEvent * pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint memoryBarrierCount, VkMemoryBarrier * pMemoryBarriers, uint bufferMemoryBarrierCount, VkBufferMemoryBarrier * pBufferMemoryBarriers, uint imageMemoryBarrierCount, VkImageMemoryBarrier * pImageMemoryBarriers) @extern("vkCmdWaitEvents"); +fn void cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint query) @extern("vkCmdWriteTimestamp"); +fn VkResult createBuffer (VkDevice device, VkBufferCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkBuffer * pBuffer) @extern("vkCreateBuffer"); +fn VkResult createBufferView (VkDevice device, VkBufferViewCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkBufferView * pView) @extern("vkCreateBufferView"); +fn VkResult createCommandPool (VkDevice device, VkCommandPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkCommandPool * pCommandPool) @extern("vkCreateCommandPool"); +fn VkResult createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkComputePipelineCreateInfo * pCreateInfos, VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines) @extern("vkCreateComputePipelines"); +fn VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorPool * pDescriptorPool) @extern("vkCreateDescriptorPool"); +fn VkResult createDescriptorSetLayout (VkDevice device, VkDescriptorSetLayoutCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorSetLayout * pSetLayout) @extern("vkCreateDescriptorSetLayout"); +fn VkResult createDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate) @extern("vkCreateDescriptorUpdateTemplate"); +fn VkResult createDevice (VkPhysicalDevice physicalDevice, VkDeviceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDevice * pDevice) @extern("vkCreateDevice"); +fn VkResult createEvent (VkDevice device, VkEventCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkEvent * pEvent) @extern("vkCreateEvent"); +fn VkResult createFence (VkDevice device, VkFenceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkFence * pFence) @extern("vkCreateFence"); +fn VkResult createFramebuffer (VkDevice device, VkFramebufferCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkFramebuffer * pFramebuffer) @extern("vkCreateFramebuffer"); +fn VkResult createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkGraphicsPipelineCreateInfo * pCreateInfos, VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines) @extern("vkCreateGraphicsPipelines"); +fn VkResult createImage (VkDevice device, VkImageCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkImage * pImage) @extern("vkCreateImage"); +fn VkResult createImageView (VkDevice device, VkImageViewCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkImageView * pView) @extern("vkCreateImageView"); +fn VkResult createInstance (VkInstanceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkInstance * pInstance) @extern("vkCreateInstance"); +fn VkResult createPipelineCache (VkDevice device, VkPipelineCacheCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkPipelineCache * pPipelineCache) @extern("vkCreatePipelineCache"); +fn VkResult createPipelineLayout (VkDevice device, VkPipelineLayoutCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkPipelineLayout * pPipelineLayout) @extern("vkCreatePipelineLayout"); +fn VkResult createQueryPool (VkDevice device, VkQueryPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkQueryPool * pQueryPool) @extern("vkCreateQueryPool"); +fn VkResult createRenderPass (VkDevice device, VkRenderPassCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass) @extern("vkCreateRenderPass"); +fn VkResult createSampler (VkDevice device, VkSamplerCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSampler * pSampler) @extern("vkCreateSampler"); +fn VkResult createSamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversionCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSamplerYcbcrConversion * pYcbcrConversion) @extern("vkCreateSamplerYcbcrConversion"); +fn VkResult createSemaphore (VkDevice device, VkSemaphoreCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSemaphore * pSemaphore) @extern("vkCreateSemaphore"); +fn VkResult createShaderModule (VkDevice device, VkShaderModuleCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkShaderModule * pShaderModule) @extern("vkCreateShaderModule"); +fn void destroyBuffer (VkDevice device, VkBuffer buffer, VkAllocationCallbacks * pAllocator) @extern("vkDestroyBuffer"); +fn void destroyBufferView (VkDevice device, VkBufferView bufferView, VkAllocationCallbacks * pAllocator) @extern("vkDestroyBufferView"); +fn void destroyCommandPool (VkDevice device, VkCommandPool commandPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyCommandPool"); +fn void destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorPool"); +fn void destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorSetLayout"); +fn void destroyDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorUpdateTemplate"); +fn void destroyDevice (VkDevice device, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDevice"); +fn void destroyEvent (VkDevice device, VkEvent event, VkAllocationCallbacks * pAllocator) @extern("vkDestroyEvent"); +fn void destroyFence (VkDevice device, VkFence fence, VkAllocationCallbacks * pAllocator) @extern("vkDestroyFence"); +fn void destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, VkAllocationCallbacks * pAllocator) @extern("vkDestroyFramebuffer"); +fn void destroyImage (VkDevice device, VkImage image, VkAllocationCallbacks * pAllocator) @extern("vkDestroyImage"); +fn void destroyImageView (VkDevice device, VkImageView imageView, VkAllocationCallbacks * pAllocator) @extern("vkDestroyImageView"); +fn void destroyInstance (VkInstance instance, VkAllocationCallbacks * pAllocator) @extern("vkDestroyInstance"); +fn void destroyPipeline (VkDevice device, VkPipeline pipeline, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipeline"); +fn void destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipelineCache"); +fn void destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipelineLayout"); +fn void destroyQueryPool (VkDevice device, VkQueryPool queryPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyQueryPool"); +fn void destroyRenderPass (VkDevice device, VkRenderPass renderPass, VkAllocationCallbacks * pAllocator) @extern("vkDestroyRenderPass"); +fn void destroySampler (VkDevice device, VkSampler sampler, VkAllocationCallbacks * pAllocator) @extern("vkDestroySampler"); +fn void destroySamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, VkAllocationCallbacks * pAllocator) @extern("vkDestroySamplerYcbcrConversion"); +fn void destroySemaphore (VkDevice device, VkSemaphore semaphore, VkAllocationCallbacks * pAllocator) @extern("vkDestroySemaphore"); +fn void destroyShaderModule (VkDevice device, VkShaderModule shaderModule, VkAllocationCallbacks * pAllocator) @extern("vkDestroyShaderModule"); +fn VkResult deviceWaitIdle (VkDevice device) @extern("vkDeviceWaitIdle"); +fn VkResult endCommandBuffer (VkCommandBuffer commandBuffer) @extern("vkEndCommandBuffer"); +fn VkResult enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, ZString pLayerName, uint * pPropertyCount, VkExtensionProperties * pProperties) @extern("vkEnumerateDeviceExtensionProperties"); +fn VkResult enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, uint * pPropertyCount, VkLayerProperties * pProperties) @extern("vkEnumerateDeviceLayerProperties"); +fn VkResult enumerateInstanceExtensionProperties (ZString pLayerName, uint * pPropertyCount, VkExtensionProperties * pProperties) @extern("vkEnumerateInstanceExtensionProperties"); +fn VkResult enumerateInstanceLayerProperties (uint * pPropertyCount, VkLayerProperties * pProperties) @extern("vkEnumerateInstanceLayerProperties"); +fn VkResult enumerateInstanceVersion (uint * pApiVersion) @extern("vkEnumerateInstanceVersion"); +fn VkResult enumeratePhysicalDeviceGroups (VkInstance instance, uint * pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties) @extern("vkEnumeratePhysicalDeviceGroups"); +fn VkResult enumeratePhysicalDevices (VkInstance instance, uint * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices) @extern("vkEnumeratePhysicalDevices"); +fn VkResult flushMappedMemoryRanges (VkDevice device, uint memoryRangeCount, VkMappedMemoryRange * pMemoryRanges) @extern("vkFlushMappedMemoryRanges"); +fn void freeCommandBuffers (VkDevice device, VkCommandPool commandPool, uint commandBufferCount, VkCommandBuffer * pCommandBuffers) @extern("vkFreeCommandBuffers"); +fn VkResult freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, uint descriptorSetCount, VkDescriptorSet * pDescriptorSets) @extern("vkFreeDescriptorSets"); +fn void freeMemory (VkDevice device, VkDeviceMemory memory, VkAllocationCallbacks * pAllocator) @extern("vkFreeMemory"); +fn void getBufferMemoryRequirements (VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements) @extern("vkGetBufferMemoryRequirements"); +fn void getBufferMemoryRequirements2 (VkDevice device, VkBufferMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements) @extern("vkGetBufferMemoryRequirements2"); +fn void getDescriptorSetLayoutSupport (VkDevice device, VkDescriptorSetLayoutCreateInfo * pCreateInfo, VkDescriptorSetLayoutSupport * pSupport) @extern("vkGetDescriptorSetLayoutSupport"); +fn void getDeviceGroupPeerMemoryFeatures (VkDevice device, uint heapIndex, uint localDeviceIndex, uint remoteDeviceIndex, VkPeerMemoryFeatureFlags * pPeerMemoryFeatures) @extern("vkGetDeviceGroupPeerMemoryFeatures"); +fn void getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes) @extern("vkGetDeviceMemoryCommitment"); +fn PFN_vkVoidFunction getDeviceProcAddr (VkDevice device, ZString pName) @extern("vkGetDeviceProcAddr"); +fn void getDeviceQueue (VkDevice device, uint queueFamilyIndex, uint queueIndex, VkQueue * pQueue) @extern("vkGetDeviceQueue"); +fn void getDeviceQueue2 (VkDevice device, VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue) @extern("vkGetDeviceQueue2"); +fn VkResult getEventStatus (VkDevice device, VkEvent event) @extern("vkGetEventStatus"); +fn VkResult getFenceStatus (VkDevice device, VkFence fence) @extern("vkGetFenceStatus"); +fn void getImageMemoryRequirements (VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements) @extern("vkGetImageMemoryRequirements"); +fn void getImageMemoryRequirements2 (VkDevice device, VkImageMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements) @extern("vkGetImageMemoryRequirements2"); +fn void getImageSparseMemoryRequirements (VkDevice device, VkImage image, uint * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements * pSparseMemoryRequirements) @extern("vkGetImageSparseMemoryRequirements"); +fn void getImageSparseMemoryRequirements2 (VkDevice device, VkImageSparseMemoryRequirementsInfo2 * pInfo, uint * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements) @extern("vkGetImageSparseMemoryRequirements2"); +fn void getImageSubresourceLayout (VkDevice device, VkImage image, VkImageSubresource * pSubresource, VkSubresourceLayout * pLayout) @extern("vkGetImageSubresourceLayout"); +fn PFN_vkVoidFunction getInstanceProcAddr (VkInstance instance, ZString pName) @extern("vkGetInstanceProcAddr"); +fn void getPhysicalDeviceExternalBufferProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VkExternalBufferProperties * pExternalBufferProperties) @extern("vkGetPhysicalDeviceExternalBufferProperties"); +fn void getPhysicalDeviceExternalFenceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VkExternalFenceProperties * pExternalFenceProperties) @extern("vkGetPhysicalDeviceExternalFenceProperties"); +fn void getPhysicalDeviceExternalSemaphoreProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VkExternalSemaphoreProperties * pExternalSemaphoreProperties) @extern("vkGetPhysicalDeviceExternalSemaphoreProperties"); +fn void getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures) @extern("vkGetPhysicalDeviceFeatures"); +fn void getPhysicalDeviceFeatures2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures) @extern("vkGetPhysicalDeviceFeatures2"); +fn void getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties) @extern("vkGetPhysicalDeviceFormatProperties"); +fn void getPhysicalDeviceFormatProperties2 (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 * pFormatProperties) @extern("vkGetPhysicalDeviceFormatProperties2"); +fn VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties * pImageFormatProperties) @extern("vkGetPhysicalDeviceImageFormatProperties"); +fn VkResult getPhysicalDeviceImageFormatProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VkImageFormatProperties2 * pImageFormatProperties) @extern("vkGetPhysicalDeviceImageFormatProperties2"); +fn void getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties) @extern("vkGetPhysicalDeviceMemoryProperties"); +fn void getPhysicalDeviceMemoryProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 * pMemoryProperties) @extern("vkGetPhysicalDeviceMemoryProperties2"); +fn void getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties) @extern("vkGetPhysicalDeviceProperties"); +fn void getPhysicalDeviceProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties) @extern("vkGetPhysicalDeviceProperties2"); +fn void getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice physicalDevice, uint * pQueueFamilyPropertyCount, VkQueueFamilyProperties * pQueueFamilyProperties) @extern("vkGetPhysicalDeviceQueueFamilyProperties"); +fn void getPhysicalDeviceQueueFamilyProperties2 (VkPhysicalDevice physicalDevice, uint * pQueueFamilyPropertyCount, VkQueueFamilyProperties2 * pQueueFamilyProperties) @extern("vkGetPhysicalDeviceQueueFamilyProperties2"); +fn void getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint * pPropertyCount, VkSparseImageFormatProperties * pProperties) @extern("vkGetPhysicalDeviceSparseImageFormatProperties"); +fn void getPhysicalDeviceSparseImageFormatProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint * pPropertyCount, VkSparseImageFormatProperties2 * pProperties) @extern("vkGetPhysicalDeviceSparseImageFormatProperties2"); +fn VkResult getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, usz * pDataSize, void * pData) @extern("vkGetPipelineCacheData"); +fn VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, uint firstQuery, uint queryCount, usz dataSize, void * pData, VkDeviceSize stride, VkQueryResultFlags flags) @extern("vkGetQueryPoolResults"); +fn void getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity) @extern("vkGetRenderAreaGranularity"); +fn VkResult invalidateMappedMemoryRanges (VkDevice device, uint memoryRangeCount, VkMappedMemoryRange * pMemoryRanges) @extern("vkInvalidateMappedMemoryRanges"); +fn VkResult mapMemory (VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData) @extern("vkMapMemory"); +fn VkResult mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, uint srcCacheCount, VkPipelineCache * pSrcCaches) @extern("vkMergePipelineCaches"); +fn VkResult queueBindSparse (VkQueue queue, uint bindInfoCount, VkBindSparseInfo * pBindInfo, VkFence fence) @extern("vkQueueBindSparse"); +fn VkResult queueSubmit (VkQueue queue, uint submitCount, VkSubmitInfo * pSubmits, VkFence fence) @extern("vkQueueSubmit"); +fn VkResult queueWaitIdle (VkQueue queue) @extern("vkQueueWaitIdle"); +fn VkResult resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) @extern("vkResetCommandBuffer"); +fn VkResult resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) @extern("vkResetCommandPool"); +fn VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) @extern("vkResetDescriptorPool"); +fn VkResult resetEvent (VkDevice device, VkEvent event) @extern("vkResetEvent"); +fn VkResult resetFences (VkDevice device, uint fenceCount, VkFence * pFences) @extern("vkResetFences"); +fn VkResult setEvent (VkDevice device, VkEvent event) @extern("vkSetEvent"); +fn void trimCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) @extern("vkTrimCommandPool"); +fn void unmapMemory (VkDevice device, VkDeviceMemory memory) @extern("vkUnmapMemory"); +fn void updateDescriptorSetWithTemplate (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, void * pData) @extern("vkUpdateDescriptorSetWithTemplate"); +fn void updateDescriptorSets (VkDevice device, uint descriptorWriteCount, VkWriteDescriptorSet * pDescriptorWrites, uint descriptorCopyCount, VkCopyDescriptorSet * pDescriptorCopies) @extern("vkUpdateDescriptorSets"); +fn VkResult waitForFences (VkDevice device, uint fenceCount, VkFence * pFences, VkBool32 waitAll, ulong timeout) @extern("vkWaitForFences"); diff --git a/libraries/vulkan.c3l/vk12.c3i b/libraries/vulkan.c3l/vk12.c3i new file mode 100644 index 0000000..9181053 --- /dev/null +++ b/libraries/vulkan.c3l/vk12.c3i @@ -0,0 +1,4012 @@ +module vulkan::vk @if(internal::vk_version() == vk::VK_API_VERSION_1_2); +import vulkan; + +//Adapted from the glad loader generator at: https://gen.glad.sh. +//License/ Information: +/** + * Loader generated by glad 2.0.7 on Sat Sep 14 23:10:30 2024 + * + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + * + * Generator: C/C++ + * Specification: vk + * Extensions: 0 + * + * APIs: + * - vulkan=1.2 + * + * Options: + * - ALIAS = False + * - DEBUG = False + * - HEADER_ONLY = False + * - LOADER = False + * - MX = False + * - ON_DEMAND = False + * + * Commandline: + * --api='vulkan=1.2' --extensions='' c + * + * Online: + * http://glad.sh/#api=vulkan%3D1.2&extensions=&generator=c&options= + * + */ + +const VK_ATTACHMENT_UNUSED = (~0U); +const VK_FALSE = 0; +const VK_LOD_CLAMP_NONE = 1000.0F; +const VK_LUID_SIZE = 8; +const VK_MAX_DESCRIPTION_SIZE = 256; +const VK_MAX_DEVICE_GROUP_SIZE = 32; +const VK_MAX_DRIVER_INFO_SIZE = 256; +const VK_MAX_DRIVER_NAME_SIZE = 256; +const VK_MAX_EXTENSION_NAME_SIZE = 256; +const VK_MAX_MEMORY_HEAPS = 16; +const VK_MAX_MEMORY_TYPES = 32; +const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256; +const VK_QUEUE_FAMILY_EXTERNAL = (~1U); +const VK_QUEUE_FAMILY_IGNORED = (~0U); +const VK_REMAINING_ARRAY_LAYERS = (~0U); +const VK_REMAINING_MIP_LEVELS = (~0U); +const VK_SUBPASS_EXTERNAL = (~0U); +const VK_TRUE = 1; +const VK_UUID_SIZE = 16; +const ulong VK_WHOLE_SIZE = (~0); + +distinct VkInstance = uptr; +distinct VkPhysicalDevice = uptr; +distinct VkDevice = uptr; +distinct VkQueue = uptr; +distinct VkCommandBuffer = uptr; +distinct VkDeviceMemory = uptr; +distinct VkCommandPool = uptr; +distinct VkBuffer = uptr; +distinct VkBufferView = uptr; +distinct VkImage = uptr; +distinct VkImageView = uptr; +distinct VkShaderModule = uptr; +distinct VkPipeline = uptr; +distinct VkPipelineLayout = uptr; +distinct VkSampler = uptr; +distinct VkDescriptorSet = uptr; +distinct VkDescriptorSetLayout = uptr; +distinct VkDescriptorPool = uptr; +distinct VkFence = uptr; +distinct VkSemaphore = uptr; +distinct VkEvent = uptr; +distinct VkQueryPool = uptr; +distinct VkFramebuffer = uptr; +distinct VkRenderPass = uptr; +distinct VkPipelineCache = uptr; +distinct VkDescriptorUpdateTemplate = uptr; +distinct VkSamplerYcbcrConversion = uptr; +enum VkAttachmentLoadOp : int (int value) +{ + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkAttachmentStoreOp : int (int value) +{ + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkBlendFactor : int (int value) +{ + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkBlendOp : int (int value) +{ + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkBorderColor : int (int value) +{ + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkFramebufferCreateFlagBits : int (int value) +{ + VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 1, + VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineCacheHeaderVersion : int (int value) +{ + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorSetLayoutCreateFlagBits : int (int value) +{ + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 2, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDeviceQueueCreateFlagBits : int (int value) +{ + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 1, + VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkBufferCreateFlagBits : int (int value) +{ + 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, + VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkBufferUsageFlagBits : int (int value) +{ + 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, + VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkColorComponentFlagBits : int (int value) +{ + VK_COLOR_COMPONENT_R_BIT = 1, + VK_COLOR_COMPONENT_G_BIT = 2, + VK_COLOR_COMPONENT_B_BIT = 4, + VK_COLOR_COMPONENT_A_BIT = 8, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkComponentSwizzle : int (int value) +{ + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandPoolCreateFlagBits : int (int value) +{ + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 4, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandPoolResetFlagBits : int (int value) +{ + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferResetFlagBits : int (int value) +{ + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferLevel : int (int value) +{ + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferUsageFlagBits : int (int value) +{ + 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, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCompareOp : int (int value) +{ + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkCullModeFlagBits : int (int value) +{ + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 1, + VK_CULL_MODE_BACK_BIT = 2, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorType : int (int value) +{ + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkDynamicState : int (int value) +{ + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} +enum VkFenceCreateFlagBits : int (int value) +{ + VK_FENCE_CREATE_SIGNALED_BIT = 1, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPolygonMode : int (int value) +{ + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkFormat : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkFormatFeatureFlagBits : int (int value) +{ + 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, + VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkFrontFace : int (int value) +{ + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageAspectFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageCreateFlagBits : int (int value) +{ + 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, + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageLayout : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageTiling : int (int value) +{ + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageType : int (int value) +{ + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageUsageFlagBits : int (int value) +{ + 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, + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageViewType : int (int value) +{ + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSharingMode : int (int value) +{ + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkIndexType : int (int value) +{ + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkLogicOp : int (int value) +{ + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryHeapFlagBits : int (int value) +{ + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 2, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkAccessFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryPropertyFlagBits : int (int value) +{ + 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, + VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPhysicalDeviceType : int (int value) +{ + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineBindPoint : int (int value) +{ + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineCreateFlagBits : int (int value) +{ + 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 = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPrimitiveTopology : int (int value) +{ + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryControlFlagBits : int (int value) +{ + VK_QUERY_CONTROL_PRECISE_BIT = 1, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryPipelineStatisticFlagBits : int (int value) +{ + 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, + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryResultFlagBits : int (int value) +{ + 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, + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryType : int (int value) +{ + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueueFlagBits : int (int value) +{ + 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, + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSubpassContents : int (int value) +{ + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} +enum VkResult : int (int value) +{ + 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_RESULT_MAX_ENUM = 0x7FFFFFFF +} +enum VkShaderStageFlagBits : int (int value) +{ + 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, + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSparseMemoryBindFlagBits : int (int value) +{ + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkStencilFaceFlagBits : int (int value) +{ + VK_STENCIL_FACE_FRONT_BIT = 1, + VK_STENCIL_FACE_BACK_BIT = 2, + VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, + VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkStencilOp : int (int value) +{ + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkStructureType : int (int value) +{ + 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 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + 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 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkSystemAllocationScope : int (int value) +{ + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkInternalAllocationType : int (int value) +{ + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerAddressMode : int (int value) +{ + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkFilter : int (int value) +{ + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerMipmapMode : int (int value) +{ + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkVertexInputRate : int (int value) +{ + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineStageFlagBits : int (int value) +{ + 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_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSparseImageFormatFlagBits : int (int value) +{ + 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, + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSampleCountFlagBits : int (int value) +{ + 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, + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkAttachmentDescriptionFlagBits : int (int value) +{ + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorPoolCreateFlagBits : int (int value) +{ + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 2, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDependencyFlagBits : int (int value) +{ + VK_DEPENDENCY_BY_REGION_BIT = 1, + VK_DEPENDENCY_DEVICE_GROUP_BIT = 4, + VK_DEPENDENCY_VIEW_LOCAL_BIT = 2, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkObjectType : int (int value) +{ + 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_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorUpdateTemplateType : int (int value) +{ + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPointClippingBehavior : int (int value) +{ + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkResolveModeFlagBits : int (int value) +{ + 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, + VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorBindingFlagBits : int (int value) +{ + 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, + VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSemaphoreType : int (int value) +{ + VK_SEMAPHORE_TYPE_BINARY = 0, + VK_SEMAPHORE_TYPE_TIMELINE = 1, + VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSemaphoreWaitFlagBits : int (int value) +{ + VK_SEMAPHORE_WAIT_ANY_BIT = 1, + VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalMemoryHandleTypeFlagBits : int (int value) +{ + 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, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalMemoryFeatureFlagBits : int (int value) +{ + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalSemaphoreHandleTypeFlagBits : int (int value) +{ + 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 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 16, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalSemaphoreFeatureFlagBits : int (int value) +{ + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSemaphoreImportFlagBits : int (int value) +{ + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalFenceHandleTypeFlagBits : int (int value) +{ + 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, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalFenceFeatureFlagBits : int (int value) +{ + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkFenceImportFlagBits : int (int value) +{ + VK_FENCE_IMPORT_TEMPORARY_BIT = 1, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPeerMemoryFeatureFlagBits : int (int value) +{ + 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, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryAllocateFlagBits : int (int value) +{ + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 2, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 4, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSubgroupFeatureFlagBits : int (int value) +{ + 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, + VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkTessellationDomainOrigin : int (int value) +{ + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerYcbcrModelConversion : int (int value) +{ + 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, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerYcbcrRange : int (int value) +{ + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF +} +enum VkChromaLocation : int (int value) +{ + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, + VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerReductionMode : int (int value) +{ + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, + VK_SAMPLER_REDUCTION_MODE_MIN = 1, + VK_SAMPLER_REDUCTION_MODE_MAX = 2, + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkShaderFloatControlsIndependence : int (int value) +{ + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF +} +enum VkVendorId : int (int value) +{ + VK_VENDOR_ID_KHRONOS = 0x10000, + 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, + VK_VENDOR_ID_MOBILEYE = 0x10007, + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} +enum VkDriverId : int (int value) +{ + 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, + VK_DRIVER_ID_MESA_DOZEN = 23, + VK_DRIVER_ID_MESA_NVK = 24, + VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, + VK_DRIVER_ID_MESA_HONEYKRISP = 26, + VK_DRIVER_ID_RESERVED_27 = 27, + VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF +} +def PFN_vkInternalAllocationNotification = fn void ( + void* pUserData, + usz size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); +def PFN_vkInternalFreeNotification = fn void ( + void* pUserData, + usz size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); +def PFN_vkReallocationFunction = fn void* ( + void* pUserData, + void* pOriginal, + usz size, + usz alignment, + VkSystemAllocationScope allocationScope); +def PFN_vkAllocationFunction = fn void* ( + void* pUserData, + usz size, + usz alignment, + VkSystemAllocationScope allocationScope); +def PFN_vkFreeFunction = fn void ( + void* pUserData, + void* pMemory); +def PFN_vkVoidFunction = fn void (); +struct VkBaseOutStructure +{ + VkStructureType sType; + VkBaseOutStructure * pNext; +} + +struct VkBaseInStructure +{ + VkStructureType sType; + VkBaseInStructure * pNext; +} + +struct VkOffset2D +{ + int x; + int y; +} + +struct VkOffset3D +{ + int x; + int y; + int z; +} + +struct VkExtent2D +{ + uint width; + uint height; +} + +struct VkExtent3D +{ + uint width; + uint height; + uint depth; +} + +struct VkViewport +{ + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} + +struct VkRect2D +{ + VkOffset2D offset; + VkExtent2D extent; +} + +struct VkClearRect +{ + VkRect2D rect; + uint baseArrayLayer; + uint layerCount; +} + +struct VkComponentMapping +{ + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} + +struct VkExtensionProperties +{ + char[ VK_MAX_EXTENSION_NAME_SIZE ] extensionName; + uint specVersion; +} + +struct VkLayerProperties +{ + char[ VK_MAX_EXTENSION_NAME_SIZE ] layerName; + uint specVersion; + uint implementationVersion; + char[ VK_MAX_DESCRIPTION_SIZE ] description; +} + +struct VkApplicationInfo +{ + VkStructureType sType; + void * pNext; + char * pApplicationName; + uint applicationVersion; + char * pEngineName; + uint engineVersion; + uint apiVersion; +} + +struct VkAllocationCallbacks +{ + void * pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} + +struct VkDescriptorImageInfo +{ + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} + +struct VkCopyDescriptorSet +{ + VkStructureType sType; + void * pNext; + VkDescriptorSet srcSet; + uint srcBinding; + uint srcArrayElement; + VkDescriptorSet dstSet; + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; +} + +struct VkDescriptorPoolSize +{ + VkDescriptorType type; + uint descriptorCount; +} + +struct VkDescriptorSetAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorPool descriptorPool; + uint descriptorSetCount; + VkDescriptorSetLayout * pSetLayouts; +} + +struct VkSpecializationMapEntry +{ + uint constantID; + uint offset; + usz size; +} + +struct VkSpecializationInfo +{ + uint mapEntryCount; + VkSpecializationMapEntry * pMapEntries; + usz dataSize; + void * pData; +} + +struct VkVertexInputBindingDescription +{ + uint binding; + uint stride; + VkVertexInputRate inputRate; +} + +struct VkVertexInputAttributeDescription +{ + uint location; + uint binding; + VkFormat format; + uint offset; +} + +struct VkStencilOpState +{ + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint compareMask; + uint writeMask; + uint reference; +} + +struct VkPipelineCacheHeaderVersionOne +{ + uint headerSize; + VkPipelineCacheHeaderVersion headerVersion; + uint vendorID; + uint deviceID; + char[ VK_UUID_SIZE ] pipelineCacheUUID; +} + +struct VkCommandBufferAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint commandBufferCount; +} + +union VkClearColorValue { + float[4] float32; + int[4] int32; + uint[4] uint32; +} + +struct VkClearDepthStencilValue +{ + float depth; + uint stencil; +} + +union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} + +struct VkAttachmentReference +{ + uint attachment; + VkImageLayout layout; +} + +struct VkDrawIndirectCommand +{ + uint vertexCount; + uint instanceCount; + uint firstVertex; + uint firstInstance; +} + +struct VkDrawIndexedIndirectCommand +{ + uint indexCount; + uint instanceCount; + uint firstIndex; + int vertexOffset; + uint firstInstance; +} + +struct VkDispatchIndirectCommand +{ + uint x; + uint y; + uint z; +} + +struct VkConformanceVersion +{ + char major; + char minor; + char subminor; + char patch; +} + +struct VkPhysicalDeviceDriverProperties +{ + VkStructureType sType; + void * pNext; + VkDriverId driverID; + char[ VK_MAX_DRIVER_NAME_SIZE ] driverName; + char[ VK_MAX_DRIVER_INFO_SIZE ] driverInfo; + VkConformanceVersion conformanceVersion; +} + +struct VkPhysicalDeviceExternalImageFormatInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} + +struct VkPhysicalDeviceExternalSemaphoreInfo +{ + VkStructureType sType; + void * pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} + +struct VkPhysicalDeviceExternalFenceInfo +{ + VkStructureType sType; + void * pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} + +struct VkPhysicalDeviceMultiviewProperties +{ + VkStructureType sType; + void * pNext; + uint maxMultiviewViewCount; + uint maxMultiviewInstanceIndex; +} + +struct VkRenderPassMultiviewCreateInfo +{ + VkStructureType sType; + void * pNext; + uint subpassCount; + uint * pViewMasks; + uint dependencyCount; + int * pViewOffsets; + uint correlationMaskCount; + uint * pCorrelationMasks; +} + +struct VkBindBufferMemoryDeviceGroupInfo +{ + VkStructureType sType; + void * pNext; + uint deviceIndexCount; + uint * pDeviceIndices; +} + +struct VkBindImageMemoryDeviceGroupInfo +{ + VkStructureType sType; + void * pNext; + uint deviceIndexCount; + uint * pDeviceIndices; + uint splitInstanceBindRegionCount; + VkRect2D * pSplitInstanceBindRegions; +} + +struct VkDeviceGroupRenderPassBeginInfo +{ + VkStructureType sType; + void * pNext; + uint deviceMask; + uint deviceRenderAreaCount; + VkRect2D * pDeviceRenderAreas; +} + +struct VkDeviceGroupCommandBufferBeginInfo +{ + VkStructureType sType; + void * pNext; + uint deviceMask; +} + +struct VkDeviceGroupSubmitInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + uint * pWaitSemaphoreDeviceIndices; + uint commandBufferCount; + uint * pCommandBufferDeviceMasks; + uint signalSemaphoreCount; + uint * pSignalSemaphoreDeviceIndices; +} + +struct VkDeviceGroupBindSparseInfo +{ + VkStructureType sType; + void * pNext; + uint resourceDeviceIndex; + uint memoryDeviceIndex; +} + +struct VkDeviceGroupDeviceCreateInfo +{ + VkStructureType sType; + void * pNext; + uint physicalDeviceCount; + VkPhysicalDevice * pPhysicalDevices; +} + +struct VkDescriptorUpdateTemplateEntry +{ + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; + VkDescriptorType descriptorType; + usz offset; + usz stride; +} + +struct VkBufferMemoryRequirementsInfo2 +{ + VkStructureType sType; + void * pNext; + VkBuffer buffer; +} + +struct VkImageMemoryRequirementsInfo2 +{ + VkStructureType sType; + void * pNext; + VkImage image; +} + +struct VkImageSparseMemoryRequirementsInfo2 +{ + VkStructureType sType; + void * pNext; + VkImage image; +} + +struct VkPhysicalDevicePointClippingProperties +{ + VkStructureType sType; + void * pNext; + VkPointClippingBehavior pointClippingBehavior; +} + +struct VkMemoryDedicatedAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkImage image; + VkBuffer buffer; +} + +struct VkPipelineTessellationDomainOriginStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkTessellationDomainOrigin domainOrigin; +} + +struct VkSamplerYcbcrConversionInfo +{ + VkStructureType sType; + void * pNext; + VkSamplerYcbcrConversion conversion; +} + +struct VkBindImagePlaneMemoryInfo +{ + VkStructureType sType; + void * pNext; + VkImageAspectFlagBits planeAspect; +} + +struct VkImagePlaneMemoryRequirementsInfo +{ + VkStructureType sType; + void * pNext; + VkImageAspectFlagBits planeAspect; +} + +struct VkSamplerYcbcrConversionImageFormatProperties +{ + VkStructureType sType; + void * pNext; + uint combinedImageSamplerDescriptorCount; +} + +struct VkSamplerReductionModeCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSamplerReductionMode reductionMode; +} + +struct VkImageFormatListCreateInfo +{ + VkStructureType sType; + void * pNext; + uint viewFormatCount; + VkFormat * pViewFormats; +} + +struct VkDescriptorSetVariableDescriptorCountAllocateInfo +{ + VkStructureType sType; + void * pNext; + uint descriptorSetCount; + uint * pDescriptorCounts; +} + +struct VkDescriptorSetVariableDescriptorCountLayoutSupport +{ + VkStructureType sType; + void * pNext; + uint maxVariableDescriptorCount; +} + +struct VkSubpassBeginInfo +{ + VkStructureType sType; + void * pNext; + VkSubpassContents contents; +} + +struct VkSubpassEndInfo +{ + VkStructureType sType; + void * pNext; +} + +struct VkPhysicalDeviceTimelineSemaphoreProperties +{ + VkStructureType sType; + void * pNext; + ulong maxTimelineSemaphoreValueDifference; +} + +struct VkSemaphoreTypeCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphoreType semaphoreType; + ulong initialValue; +} + +struct VkTimelineSemaphoreSubmitInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreValueCount; + ulong * pWaitSemaphoreValues; + uint signalSemaphoreValueCount; + ulong * pSignalSemaphoreValues; +} + +struct VkSemaphoreSignalInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphore semaphore; + ulong value; +} + +struct VkBufferDeviceAddressInfo +{ + VkStructureType sType; + void * pNext; + VkBuffer buffer; +} + +struct VkBufferOpaqueCaptureAddressCreateInfo +{ + VkStructureType sType; + void * pNext; + ulong opaqueCaptureAddress; +} + +struct VkRenderPassAttachmentBeginInfo +{ + VkStructureType sType; + void * pNext; + uint attachmentCount; + VkImageView * pAttachments; +} + +struct VkAttachmentReferenceStencilLayout +{ + VkStructureType sType; + void * pNext; + VkImageLayout stencilLayout; +} + +struct VkAttachmentDescriptionStencilLayout +{ + VkStructureType sType; + void * pNext; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; +} + +struct VkMemoryOpaqueCaptureAddressAllocateInfo +{ + VkStructureType sType; + void * pNext; + ulong opaqueCaptureAddress; +} + +struct VkDeviceMemoryOpaqueCaptureAddressInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceMemory memory; +} + +def VkSampleMask = uint; +def VkBool32 = uint; +def VkFlags = uint; +def VkDeviceSize = ulong; +def VkDeviceAddress = ulong; +def VkFramebufferCreateFlags = VkFlags; +def VkQueryPoolCreateFlags = VkFlags; +def VkRenderPassCreateFlags = VkFlags; +def VkSamplerCreateFlags = VkFlags; +def VkPipelineLayoutCreateFlags = VkFlags; +def VkPipelineCacheCreateFlags = VkFlags; +def VkPipelineDepthStencilStateCreateFlags = VkFlags; +def VkPipelineDynamicStateCreateFlags = VkFlags; +def VkPipelineColorBlendStateCreateFlags = VkFlags; +def VkPipelineMultisampleStateCreateFlags = VkFlags; +def VkPipelineRasterizationStateCreateFlags = VkFlags; +def VkPipelineViewportStateCreateFlags = VkFlags; +def VkPipelineTessellationStateCreateFlags = VkFlags; +def VkPipelineInputAssemblyStateCreateFlags = VkFlags; +def VkPipelineVertexInputStateCreateFlags = VkFlags; +def VkPipelineShaderStageCreateFlags = VkFlags; +def VkDescriptorSetLayoutCreateFlags = VkFlags; +def VkBufferViewCreateFlags = VkFlags; +def VkInstanceCreateFlags = VkFlags; +def VkDeviceCreateFlags = VkFlags; +def VkDeviceQueueCreateFlags = VkFlags; +def VkQueueFlags = VkFlags; +def VkMemoryPropertyFlags = VkFlags; +def VkMemoryHeapFlags = VkFlags; +def VkAccessFlags = VkFlags; +def VkBufferUsageFlags = VkFlags; +def VkBufferCreateFlags = VkFlags; +def VkShaderStageFlags = VkFlags; +def VkImageUsageFlags = VkFlags; +def VkImageCreateFlags = VkFlags; +def VkImageViewCreateFlags = VkFlags; +def VkPipelineCreateFlags = VkFlags; +def VkColorComponentFlags = VkFlags; +def VkFenceCreateFlags = VkFlags; +def VkSemaphoreCreateFlags = VkFlags; +def VkFormatFeatureFlags = VkFlags; +def VkQueryControlFlags = VkFlags; +def VkQueryResultFlags = VkFlags; +def VkShaderModuleCreateFlags = VkFlags; +def VkEventCreateFlags = VkFlags; +def VkCommandPoolCreateFlags = VkFlags; +def VkCommandPoolResetFlags = VkFlags; +def VkCommandBufferResetFlags = VkFlags; +def VkCommandBufferUsageFlags = VkFlags; +def VkQueryPipelineStatisticFlags = VkFlags; +def VkMemoryMapFlags = VkFlags; +def VkImageAspectFlags = VkFlags; +def VkSparseMemoryBindFlags = VkFlags; +def VkSparseImageFormatFlags = VkFlags; +def VkSubpassDescriptionFlags = VkFlags; +def VkPipelineStageFlags = VkFlags; +def VkSampleCountFlags = VkFlags; +def VkAttachmentDescriptionFlags = VkFlags; +def VkStencilFaceFlags = VkFlags; +def VkCullModeFlags = VkFlags; +def VkDescriptorPoolCreateFlags = VkFlags; +def VkDescriptorPoolResetFlags = VkFlags; +def VkDependencyFlags = VkFlags; +def VkSubgroupFeatureFlags = VkFlags; +def VkDescriptorUpdateTemplateCreateFlags = VkFlags; +def VkSemaphoreWaitFlags = VkFlags; +def VkPeerMemoryFeatureFlags = VkFlags; +def VkMemoryAllocateFlags = VkFlags; +def VkCommandPoolTrimFlags = VkFlags; +def VkExternalMemoryHandleTypeFlags = VkFlags; +def VkExternalMemoryFeatureFlags = VkFlags; +def VkExternalSemaphoreHandleTypeFlags = VkFlags; +def VkExternalSemaphoreFeatureFlags = VkFlags; +def VkSemaphoreImportFlags = VkFlags; +def VkExternalFenceHandleTypeFlags = VkFlags; +def VkExternalFenceFeatureFlags = VkFlags; +def VkFenceImportFlags = VkFlags; +def VkDescriptorBindingFlags = VkFlags; +def VkResolveModeFlags = VkFlags; +struct VkDeviceQueueCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceQueueCreateFlags flags; + uint queueFamilyIndex; + uint queueCount; + float * pQueuePriorities; +} + +struct VkInstanceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkInstanceCreateFlags flags; + VkApplicationInfo * pApplicationInfo; + uint enabledLayerCount; + ZString ppEnabledLayerNames; + uint enabledExtensionCount; + ZString ppEnabledExtensionNames; +} + +struct VkQueueFamilyProperties +{ + VkQueueFlags queueFlags; + uint queueCount; + uint timestampValidBits; + VkExtent3D minImageTransferGranularity; +} + +struct VkMemoryAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceSize allocationSize; + uint memoryTypeIndex; +} + +struct VkMemoryRequirements +{ + VkDeviceSize size; + VkDeviceSize alignment; + uint memoryTypeBits; +} + +struct VkSparseImageFormatProperties +{ + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} + +struct VkSparseImageMemoryRequirements +{ + VkSparseImageFormatProperties formatProperties; + uint imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} + +struct VkMemoryType +{ + VkMemoryPropertyFlags propertyFlags; + uint heapIndex; +} + +struct VkMemoryHeap +{ + VkDeviceSize size; + VkMemoryHeapFlags flags; +} + +struct VkMappedMemoryRange +{ + VkStructureType sType; + void * pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} + +struct VkFormatProperties +{ + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} + +struct VkImageFormatProperties +{ + VkExtent3D maxExtent; + uint maxMipLevels; + uint maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} + +struct VkDescriptorBufferInfo +{ + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} + +struct VkWriteDescriptorSet +{ + VkStructureType sType; + void * pNext; + VkDescriptorSet dstSet; + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; + VkDescriptorType descriptorType; + VkDescriptorImageInfo * pImageInfo; + VkDescriptorBufferInfo * pBufferInfo; + VkBufferView * pTexelBufferView; +} + +struct VkBufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint queueFamilyIndexCount; + uint * pQueueFamilyIndices; +} + +struct VkBufferViewCreateInfo +{ + VkStructureType sType; + void * pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} + +struct VkImageSubresource +{ + VkImageAspectFlags aspectMask; + uint mipLevel; + uint arrayLayer; +} + +struct VkImageSubresourceLayers +{ + VkImageAspectFlags aspectMask; + uint mipLevel; + uint baseArrayLayer; + uint layerCount; +} + +struct VkImageSubresourceRange +{ + VkImageAspectFlags aspectMask; + uint baseMipLevel; + uint levelCount; + uint baseArrayLayer; + uint layerCount; +} + +struct VkMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} + +struct VkBufferMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint srcQueueFamilyIndex; + uint dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} + +struct VkImageMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint srcQueueFamilyIndex; + uint dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} + +struct VkImageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint mipLevels; + uint arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint queueFamilyIndexCount; + uint * pQueueFamilyIndices; + VkImageLayout initialLayout; +} + +struct VkSubresourceLayout +{ + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} + +struct VkImageViewCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} + +struct VkBufferCopy +{ + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} + +struct VkSparseMemoryBind +{ + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} + +struct VkSparseImageMemoryBind +{ + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} + +struct VkSparseBufferMemoryBindInfo +{ + VkBuffer buffer; + uint bindCount; + VkSparseMemoryBind * pBinds; +} + +struct VkSparseImageOpaqueMemoryBindInfo +{ + VkImage image; + uint bindCount; + VkSparseMemoryBind * pBinds; +} + +struct VkSparseImageMemoryBindInfo +{ + VkImage image; + uint bindCount; + VkSparseImageMemoryBind * pBinds; +} + +struct VkBindSparseInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + VkSemaphore * pWaitSemaphores; + uint bufferBindCount; + VkSparseBufferMemoryBindInfo * pBufferBinds; + uint imageOpaqueBindCount; + VkSparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds; + uint imageBindCount; + VkSparseImageMemoryBindInfo * pImageBinds; + uint signalSemaphoreCount; + VkSemaphore * pSignalSemaphores; +} + +struct VkImageCopy +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} + +struct VkImageBlit +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D[2] srcOffsets; + VkImageSubresourceLayers dstSubresource; + VkOffset3D[2] dstOffsets; +} + +struct VkBufferImageCopy +{ + VkDeviceSize bufferOffset; + uint bufferRowLength; + uint bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} + +struct VkImageResolve +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} + +struct VkShaderModuleCreateInfo +{ + VkStructureType sType; + void * pNext; + VkShaderModuleCreateFlags flags; + usz codeSize; + uint * pCode; +} + +struct VkDescriptorSetLayoutBinding +{ + uint binding; + VkDescriptorType descriptorType; + uint descriptorCount; + VkShaderStageFlags stageFlags; + VkSampler * pImmutableSamplers; +} + +struct VkDescriptorSetLayoutCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint bindingCount; + VkDescriptorSetLayoutBinding * pBindings; +} + +struct VkDescriptorPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorPoolCreateFlags flags; + uint maxSets; + uint poolSizeCount; + VkDescriptorPoolSize * pPoolSizes; +} + +struct VkPipelineShaderStageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule vkmodule; + char * pName; + VkSpecializationInfo * pSpecializationInfo; +} + +struct VkComputePipelineCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int basePipelineIndex; +} + +struct VkPipelineVertexInputStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint vertexBindingDescriptionCount; + VkVertexInputBindingDescription * pVertexBindingDescriptions; + uint vertexAttributeDescriptionCount; + VkVertexInputAttributeDescription * pVertexAttributeDescriptions; +} + +struct VkPipelineInputAssemblyStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} + +struct VkPipelineTessellationStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineTessellationStateCreateFlags flags; + uint patchControlPoints; +} + +struct VkPipelineViewportStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineViewportStateCreateFlags flags; + uint viewportCount; + VkViewport * pViewports; + uint scissorCount; + VkRect2D * pScissors; +} + +struct VkPipelineRasterizationStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} + +struct VkPipelineMultisampleStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + VkSampleMask * pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} + +struct VkPipelineColorBlendAttachmentState +{ + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} + +struct VkPipelineColorBlendStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint attachmentCount; + VkPipelineColorBlendAttachmentState * pAttachments; + float[4] blendConstants; +} + +struct VkPipelineDynamicStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineDynamicStateCreateFlags flags; + uint dynamicStateCount; + VkDynamicState * pDynamicStates; +} + +struct VkPipelineDepthStencilStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} + +struct VkGraphicsPipelineCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCreateFlags flags; + uint stageCount; + VkPipelineShaderStageCreateInfo * pStages; + VkPipelineVertexInputStateCreateInfo * pVertexInputState; + VkPipelineInputAssemblyStateCreateInfo * pInputAssemblyState; + VkPipelineTessellationStateCreateInfo * pTessellationState; + VkPipelineViewportStateCreateInfo * pViewportState; + VkPipelineRasterizationStateCreateInfo * pRasterizationState; + VkPipelineMultisampleStateCreateInfo * pMultisampleState; + VkPipelineDepthStencilStateCreateInfo * pDepthStencilState; + VkPipelineColorBlendStateCreateInfo * pColorBlendState; + VkPipelineDynamicStateCreateInfo * pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint subpass; + VkPipeline basePipelineHandle; + int basePipelineIndex; +} + +struct VkPipelineCacheCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCacheCreateFlags flags; + usz initialDataSize; + void * pInitialData; +} + +struct VkPushConstantRange +{ + VkShaderStageFlags stageFlags; + uint offset; + uint size; +} + +struct VkPipelineLayoutCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineLayoutCreateFlags flags; + uint setLayoutCount; + VkDescriptorSetLayout * pSetLayouts; + uint pushConstantRangeCount; + VkPushConstantRange * pPushConstantRanges; +} + +struct VkSamplerCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} + +struct VkCommandPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkCommandPoolCreateFlags flags; + uint queueFamilyIndex; +} + +struct VkCommandBufferInheritanceInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPass renderPass; + uint subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} + +struct VkCommandBufferBeginInfo +{ + VkStructureType sType; + void * pNext; + VkCommandBufferUsageFlags flags; + VkCommandBufferInheritanceInfo * pInheritanceInfo; +} + +struct VkRenderPassBeginInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint clearValueCount; + VkClearValue * pClearValues; +} + +struct VkClearAttachment +{ + VkImageAspectFlags aspectMask; + uint colorAttachment; + VkClearValue clearValue; +} + +struct VkAttachmentDescription +{ + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} + +struct VkSubpassDescription +{ + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint inputAttachmentCount; + VkAttachmentReference * pInputAttachments; + uint colorAttachmentCount; + VkAttachmentReference * pColorAttachments; + VkAttachmentReference * pResolveAttachments; + VkAttachmentReference * pDepthStencilAttachment; + uint preserveAttachmentCount; + uint * pPreserveAttachments; +} + +struct VkSubpassDependency +{ + uint srcSubpass; + uint dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} + +struct VkRenderPassCreateInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPassCreateFlags flags; + uint attachmentCount; + VkAttachmentDescription * pAttachments; + uint subpassCount; + VkSubpassDescription * pSubpasses; + uint dependencyCount; + VkSubpassDependency * pDependencies; +} + +struct VkEventCreateInfo +{ + VkStructureType sType; + void * pNext; + VkEventCreateFlags flags; +} + +struct VkFenceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFenceCreateFlags flags; +} + +struct VkPhysicalDeviceFeatures +{ + VkBool32 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; +} + +struct VkPhysicalDeviceSparseProperties +{ + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} + +struct VkPhysicalDeviceLimits +{ + uint maxImageDimension1D; + uint maxImageDimension2D; + uint maxImageDimension3D; + uint maxImageDimensionCube; + uint maxImageArrayLayers; + uint maxTexelBufferElements; + uint maxUniformBufferRange; + uint maxStorageBufferRange; + uint maxPushConstantsSize; + uint maxMemoryAllocationCount; + uint maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint maxBoundDescriptorSets; + uint maxPerStageDescriptorSamplers; + uint maxPerStageDescriptorUniformBuffers; + uint maxPerStageDescriptorStorageBuffers; + uint maxPerStageDescriptorSampledImages; + uint maxPerStageDescriptorStorageImages; + uint maxPerStageDescriptorInputAttachments; + uint maxPerStageResources; + uint maxDescriptorSetSamplers; + uint maxDescriptorSetUniformBuffers; + uint maxDescriptorSetUniformBuffersDynamic; + uint maxDescriptorSetStorageBuffers; + uint maxDescriptorSetStorageBuffersDynamic; + uint maxDescriptorSetSampledImages; + uint maxDescriptorSetStorageImages; + uint maxDescriptorSetInputAttachments; + uint maxVertexInputAttributes; + uint maxVertexInputBindings; + uint maxVertexInputAttributeOffset; + uint maxVertexInputBindingStride; + uint maxVertexOutputComponents; + uint maxTessellationGenerationLevel; + uint maxTessellationPatchSize; + uint maxTessellationControlPerVertexInputComponents; + uint maxTessellationControlPerVertexOutputComponents; + uint maxTessellationControlPerPatchOutputComponents; + uint maxTessellationControlTotalOutputComponents; + uint maxTessellationEvaluationInputComponents; + uint maxTessellationEvaluationOutputComponents; + uint maxGeometryShaderInvocations; + uint maxGeometryInputComponents; + uint maxGeometryOutputComponents; + uint maxGeometryOutputVertices; + uint maxGeometryTotalOutputComponents; + uint maxFragmentInputComponents; + uint maxFragmentOutputAttachments; + uint maxFragmentDualSrcAttachments; + uint maxFragmentCombinedOutputResources; + uint maxComputeSharedMemorySize; + uint[3] maxComputeWorkGroupCount; + uint maxComputeWorkGroupInvocations; + uint[3] maxComputeWorkGroupSize; + uint subPixelPrecisionBits; + uint subTexelPrecisionBits; + uint mipmapPrecisionBits; + uint maxDrawIndexedIndexValue; + uint maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint maxViewports; + uint[2] maxViewportDimensions; + float[2] viewportBoundsRange; + uint viewportSubPixelBits; + usz minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int minTexelOffset; + uint maxTexelOffset; + int minTexelGatherOffset; + uint maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint subPixelInterpolationOffsetBits; + uint maxFramebufferWidth; + uint maxFramebufferHeight; + uint maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint maxClipDistances; + uint maxCullDistances; + uint maxCombinedClipAndCullDistances; + uint discreteQueuePriorities; + float[2] pointSizeRange; + float[2] lineWidthRange; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} + +struct VkSemaphoreCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphoreCreateFlags flags; +} + +struct VkQueryPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} + +struct VkFramebufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint attachmentCount; + VkImageView * pAttachments; + uint width; + uint height; + uint layers; +} + +struct VkSubmitInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + VkSemaphore * pWaitSemaphores; + VkPipelineStageFlags * pWaitDstStageMask; + uint commandBufferCount; + VkCommandBuffer * pCommandBuffers; + uint signalSemaphoreCount; + VkSemaphore * pSignalSemaphores; +} + +struct VkPhysicalDeviceFeatures2 +{ + VkStructureType sType; + void * pNext; + VkPhysicalDeviceFeatures features; +} + +struct VkFormatProperties2 +{ + VkStructureType sType; + void * pNext; + VkFormatProperties formatProperties; +} + +struct VkImageFormatProperties2 +{ + VkStructureType sType; + void * pNext; + VkImageFormatProperties imageFormatProperties; +} + +struct VkPhysicalDeviceImageFormatInfo2 +{ + VkStructureType sType; + void * pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} + +struct VkQueueFamilyProperties2 +{ + VkStructureType sType; + void * pNext; + VkQueueFamilyProperties queueFamilyProperties; +} + +struct VkSparseImageFormatProperties2 +{ + VkStructureType sType; + void * pNext; + VkSparseImageFormatProperties properties; +} + +struct VkPhysicalDeviceSparseImageFormatInfo2 +{ + VkStructureType sType; + void * pNext; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; +} + +struct VkPhysicalDeviceVariablePointersFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} + +def VkPhysicalDeviceVariablePointerFeatures = VkPhysicalDeviceVariablePointersFeatures; + +struct VkExternalMemoryProperties +{ + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} + +struct VkExternalImageFormatProperties +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryProperties externalMemoryProperties; +} + +struct VkPhysicalDeviceExternalBufferInfo +{ + VkStructureType sType; + void * pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} + +struct VkExternalBufferProperties +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryProperties externalMemoryProperties; +} + +struct VkPhysicalDeviceIDProperties +{ + VkStructureType sType; + void * pNext; + char[ VK_UUID_SIZE ] deviceUUID; + char[ VK_UUID_SIZE ] driverUUID; + char[ VK_LUID_SIZE ] deviceLUID; + uint deviceNodeMask; + VkBool32 deviceLUIDValid; +} + +struct VkExternalMemoryImageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} + +struct VkExternalMemoryBufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} + +struct VkExportMemoryAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} + +struct VkExternalSemaphoreProperties +{ + VkStructureType sType; + void * pNext; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} + +struct VkExportSemaphoreCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} + +struct VkExternalFenceProperties +{ + VkStructureType sType; + void * pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} + +struct VkExportFenceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} + +struct VkPhysicalDeviceMultiviewFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} + +struct VkPhysicalDeviceGroupProperties +{ + VkStructureType sType; + void * pNext; + uint physicalDeviceCount; + VkPhysicalDevice[ VK_MAX_DEVICE_GROUP_SIZE ] physicalDevices; + VkBool32 subsetAllocation; +} + +struct VkMemoryAllocateFlagsInfo +{ + VkStructureType sType; + void * pNext; + VkMemoryAllocateFlags flags; + uint deviceMask; +} + +struct VkBindBufferMemoryInfo +{ + VkStructureType sType; + void * pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} + +struct VkBindImageMemoryInfo +{ + VkStructureType sType; + void * pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} + +struct VkDescriptorUpdateTemplateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorUpdateTemplateCreateFlags flags; + uint descriptorUpdateEntryCount; + VkDescriptorUpdateTemplateEntry * pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint set; +} + +struct VkInputAttachmentAspectReference +{ + uint subpass; + uint inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} + +struct VkRenderPassInputAttachmentAspectCreateInfo +{ + VkStructureType sType; + void * pNext; + uint aspectReferenceCount; + VkInputAttachmentAspectReference * pAspectReferences; +} + +struct VkPhysicalDevice16BitStorageFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} + +struct VkPhysicalDeviceSubgroupProperties +{ + VkStructureType sType; + void * pNext; + uint subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} + +struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderSubgroupExtendedTypes; +} + +struct VkMemoryRequirements2 +{ + VkStructureType sType; + void * pNext; + VkMemoryRequirements memoryRequirements; +} + +struct VkSparseImageMemoryRequirements2 +{ + VkStructureType sType; + void * pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} + +struct VkMemoryDedicatedRequirements +{ + VkStructureType sType; + void * pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} + +struct VkImageViewUsageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageUsageFlags usage; +} + +struct VkSamplerYcbcrConversionCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} + +struct VkPhysicalDeviceSamplerYcbcrConversionFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 samplerYcbcrConversion; +} + +struct VkProtectedSubmitInfo +{ + VkStructureType sType; + void * pNext; + VkBool32 protectedSubmit; +} + +struct VkPhysicalDeviceProtectedMemoryFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 protectedMemory; +} + +struct VkPhysicalDeviceProtectedMemoryProperties +{ + VkStructureType sType; + void * pNext; + VkBool32 protectedNoFault; +} + +struct VkDeviceQueueInfo2 +{ + VkStructureType sType; + void * pNext; + VkDeviceQueueCreateFlags flags; + uint queueFamilyIndex; + uint queueIndex; +} + +struct VkPhysicalDeviceSamplerFilterMinmaxProperties +{ + VkStructureType sType; + void * pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} + +struct VkPhysicalDeviceMaintenance3Properties +{ + VkStructureType sType; + void * pNext; + uint maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} + +struct VkDescriptorSetLayoutSupport +{ + VkStructureType sType; + void * pNext; + VkBool32 supported; +} + +struct VkPhysicalDeviceShaderDrawParametersFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderDrawParameters; +} + +def VkPhysicalDeviceShaderDrawParameterFeatures = VkPhysicalDeviceShaderDrawParametersFeatures; + +struct VkPhysicalDeviceShaderFloat16Int8Features +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; +} + +struct VkPhysicalDeviceFloatControlsProperties +{ + VkStructureType sType; + void * pNext; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 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; +} + +struct VkPhysicalDeviceHostQueryResetFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 hostQueryReset; +} + +struct VkPhysicalDeviceDescriptorIndexingFeatures +{ + VkStructureType sType; + void * pNext; + 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; +} + +struct VkPhysicalDeviceDescriptorIndexingProperties +{ + VkStructureType sType; + void * pNext; + uint maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint maxPerStageDescriptorUpdateAfterBindSamplers; + uint maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint maxPerStageDescriptorUpdateAfterBindSampledImages; + uint maxPerStageDescriptorUpdateAfterBindStorageImages; + uint maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint maxPerStageUpdateAfterBindResources; + uint maxDescriptorSetUpdateAfterBindSamplers; + uint maxDescriptorSetUpdateAfterBindUniformBuffers; + uint maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint maxDescriptorSetUpdateAfterBindStorageBuffers; + uint maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint maxDescriptorSetUpdateAfterBindSampledImages; + uint maxDescriptorSetUpdateAfterBindStorageImages; + uint maxDescriptorSetUpdateAfterBindInputAttachments; +} + +struct VkDescriptorSetLayoutBindingFlagsCreateInfo +{ + VkStructureType sType; + void * pNext; + uint bindingCount; + VkDescriptorBindingFlags * pBindingFlags; +} + +struct VkAttachmentDescription2 +{ + VkStructureType sType; + void * pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} + +struct VkAttachmentReference2 +{ + VkStructureType sType; + void * pNext; + uint attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} + +struct VkSubpassDescription2 +{ + VkStructureType sType; + void * pNext; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint viewMask; + uint inputAttachmentCount; + VkAttachmentReference2 * pInputAttachments; + uint colorAttachmentCount; + VkAttachmentReference2 * pColorAttachments; + VkAttachmentReference2 * pResolveAttachments; + VkAttachmentReference2 * pDepthStencilAttachment; + uint preserveAttachmentCount; + uint * pPreserveAttachments; +} + +struct VkSubpassDependency2 +{ + VkStructureType sType; + void * pNext; + uint srcSubpass; + uint dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int viewOffset; +} + +struct VkRenderPassCreateInfo2 +{ + VkStructureType sType; + void * pNext; + VkRenderPassCreateFlags flags; + uint attachmentCount; + VkAttachmentDescription2 * pAttachments; + uint subpassCount; + VkSubpassDescription2 * pSubpasses; + uint dependencyCount; + VkSubpassDependency2 * pDependencies; + uint correlatedViewMaskCount; + uint * pCorrelatedViewMasks; +} + +struct VkPhysicalDeviceTimelineSemaphoreFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 timelineSemaphore; +} + +struct VkSemaphoreWaitInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphoreWaitFlags flags; + uint semaphoreCount; + VkSemaphore * pSemaphores; + ulong * pValues; +} + +struct VkPhysicalDevice8BitStorageFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} + +struct VkPhysicalDeviceVulkanMemoryModelFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; +} + +struct VkPhysicalDeviceShaderAtomicInt64Features +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} + +struct VkPhysicalDeviceDepthStencilResolveProperties +{ + VkStructureType sType; + void * pNext; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; +} + +struct VkSubpassDescriptionDepthStencilResolve +{ + VkStructureType sType; + void * pNext; + VkResolveModeFlagBits depthResolveMode; + VkResolveModeFlagBits stencilResolveMode; + VkAttachmentReference2 * pDepthStencilResolveAttachment; +} + +struct VkImageStencilUsageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageUsageFlags stencilUsage; +} + +struct VkPhysicalDeviceScalarBlockLayoutFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 scalarBlockLayout; +} + +struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 uniformBufferStandardLayout; +} + +struct VkPhysicalDeviceBufferDeviceAddressFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} + +struct VkPhysicalDeviceImagelessFramebufferFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 imagelessFramebuffer; +} + +struct VkFramebufferAttachmentImageInfo +{ + VkStructureType sType; + void * pNext; + VkImageCreateFlags flags; + VkImageUsageFlags usage; + uint width; + uint height; + uint layerCount; + uint viewFormatCount; + VkFormat * pViewFormats; +} + +struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 separateDepthStencilLayouts; +} + +struct VkPhysicalDeviceVulkan11Features +{ + VkStructureType sType; + void * pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; + VkBool32 protectedMemory; + VkBool32 samplerYcbcrConversion; + VkBool32 shaderDrawParameters; +} + +struct VkPhysicalDeviceVulkan11Properties +{ + VkStructureType sType; + void * pNext; + char[ VK_UUID_SIZE ] deviceUUID; + char[ VK_UUID_SIZE ] driverUUID; + char[ VK_LUID_SIZE ] deviceLUID; + uint deviceNodeMask; + VkBool32 deviceLUIDValid; + uint subgroupSize; + VkShaderStageFlags subgroupSupportedStages; + VkSubgroupFeatureFlags subgroupSupportedOperations; + VkBool32 subgroupQuadOperationsInAllStages; + VkPointClippingBehavior pointClippingBehavior; + uint maxMultiviewViewCount; + uint maxMultiviewInstanceIndex; + VkBool32 protectedNoFault; + uint maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} + +struct VkPhysicalDeviceVulkan12Features +{ + VkStructureType sType; + void * pNext; + VkBool32 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; +} + +struct VkPhysicalDeviceVulkan12Properties +{ + VkStructureType sType; + void * pNext; + VkDriverId driverID; + char[ VK_MAX_DRIVER_NAME_SIZE ] driverName; + char[ VK_MAX_DRIVER_INFO_SIZE ] driverInfo; + VkConformanceVersion conformanceVersion; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 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; + uint maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint maxPerStageDescriptorUpdateAfterBindSamplers; + uint maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint maxPerStageDescriptorUpdateAfterBindSampledImages; + uint maxPerStageDescriptorUpdateAfterBindStorageImages; + uint maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint maxPerStageUpdateAfterBindResources; + uint maxDescriptorSetUpdateAfterBindSamplers; + uint maxDescriptorSetUpdateAfterBindUniformBuffers; + uint maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint maxDescriptorSetUpdateAfterBindStorageBuffers; + uint maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint maxDescriptorSetUpdateAfterBindSampledImages; + uint maxDescriptorSetUpdateAfterBindStorageImages; + uint maxDescriptorSetUpdateAfterBindInputAttachments; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; + ulong maxTimelineSemaphoreValueDifference; + VkSampleCountFlags framebufferIntegerColorSampleCounts; +} + +struct VkPhysicalDeviceProperties +{ + uint apiVersion; + uint driverVersion; + uint vendorID; + uint deviceID; + VkPhysicalDeviceType deviceType; + char[ VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ] deviceName; + char[ VK_UUID_SIZE ] pipelineCacheUUID; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} + +struct VkDeviceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceCreateFlags flags; + uint queueCreateInfoCount; + VkDeviceQueueCreateInfo * pQueueCreateInfos; + uint enabledLayerCount; + ZString ppEnabledLayerNames; + uint enabledExtensionCount; + ZString ppEnabledExtensionNames; + VkPhysicalDeviceFeatures * pEnabledFeatures; +} + +struct VkPhysicalDeviceMemoryProperties +{ + uint memoryTypeCount; + VkMemoryType[ VK_MAX_MEMORY_TYPES ] memoryTypes; + uint memoryHeapCount; + VkMemoryHeap[ VK_MAX_MEMORY_HEAPS ] memoryHeaps; +} + +struct VkPhysicalDeviceProperties2 +{ + VkStructureType sType; + void * pNext; + VkPhysicalDeviceProperties properties; +} + +struct VkPhysicalDeviceMemoryProperties2 +{ + VkStructureType sType; + void * pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} + +struct VkFramebufferAttachmentsCreateInfo +{ + VkStructureType sType; + void * pNext; + uint attachmentImageInfoCount; + VkFramebufferAttachmentImageInfo * pAttachmentImageInfos; +} + + + +const VK_VERSION_1_0 = 1; +const VK_VERSION_1_1 = 1; +const VK_VERSION_1_2 = 1; + + + +fn VkResult allocateCommandBuffers (VkDevice device, VkCommandBufferAllocateInfo * pAllocateInfo, VkCommandBuffer * pCommandBuffers) @extern("vkAllocateCommandBuffers"); +fn VkResult allocateDescriptorSets (VkDevice device, VkDescriptorSetAllocateInfo * pAllocateInfo, VkDescriptorSet * pDescriptorSets) @extern("vkAllocateDescriptorSets"); +fn VkResult allocateMemory (VkDevice device, VkMemoryAllocateInfo * pAllocateInfo, VkAllocationCallbacks * pAllocator, VkDeviceMemory * pMemory) @extern("vkAllocateMemory"); +fn VkResult beginCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo * pBeginInfo) @extern("vkBeginCommandBuffer"); +fn VkResult bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) @extern("vkBindBufferMemory"); +fn VkResult bindBufferMemory2 (VkDevice device, uint bindInfoCount, VkBindBufferMemoryInfo * pBindInfos) @extern("vkBindBufferMemory2"); +fn VkResult bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) @extern("vkBindImageMemory"); +fn VkResult bindImageMemory2 (VkDevice device, uint bindInfoCount, VkBindImageMemoryInfo * pBindInfos) @extern("vkBindImageMemory2"); +fn void cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query, VkQueryControlFlags flags) @extern("vkCmdBeginQuery"); +fn void cmdBeginRenderPass (VkCommandBuffer commandBuffer, VkRenderPassBeginInfo * pRenderPassBegin, VkSubpassContents contents) @extern("vkCmdBeginRenderPass"); +fn void cmdBeginRenderPass2 (VkCommandBuffer commandBuffer, VkRenderPassBeginInfo * pRenderPassBegin, VkSubpassBeginInfo * pSubpassBeginInfo) @extern("vkCmdBeginRenderPass2"); +fn void cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint firstSet, uint descriptorSetCount, VkDescriptorSet * pDescriptorSets, uint dynamicOffsetCount, uint * pDynamicOffsets) @extern("vkCmdBindDescriptorSets"); +fn void cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) @extern("vkCmdBindIndexBuffer"); +fn void cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) @extern("vkCmdBindPipeline"); +fn void cmdBindVertexBuffers (VkCommandBuffer commandBuffer, uint firstBinding, uint bindingCount, VkBuffer * pBuffers, VkDeviceSize * pOffsets) @extern("vkCmdBindVertexBuffers"); +fn void cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageBlit * pRegions, VkFilter filter) @extern("vkCmdBlitImage"); +fn void cmdClearAttachments (VkCommandBuffer commandBuffer, uint attachmentCount, VkClearAttachment * pAttachments, uint rectCount, VkClearRect * pRects) @extern("vkCmdClearAttachments"); +fn void cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue * pColor, uint rangeCount, VkImageSubresourceRange * pRanges) @extern("vkCmdClearColorImage"); +fn void cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue * pDepthStencil, uint rangeCount, VkImageSubresourceRange * pRanges) @extern("vkCmdClearDepthStencilImage"); +fn void cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint regionCount, VkBufferCopy * pRegions) @extern("vkCmdCopyBuffer"); +fn void cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkBufferImageCopy * pRegions) @extern("vkCmdCopyBufferToImage"); +fn void cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageCopy * pRegions) @extern("vkCmdCopyImage"); +fn void cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint regionCount, VkBufferImageCopy * pRegions) @extern("vkCmdCopyImageToBuffer"); +fn void cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) @extern("vkCmdCopyQueryPoolResults"); +fn void cmdDispatch (VkCommandBuffer commandBuffer, uint groupCountX, uint groupCountY, uint groupCountZ) @extern("vkCmdDispatch"); +fn void cmdDispatchBase (VkCommandBuffer commandBuffer, uint baseGroupX, uint baseGroupY, uint baseGroupZ, uint groupCountX, uint groupCountY, uint groupCountZ) @extern("vkCmdDispatchBase"); +fn void cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) @extern("vkCmdDispatchIndirect"); +fn void cmdDraw (VkCommandBuffer commandBuffer, uint vertexCount, uint instanceCount, uint firstVertex, uint firstInstance) @extern("vkCmdDraw"); +fn void cmdDrawIndexed (VkCommandBuffer commandBuffer, uint indexCount, uint instanceCount, uint firstIndex, int vertexOffset, uint firstInstance) @extern("vkCmdDrawIndexed"); +fn void cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride) @extern("vkCmdDrawIndexedIndirect"); +fn void cmdDrawIndexedIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint maxDrawCount, uint stride) @extern("vkCmdDrawIndexedIndirectCount"); +fn void cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride) @extern("vkCmdDrawIndirect"); +fn void cmdDrawIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint maxDrawCount, uint stride) @extern("vkCmdDrawIndirectCount"); +fn void cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query) @extern("vkCmdEndQuery"); +fn void cmdEndRenderPass (VkCommandBuffer commandBuffer) @extern("vkCmdEndRenderPass"); +fn void cmdEndRenderPass2 (VkCommandBuffer commandBuffer, VkSubpassEndInfo * pSubpassEndInfo) @extern("vkCmdEndRenderPass2"); +fn void cmdExecuteCommands (VkCommandBuffer commandBuffer, uint commandBufferCount, VkCommandBuffer * pCommandBuffers) @extern("vkCmdExecuteCommands"); +fn void cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint data) @extern("vkCmdFillBuffer"); +fn void cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents) @extern("vkCmdNextSubpass"); +fn void cmdNextSubpass2 (VkCommandBuffer commandBuffer, VkSubpassBeginInfo * pSubpassBeginInfo, VkSubpassEndInfo * pSubpassEndInfo) @extern("vkCmdNextSubpass2"); +fn void cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint memoryBarrierCount, VkMemoryBarrier * pMemoryBarriers, uint bufferMemoryBarrierCount, VkBufferMemoryBarrier * pBufferMemoryBarriers, uint imageMemoryBarrierCount, VkImageMemoryBarrier * pImageMemoryBarriers) @extern("vkCmdPipelineBarrier"); +fn void cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint offset, uint size, void * pValues) @extern("vkCmdPushConstants"); +fn void cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) @extern("vkCmdResetEvent"); +fn void cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount) @extern("vkCmdResetQueryPool"); +fn void cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageResolve * pRegions) @extern("vkCmdResolveImage"); +fn void cmdSetBlendConstants (VkCommandBuffer commandBuffer, float[4] blendConstants) @extern("vkCmdSetBlendConstants"); +fn void cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) @extern("vkCmdSetDepthBias"); +fn void cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) @extern("vkCmdSetDepthBounds"); +fn void cmdSetDeviceMask (VkCommandBuffer commandBuffer, uint deviceMask) @extern("vkCmdSetDeviceMask"); +fn void cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) @extern("vkCmdSetEvent"); +fn void cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth) @extern("vkCmdSetLineWidth"); +fn void cmdSetScissor (VkCommandBuffer commandBuffer, uint firstScissor, uint scissorCount, VkRect2D * pScissors) @extern("vkCmdSetScissor"); +fn void cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint compareMask) @extern("vkCmdSetStencilCompareMask"); +fn void cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint reference) @extern("vkCmdSetStencilReference"); +fn void cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint writeMask) @extern("vkCmdSetStencilWriteMask"); +fn void cmdSetViewport (VkCommandBuffer commandBuffer, uint firstViewport, uint viewportCount, VkViewport * pViewports) @extern("vkCmdSetViewport"); +fn void cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, void * pData) @extern("vkCmdUpdateBuffer"); +fn void cmdWaitEvents (VkCommandBuffer commandBuffer, uint eventCount, VkEvent * pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint memoryBarrierCount, VkMemoryBarrier * pMemoryBarriers, uint bufferMemoryBarrierCount, VkBufferMemoryBarrier * pBufferMemoryBarriers, uint imageMemoryBarrierCount, VkImageMemoryBarrier * pImageMemoryBarriers) @extern("vkCmdWaitEvents"); +fn void cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint query) @extern("vkCmdWriteTimestamp"); +fn VkResult createBuffer (VkDevice device, VkBufferCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkBuffer * pBuffer) @extern("vkCreateBuffer"); +fn VkResult createBufferView (VkDevice device, VkBufferViewCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkBufferView * pView) @extern("vkCreateBufferView"); +fn VkResult createCommandPool (VkDevice device, VkCommandPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkCommandPool * pCommandPool) @extern("vkCreateCommandPool"); +fn VkResult createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkComputePipelineCreateInfo * pCreateInfos, VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines) @extern("vkCreateComputePipelines"); +fn VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorPool * pDescriptorPool) @extern("vkCreateDescriptorPool"); +fn VkResult createDescriptorSetLayout (VkDevice device, VkDescriptorSetLayoutCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorSetLayout * pSetLayout) @extern("vkCreateDescriptorSetLayout"); +fn VkResult createDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate) @extern("vkCreateDescriptorUpdateTemplate"); +fn VkResult createDevice (VkPhysicalDevice physicalDevice, VkDeviceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDevice * pDevice) @extern("vkCreateDevice"); +fn VkResult createEvent (VkDevice device, VkEventCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkEvent * pEvent) @extern("vkCreateEvent"); +fn VkResult createFence (VkDevice device, VkFenceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkFence * pFence) @extern("vkCreateFence"); +fn VkResult createFramebuffer (VkDevice device, VkFramebufferCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkFramebuffer * pFramebuffer) @extern("vkCreateFramebuffer"); +fn VkResult createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkGraphicsPipelineCreateInfo * pCreateInfos, VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines) @extern("vkCreateGraphicsPipelines"); +fn VkResult createImage (VkDevice device, VkImageCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkImage * pImage) @extern("vkCreateImage"); +fn VkResult createImageView (VkDevice device, VkImageViewCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkImageView * pView) @extern("vkCreateImageView"); +fn VkResult createInstance (VkInstanceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkInstance * pInstance) @extern("vkCreateInstance"); +fn VkResult createPipelineCache (VkDevice device, VkPipelineCacheCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkPipelineCache * pPipelineCache) @extern("vkCreatePipelineCache"); +fn VkResult createPipelineLayout (VkDevice device, VkPipelineLayoutCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkPipelineLayout * pPipelineLayout) @extern("vkCreatePipelineLayout"); +fn VkResult createQueryPool (VkDevice device, VkQueryPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkQueryPool * pQueryPool) @extern("vkCreateQueryPool"); +fn VkResult createRenderPass (VkDevice device, VkRenderPassCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass) @extern("vkCreateRenderPass"); +fn VkResult createRenderPass2 (VkDevice device, VkRenderPassCreateInfo2 * pCreateInfo, VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass) @extern("vkCreateRenderPass2"); +fn VkResult createSampler (VkDevice device, VkSamplerCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSampler * pSampler) @extern("vkCreateSampler"); +fn VkResult createSamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversionCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSamplerYcbcrConversion * pYcbcrConversion) @extern("vkCreateSamplerYcbcrConversion"); +fn VkResult createSemaphore (VkDevice device, VkSemaphoreCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSemaphore * pSemaphore) @extern("vkCreateSemaphore"); +fn VkResult createShaderModule (VkDevice device, VkShaderModuleCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkShaderModule * pShaderModule) @extern("vkCreateShaderModule"); +fn void destroyBuffer (VkDevice device, VkBuffer buffer, VkAllocationCallbacks * pAllocator) @extern("vkDestroyBuffer"); +fn void destroyBufferView (VkDevice device, VkBufferView bufferView, VkAllocationCallbacks * pAllocator) @extern("vkDestroyBufferView"); +fn void destroyCommandPool (VkDevice device, VkCommandPool commandPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyCommandPool"); +fn void destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorPool"); +fn void destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorSetLayout"); +fn void destroyDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorUpdateTemplate"); +fn void destroyDevice (VkDevice device, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDevice"); +fn void destroyEvent (VkDevice device, VkEvent event, VkAllocationCallbacks * pAllocator) @extern("vkDestroyEvent"); +fn void destroyFence (VkDevice device, VkFence fence, VkAllocationCallbacks * pAllocator) @extern("vkDestroyFence"); +fn void destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, VkAllocationCallbacks * pAllocator) @extern("vkDestroyFramebuffer"); +fn void destroyImage (VkDevice device, VkImage image, VkAllocationCallbacks * pAllocator) @extern("vkDestroyImage"); +fn void destroyImageView (VkDevice device, VkImageView imageView, VkAllocationCallbacks * pAllocator) @extern("vkDestroyImageView"); +fn void destroyInstance (VkInstance instance, VkAllocationCallbacks * pAllocator) @extern("vkDestroyInstance"); +fn void destroyPipeline (VkDevice device, VkPipeline pipeline, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipeline"); +fn void destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipelineCache"); +fn void destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipelineLayout"); +fn void destroyQueryPool (VkDevice device, VkQueryPool queryPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyQueryPool"); +fn void destroyRenderPass (VkDevice device, VkRenderPass renderPass, VkAllocationCallbacks * pAllocator) @extern("vkDestroyRenderPass"); +fn void destroySampler (VkDevice device, VkSampler sampler, VkAllocationCallbacks * pAllocator) @extern("vkDestroySampler"); +fn void destroySamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, VkAllocationCallbacks * pAllocator) @extern("vkDestroySamplerYcbcrConversion"); +fn void destroySemaphore (VkDevice device, VkSemaphore semaphore, VkAllocationCallbacks * pAllocator) @extern("vkDestroySemaphore"); +fn void destroyShaderModule (VkDevice device, VkShaderModule shaderModule, VkAllocationCallbacks * pAllocator) @extern("vkDestroyShaderModule"); +fn VkResult deviceWaitIdle (VkDevice device) @extern("vkDeviceWaitIdle"); +fn VkResult endCommandBuffer (VkCommandBuffer commandBuffer) @extern("vkEndCommandBuffer"); +fn VkResult enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, ZString pLayerName, uint * pPropertyCount, VkExtensionProperties * pProperties) @extern("vkEnumerateDeviceExtensionProperties"); +fn VkResult enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, uint * pPropertyCount, VkLayerProperties * pProperties) @extern("vkEnumerateDeviceLayerProperties"); +fn VkResult enumerateInstanceExtensionProperties (ZString pLayerName, uint * pPropertyCount, VkExtensionProperties * pProperties) @extern("vkEnumerateInstanceExtensionProperties"); +fn VkResult enumerateInstanceLayerProperties (uint * pPropertyCount, VkLayerProperties * pProperties) @extern("vkEnumerateInstanceLayerProperties"); +fn VkResult enumerateInstanceVersion (uint * pApiVersion) @extern("vkEnumerateInstanceVersion"); +fn VkResult enumeratePhysicalDeviceGroups (VkInstance instance, uint * pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties) @extern("vkEnumeratePhysicalDeviceGroups"); +fn VkResult enumeratePhysicalDevices (VkInstance instance, uint * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices) @extern("vkEnumeratePhysicalDevices"); +fn VkResult flushMappedMemoryRanges (VkDevice device, uint memoryRangeCount, VkMappedMemoryRange * pMemoryRanges) @extern("vkFlushMappedMemoryRanges"); +fn void freeCommandBuffers (VkDevice device, VkCommandPool commandPool, uint commandBufferCount, VkCommandBuffer * pCommandBuffers) @extern("vkFreeCommandBuffers"); +fn VkResult freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, uint descriptorSetCount, VkDescriptorSet * pDescriptorSets) @extern("vkFreeDescriptorSets"); +fn void freeMemory (VkDevice device, VkDeviceMemory memory, VkAllocationCallbacks * pAllocator) @extern("vkFreeMemory"); +fn VkDeviceAddress getBufferDeviceAddress (VkDevice device, VkBufferDeviceAddressInfo * pInfo) @extern("vkGetBufferDeviceAddress"); +fn void getBufferMemoryRequirements (VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements) @extern("vkGetBufferMemoryRequirements"); +fn void getBufferMemoryRequirements2 (VkDevice device, VkBufferMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements) @extern("vkGetBufferMemoryRequirements2"); +fn ulong getBufferOpaqueCaptureAddress (VkDevice device, VkBufferDeviceAddressInfo * pInfo) @extern("vkGetBufferOpaqueCaptureAddress"); +fn void getDescriptorSetLayoutSupport (VkDevice device, VkDescriptorSetLayoutCreateInfo * pCreateInfo, VkDescriptorSetLayoutSupport * pSupport) @extern("vkGetDescriptorSetLayoutSupport"); +fn void getDeviceGroupPeerMemoryFeatures (VkDevice device, uint heapIndex, uint localDeviceIndex, uint remoteDeviceIndex, VkPeerMemoryFeatureFlags * pPeerMemoryFeatures) @extern("vkGetDeviceGroupPeerMemoryFeatures"); +fn void getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes) @extern("vkGetDeviceMemoryCommitment"); +fn ulong getDeviceMemoryOpaqueCaptureAddress (VkDevice device, VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo) @extern("vkGetDeviceMemoryOpaqueCaptureAddress"); +fn PFN_vkVoidFunction getDeviceProcAddr (VkDevice device, ZString pName) @extern("vkGetDeviceProcAddr"); +fn void getDeviceQueue (VkDevice device, uint queueFamilyIndex, uint queueIndex, VkQueue * pQueue) @extern("vkGetDeviceQueue"); +fn void getDeviceQueue2 (VkDevice device, VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue) @extern("vkGetDeviceQueue2"); +fn VkResult getEventStatus (VkDevice device, VkEvent event) @extern("vkGetEventStatus"); +fn VkResult getFenceStatus (VkDevice device, VkFence fence) @extern("vkGetFenceStatus"); +fn void getImageMemoryRequirements (VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements) @extern("vkGetImageMemoryRequirements"); +fn void getImageMemoryRequirements2 (VkDevice device, VkImageMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements) @extern("vkGetImageMemoryRequirements2"); +fn void getImageSparseMemoryRequirements (VkDevice device, VkImage image, uint * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements * pSparseMemoryRequirements) @extern("vkGetImageSparseMemoryRequirements"); +fn void getImageSparseMemoryRequirements2 (VkDevice device, VkImageSparseMemoryRequirementsInfo2 * pInfo, uint * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements) @extern("vkGetImageSparseMemoryRequirements2"); +fn void getImageSubresourceLayout (VkDevice device, VkImage image, VkImageSubresource * pSubresource, VkSubresourceLayout * pLayout) @extern("vkGetImageSubresourceLayout"); +fn PFN_vkVoidFunction getInstanceProcAddr (VkInstance instance, ZString pName) @extern("vkGetInstanceProcAddr"); +fn void getPhysicalDeviceExternalBufferProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VkExternalBufferProperties * pExternalBufferProperties) @extern("vkGetPhysicalDeviceExternalBufferProperties"); +fn void getPhysicalDeviceExternalFenceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VkExternalFenceProperties * pExternalFenceProperties) @extern("vkGetPhysicalDeviceExternalFenceProperties"); +fn void getPhysicalDeviceExternalSemaphoreProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VkExternalSemaphoreProperties * pExternalSemaphoreProperties) @extern("vkGetPhysicalDeviceExternalSemaphoreProperties"); +fn void getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures) @extern("vkGetPhysicalDeviceFeatures"); +fn void getPhysicalDeviceFeatures2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures) @extern("vkGetPhysicalDeviceFeatures2"); +fn void getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties) @extern("vkGetPhysicalDeviceFormatProperties"); +fn void getPhysicalDeviceFormatProperties2 (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 * pFormatProperties) @extern("vkGetPhysicalDeviceFormatProperties2"); +fn VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties * pImageFormatProperties) @extern("vkGetPhysicalDeviceImageFormatProperties"); +fn VkResult getPhysicalDeviceImageFormatProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VkImageFormatProperties2 * pImageFormatProperties) @extern("vkGetPhysicalDeviceImageFormatProperties2"); +fn void getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties) @extern("vkGetPhysicalDeviceMemoryProperties"); +fn void getPhysicalDeviceMemoryProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 * pMemoryProperties) @extern("vkGetPhysicalDeviceMemoryProperties2"); +fn void getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties) @extern("vkGetPhysicalDeviceProperties"); +fn void getPhysicalDeviceProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties) @extern("vkGetPhysicalDeviceProperties2"); +fn void getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice physicalDevice, uint * pQueueFamilyPropertyCount, VkQueueFamilyProperties * pQueueFamilyProperties) @extern("vkGetPhysicalDeviceQueueFamilyProperties"); +fn void getPhysicalDeviceQueueFamilyProperties2 (VkPhysicalDevice physicalDevice, uint * pQueueFamilyPropertyCount, VkQueueFamilyProperties2 * pQueueFamilyProperties) @extern("vkGetPhysicalDeviceQueueFamilyProperties2"); +fn void getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint * pPropertyCount, VkSparseImageFormatProperties * pProperties) @extern("vkGetPhysicalDeviceSparseImageFormatProperties"); +fn void getPhysicalDeviceSparseImageFormatProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint * pPropertyCount, VkSparseImageFormatProperties2 * pProperties) @extern("vkGetPhysicalDeviceSparseImageFormatProperties2"); +fn VkResult getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, usz * pDataSize, void * pData) @extern("vkGetPipelineCacheData"); +fn VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, uint firstQuery, uint queryCount, usz dataSize, void * pData, VkDeviceSize stride, VkQueryResultFlags flags) @extern("vkGetQueryPoolResults"); +fn void getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity) @extern("vkGetRenderAreaGranularity"); +fn VkResult getSemaphoreCounterValue (VkDevice device, VkSemaphore semaphore, ulong * pValue) @extern("vkGetSemaphoreCounterValue"); +fn VkResult invalidateMappedMemoryRanges (VkDevice device, uint memoryRangeCount, VkMappedMemoryRange * pMemoryRanges) @extern("vkInvalidateMappedMemoryRanges"); +fn VkResult mapMemory (VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData) @extern("vkMapMemory"); +fn VkResult mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, uint srcCacheCount, VkPipelineCache * pSrcCaches) @extern("vkMergePipelineCaches"); +fn VkResult queueBindSparse (VkQueue queue, uint bindInfoCount, VkBindSparseInfo * pBindInfo, VkFence fence) @extern("vkQueueBindSparse"); +fn VkResult queueSubmit (VkQueue queue, uint submitCount, VkSubmitInfo * pSubmits, VkFence fence) @extern("vkQueueSubmit"); +fn VkResult queueWaitIdle (VkQueue queue) @extern("vkQueueWaitIdle"); +fn VkResult resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) @extern("vkResetCommandBuffer"); +fn VkResult resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) @extern("vkResetCommandPool"); +fn VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) @extern("vkResetDescriptorPool"); +fn VkResult resetEvent (VkDevice device, VkEvent event) @extern("vkResetEvent"); +fn VkResult resetFences (VkDevice device, uint fenceCount, VkFence * pFences) @extern("vkResetFences"); +fn void resetQueryPool (VkDevice device, VkQueryPool queryPool, uint firstQuery, uint queryCount) @extern("vkResetQueryPool"); +fn VkResult setEvent (VkDevice device, VkEvent event) @extern("vkSetEvent"); +fn VkResult signalSemaphore (VkDevice device, VkSemaphoreSignalInfo * pSignalInfo) @extern("vkSignalSemaphore"); +fn void trimCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) @extern("vkTrimCommandPool"); +fn void unmapMemory (VkDevice device, VkDeviceMemory memory) @extern("vkUnmapMemory"); +fn void updateDescriptorSetWithTemplate (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, void * pData) @extern("vkUpdateDescriptorSetWithTemplate"); +fn void updateDescriptorSets (VkDevice device, uint descriptorWriteCount, VkWriteDescriptorSet * pDescriptorWrites, uint descriptorCopyCount, VkCopyDescriptorSet * pDescriptorCopies) @extern("vkUpdateDescriptorSets"); +fn VkResult waitForFences (VkDevice device, uint fenceCount, VkFence * pFences, VkBool32 waitAll, ulong timeout) @extern("vkWaitForFences"); +fn VkResult waitSemaphores (VkDevice device, VkSemaphoreWaitInfo * pWaitInfo, ulong timeout) @extern("vkWaitSemaphores"); diff --git a/libraries/vulkan.c3l/vk13.c3i b/libraries/vulkan.c3l/vk13.c3i new file mode 100644 index 0000000..1d62afc --- /dev/null +++ b/libraries/vulkan.c3l/vk13.c3i @@ -0,0 +1,4951 @@ +module vulkan::vk @if(internal::vk_version() == VK_API_VERSION_1_3); +import vulkan; + +//Adapted from the glad loader generator at: https://gen.glad.sh. +//License/ Information: +/** + * Loader generated by glad 2.0.7 on Sat Sep 14 23:11:47 2024 + * + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + * + * Generator: C/C++ + * Specification: vk + * Extensions: 0 + * + * APIs: + * - vulkan=1.3 + * + * Options: + * - ALIAS = False + * - DEBUG = False + * - HEADER_ONLY = False + * - LOADER = False + * - MX = False + * - ON_DEMAND = False + * + * Commandline: + * --api='vulkan=1.3' --extensions='' c + * + * Online: + * http://glad.sh/#api=vulkan%3D1.3&extensions=&generator=c&options= + * + */ +const VK_ATTACHMENT_UNUSED = (~0U); +const VK_FALSE = 0; +const VK_LOD_CLAMP_NONE = 1000.0F; +const VK_LUID_SIZE = 8; +const VK_MAX_DESCRIPTION_SIZE = 256; +const VK_MAX_DEVICE_GROUP_SIZE = 32; +const VK_MAX_DRIVER_INFO_SIZE = 256; +const VK_MAX_DRIVER_NAME_SIZE = 256; +const VK_MAX_EXTENSION_NAME_SIZE = 256; +const VK_MAX_MEMORY_HEAPS = 16; +const VK_MAX_MEMORY_TYPES = 32; +const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256; +const VK_QUEUE_FAMILY_EXTERNAL = (~1U); +const VK_QUEUE_FAMILY_IGNORED = (~0U); +const VK_REMAINING_ARRAY_LAYERS = (~0U); +const VK_REMAINING_MIP_LEVELS = (~0U); +const VK_SUBPASS_EXTERNAL = (~0U); +const VK_TRUE = 1; +const VK_UUID_SIZE = 16; +const ulong VK_WHOLE_SIZE = (~0); + +distinct VkInstance = uptr; +distinct VkPhysicalDevice = uptr; +distinct VkDevice = uptr; +distinct VkQueue = uptr; +distinct VkCommandBuffer = uptr; +distinct VkDeviceMemory = uptr; +distinct VkCommandPool = uptr; +distinct VkBuffer = uptr; +distinct VkBufferView = uptr; +distinct VkImage = uptr; +distinct VkImageView = uptr; +distinct VkShaderModule = uptr; +distinct VkPipeline = uptr; +distinct VkPipelineLayout = uptr; +distinct VkSampler = uptr; +distinct VkDescriptorSet = uptr; +distinct VkDescriptorSetLayout = uptr; +distinct VkDescriptorPool = uptr; +distinct VkFence = uptr; +distinct VkSemaphore = uptr; +distinct VkEvent = uptr; +distinct VkQueryPool = uptr; +distinct VkFramebuffer = uptr; +distinct VkRenderPass = uptr; +distinct VkPipelineCache = uptr; +distinct VkDescriptorUpdateTemplate = uptr; +distinct VkSamplerYcbcrConversion = uptr; +distinct VkPrivateDataSlot = uptr; +enum VkAttachmentLoadOp : int (int value) +{ + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkAttachmentStoreOp : int (int value) +{ + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_NONE = 1000301000, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkBlendFactor : int (int value) +{ + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkBlendOp : int (int value) +{ + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkBorderColor : int (int value) +{ + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkFramebufferCreateFlagBits : int (int value) +{ + VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 1, + VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineCacheHeaderVersion : int (int value) +{ + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineCacheCreateFlagBits : int (int value) +{ + VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 1, + VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineShaderStageCreateFlagBits : int (int value) +{ + VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 1, + VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 2, + VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorSetLayoutCreateFlagBits : int (int value) +{ + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 2, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDeviceQueueCreateFlagBits : int (int value) +{ + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 1, + VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkBufferCreateFlagBits : int (int value) +{ + 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, + VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkBufferUsageFlagBits : int (int value) +{ + 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, + VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkColorComponentFlagBits : int (int value) +{ + VK_COLOR_COMPONENT_R_BIT = 1, + VK_COLOR_COMPONENT_G_BIT = 2, + VK_COLOR_COMPONENT_B_BIT = 4, + VK_COLOR_COMPONENT_A_BIT = 8, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkComponentSwizzle : int (int value) +{ + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandPoolCreateFlagBits : int (int value) +{ + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 4, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandPoolResetFlagBits : int (int value) +{ + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferResetFlagBits : int (int value) +{ + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferLevel : int (int value) +{ + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} +enum VkCommandBufferUsageFlagBits : int (int value) +{ + 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, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkCompareOp : int (int value) +{ + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkCullModeFlagBits : int (int value) +{ + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 1, + VK_CULL_MODE_BACK_BIT = 2, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorType : int (int value) +{ + 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, + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkDynamicState : int (int value) +{ + 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, + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} +enum VkFenceCreateFlagBits : int (int value) +{ + VK_FENCE_CREATE_SIGNALED_BIT = 1, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPolygonMode : int (int value) +{ + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkFormat : int (int value) +{ + 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, + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} +enum VkFormatFeatureFlagBits : int (int value) +{ + 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, + VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkFrontFace : int (int value) +{ + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageAspectFlagBits : int (int value) +{ + 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, + VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageCreateFlagBits : int (int value) +{ + 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, + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageLayout : int (int value) +{ + 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, + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageTiling : int (int value) +{ + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageType : int (int value) +{ + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageUsageFlagBits : int (int value) +{ + 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, + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkImageViewType : int (int value) +{ + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSharingMode : int (int value) +{ + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkIndexType : int (int value) +{ + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkLogicOp : int (int value) +{ + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryHeapFlagBits : int (int value) +{ + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 2, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkAccessFlagBits : int (int value) +{ + 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, + VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryPropertyFlagBits : int (int value) +{ + 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, + VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPhysicalDeviceType : int (int value) +{ + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineBindPoint : int (int value) +{ + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineCreateFlagBits : int (int value) +{ + 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, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPrimitiveTopology : int (int value) +{ + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryControlFlagBits : int (int value) +{ + VK_QUERY_CONTROL_PRECISE_BIT = 1, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryPipelineStatisticFlagBits : int (int value) +{ + 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, + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryResultFlagBits : int (int value) +{ + 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, + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueryType : int (int value) +{ + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkQueueFlagBits : int (int value) +{ + 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, + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSubpassContents : int (int value) +{ + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} +enum VkResult : int (int value) +{ + 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, + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} +enum VkShaderStageFlagBits : int (int value) +{ + 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, + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSparseMemoryBindFlagBits : int (int value) +{ + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkStencilFaceFlagBits : int (int value) +{ + 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, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkStencilOp : int (int value) +{ + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} +enum VkStructureType : int (int value) +{ + 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, + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSystemAllocationScope : int (int value) +{ + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkInternalAllocationType : int (int value) +{ + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerAddressMode : int (int value) +{ + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkFilter : int (int value) +{ + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerMipmapMode : int (int value) +{ + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkVertexInputRate : int (int value) +{ + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineStageFlagBits : int (int value) +{ + 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, + VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSparseImageFormatFlagBits : int (int value) +{ + 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, + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSampleCountFlagBits : int (int value) +{ + 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, + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkAttachmentDescriptionFlagBits : int (int value) +{ + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorPoolCreateFlagBits : int (int value) +{ + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 2, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDependencyFlagBits : int (int value) +{ + VK_DEPENDENCY_BY_REGION_BIT = 1, + VK_DEPENDENCY_DEVICE_GROUP_BIT = 4, + VK_DEPENDENCY_VIEW_LOCAL_BIT = 2, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkObjectType : int (int value) +{ + 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, + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkEventCreateFlagBits : int (int value) +{ + VK_EVENT_CREATE_DEVICE_ONLY_BIT = 1, + VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorUpdateTemplateType : int (int value) +{ + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPointClippingBehavior : int (int value) +{ + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} +enum VkResolveModeFlagBits : int (int value) +{ + 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, + VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkDescriptorBindingFlagBits : int (int value) +{ + 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, + VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSemaphoreType : int (int value) +{ + VK_SEMAPHORE_TYPE_BINARY = 0, + VK_SEMAPHORE_TYPE_TIMELINE = 1, + VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF +} +enum VkPipelineCreationFeedbackFlagBits : int (int value) +{ + 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, + VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSemaphoreWaitFlagBits : int (int value) +{ + VK_SEMAPHORE_WAIT_ANY_BIT = 1, + VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkToolPurposeFlagBits : int (int value) +{ + 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, + VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +def VkAccessFlagBits2 = ulong; +const VkAccessFlagBits2 VK_ACCESS_2_NONE = 0; +const VkAccessFlagBits2 VK_ACCESS_2_NONE_KHR = 0; +const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 1; +const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 1; +const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT = 2; +const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT_KHR = 2; +const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 4; +const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 4; +const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT = 8; +const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 8; +const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 16; +const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 16; +const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT = 32; +const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT_KHR = 32; +const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT = 64; +const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 64; +const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 128; +const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 128; +const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 256; +const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 256; +const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 512; +const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 512; +const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 1024; +const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 1024; +const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT = 2048; +const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 2048; +const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT = 4096; +const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 4096; +const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT = 8192; +const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT_KHR = 8192; +const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT = 16384; +const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT_KHR = 16384; +const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT = 32768; +const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT_KHR = 32768; +const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT = 65536; +const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 65536; +const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 4294967296; +const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 4294967296; +const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 8589934592; +const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 8589934592; +const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 17179869184; +const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 17179869184; + +def VkPipelineStageFlagBits2 = ulong; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE = 0; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE_KHR = 0; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 1; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 1; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 2; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 2; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 4; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 4; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 8; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 8; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 16; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 16; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 32; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 32; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 64; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 64; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 128; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 128; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 256; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 256; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 512; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 512; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 1024; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 1024; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 2048; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 2048; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 4096; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 4096; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT = 4096; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 4096; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 8192; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 8192; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT = 16384; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 16384; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 32768; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 32768; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 65536; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 65536; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT = 4294967296; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 4294967296; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 8589934592; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 8589934592; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT = 17179869184; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 17179869184; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT = 34359738368; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 34359738368; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 68719476736; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 68719476736; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 137438953472; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 137438953472; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 274877906944; +const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 274877906944; + +def VkFormatFeatureFlagBits2 = ulong; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 1; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 1; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 2; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 2; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 4; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 4; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 8; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 8; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 16; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 16; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 32; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 32; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 64; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 64; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 128; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 128; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 256; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 256; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 512; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 512; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 1024; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 1024; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 2048; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 2048; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4096; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 4096; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 8192; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 8192; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 16384; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 16384; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 32768; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 32768; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 65536; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 65536; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 131072; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 131072; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 262144; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 262144; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 524288; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 524288; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 1048576; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 1048576; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 2097152; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 2097152; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 4194304; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 4194304; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 8388608; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 8388608; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 2147483648; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 2147483648; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 4294967296; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 4294967296; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 8589934592; +const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 8589934592; + +enum VkRenderingFlagBits : int (int value) +{ + 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, + VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalMemoryHandleTypeFlagBits : int (int value) +{ + 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, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalMemoryFeatureFlagBits : int (int value) +{ + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalSemaphoreHandleTypeFlagBits : int (int value) +{ + 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, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalSemaphoreFeatureFlagBits : int (int value) +{ + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSemaphoreImportFlagBits : int (int value) +{ + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalFenceHandleTypeFlagBits : int (int value) +{ + 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, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkExternalFenceFeatureFlagBits : int (int value) +{ + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkFenceImportFlagBits : int (int value) +{ + VK_FENCE_IMPORT_TEMPORARY_BIT = 1, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkPeerMemoryFeatureFlagBits : int (int value) +{ + 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, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkMemoryAllocateFlagBits : int (int value) +{ + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 2, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 4, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkSubgroupFeatureFlagBits : int (int value) +{ + 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, + VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkTessellationDomainOrigin : int (int value) +{ + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerYcbcrModelConversion : int (int value) +{ + 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, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerYcbcrRange : int (int value) +{ + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF +} +enum VkChromaLocation : int (int value) +{ + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, + VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF +} +enum VkSamplerReductionMode : int (int value) +{ + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, + VK_SAMPLER_REDUCTION_MODE_MIN = 1, + VK_SAMPLER_REDUCTION_MODE_MAX = 2, + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF +} +enum VkShaderFloatControlsIndependence : int (int value) +{ + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF +} +enum VkSubmitFlagBits : int (int value) +{ + VK_SUBMIT_PROTECTED_BIT = 1, + VK_SUBMIT_PROTECTED_BIT_KHR = 1, + VK_SUBMIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} +enum VkVendorId : int (int value) +{ + VK_VENDOR_ID_KHRONOS = 0x10000, + 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, + VK_VENDOR_ID_MOBILEYE = 0x10007, + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} +enum VkDriverId : int (int value) +{ + 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, + VK_DRIVER_ID_MESA_DOZEN = 23, + VK_DRIVER_ID_MESA_NVK = 24, + VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, + VK_DRIVER_ID_MESA_HONEYKRISP = 26, + VK_DRIVER_ID_RESERVED_27 = 27, + VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF +} +def PFN_vkInternalAllocationNotification = fn void ( + void* pUserData, + usz size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); +def PFN_vkInternalFreeNotification = fn void ( + void* pUserData, + usz size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); +def PFN_vkReallocationFunction = fn void* ( + void* pUserData, + void* pOriginal, + usz size, + usz alignment, + VkSystemAllocationScope allocationScope); +def PFN_vkAllocationFunction = fn void* ( + void* pUserData, + usz size, + usz alignment, + VkSystemAllocationScope allocationScope); +def PFN_vkFreeFunction = fn void ( + void* pUserData, + void* pMemory); +def PFN_vkVoidFunction = fn void (); +struct VkBaseOutStructure +{ + VkStructureType sType; + VkBaseOutStructure * pNext; +} + +struct VkBaseInStructure +{ + VkStructureType sType; + VkBaseInStructure * pNext; +} + +struct VkOffset2D +{ + int x; + int y; +} + +struct VkOffset3D +{ + int x; + int y; + int z; +} + +struct VkExtent2D +{ + uint width; + uint height; +} + +struct VkExtent3D +{ + uint width; + uint height; + uint depth; +} + +struct VkViewport +{ + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} + +struct VkRect2D +{ + VkOffset2D offset; + VkExtent2D extent; +} + +struct VkClearRect +{ + VkRect2D rect; + uint baseArrayLayer; + uint layerCount; +} + +struct VkComponentMapping +{ + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} + +struct VkExtensionProperties +{ + char[ VK_MAX_EXTENSION_NAME_SIZE ] extensionName; + uint specVersion; +} + +struct VkLayerProperties +{ + char[ VK_MAX_EXTENSION_NAME_SIZE ] layerName; + uint specVersion; + uint implementationVersion; + char[ VK_MAX_DESCRIPTION_SIZE ] description; +} + +struct VkApplicationInfo +{ + VkStructureType sType; + void * pNext; + char * pApplicationName; + uint applicationVersion; + char * pEngineName; + uint engineVersion; + uint apiVersion; +} + +struct VkAllocationCallbacks +{ + void * pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} + +struct VkDescriptorImageInfo +{ + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} + +struct VkCopyDescriptorSet +{ + VkStructureType sType; + void * pNext; + VkDescriptorSet srcSet; + uint srcBinding; + uint srcArrayElement; + VkDescriptorSet dstSet; + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; +} + +struct VkDescriptorPoolSize +{ + VkDescriptorType type; + uint descriptorCount; +} + +struct VkDescriptorSetAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorPool descriptorPool; + uint descriptorSetCount; + VkDescriptorSetLayout * pSetLayouts; +} + +struct VkSpecializationMapEntry +{ + uint constantID; + uint offset; + usz size; +} + +struct VkSpecializationInfo +{ + uint mapEntryCount; + VkSpecializationMapEntry * pMapEntries; + usz dataSize; + void * pData; +} + +struct VkVertexInputBindingDescription +{ + uint binding; + uint stride; + VkVertexInputRate inputRate; +} + +struct VkVertexInputAttributeDescription +{ + uint location; + uint binding; + VkFormat format; + uint offset; +} + +struct VkStencilOpState +{ + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint compareMask; + uint writeMask; + uint reference; +} + +struct VkPipelineCacheHeaderVersionOne +{ + uint headerSize; + VkPipelineCacheHeaderVersion headerVersion; + uint vendorID; + uint deviceID; + char[ VK_UUID_SIZE ] pipelineCacheUUID; +} + +struct VkCommandBufferAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint commandBufferCount; +} + +union VkClearColorValue { + float[4] float32; + int[4] int32; + uint[4] uint32; +} + +struct VkClearDepthStencilValue +{ + float depth; + uint stencil; +} + +union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} + +struct VkAttachmentReference +{ + uint attachment; + VkImageLayout layout; +} + +struct VkDrawIndirectCommand +{ + uint vertexCount; + uint instanceCount; + uint firstVertex; + uint firstInstance; +} + +struct VkDrawIndexedIndirectCommand +{ + uint indexCount; + uint instanceCount; + uint firstIndex; + int vertexOffset; + uint firstInstance; +} + +struct VkDispatchIndirectCommand +{ + uint x; + uint y; + uint z; +} + +struct VkDevicePrivateDataCreateInfo +{ + VkStructureType sType; + void * pNext; + uint privateDataSlotRequestCount; +} + +struct VkConformanceVersion +{ + char major; + char minor; + char subminor; + char patch; +} + +struct VkPhysicalDeviceDriverProperties +{ + VkStructureType sType; + void * pNext; + VkDriverId driverID; + char[ VK_MAX_DRIVER_NAME_SIZE ] driverName; + char[ VK_MAX_DRIVER_INFO_SIZE ] driverInfo; + VkConformanceVersion conformanceVersion; +} + +struct VkPhysicalDeviceExternalImageFormatInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} + +struct VkPhysicalDeviceExternalSemaphoreInfo +{ + VkStructureType sType; + void * pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} + +struct VkPhysicalDeviceExternalFenceInfo +{ + VkStructureType sType; + void * pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} + +struct VkPhysicalDeviceMultiviewProperties +{ + VkStructureType sType; + void * pNext; + uint maxMultiviewViewCount; + uint maxMultiviewInstanceIndex; +} + +struct VkRenderPassMultiviewCreateInfo +{ + VkStructureType sType; + void * pNext; + uint subpassCount; + uint * pViewMasks; + uint dependencyCount; + int * pViewOffsets; + uint correlationMaskCount; + uint * pCorrelationMasks; +} + +struct VkBindBufferMemoryDeviceGroupInfo +{ + VkStructureType sType; + void * pNext; + uint deviceIndexCount; + uint * pDeviceIndices; +} + +struct VkBindImageMemoryDeviceGroupInfo +{ + VkStructureType sType; + void * pNext; + uint deviceIndexCount; + uint * pDeviceIndices; + uint splitInstanceBindRegionCount; + VkRect2D * pSplitInstanceBindRegions; +} + +struct VkDeviceGroupRenderPassBeginInfo +{ + VkStructureType sType; + void * pNext; + uint deviceMask; + uint deviceRenderAreaCount; + VkRect2D * pDeviceRenderAreas; +} + +struct VkDeviceGroupCommandBufferBeginInfo +{ + VkStructureType sType; + void * pNext; + uint deviceMask; +} + +struct VkDeviceGroupSubmitInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + uint * pWaitSemaphoreDeviceIndices; + uint commandBufferCount; + uint * pCommandBufferDeviceMasks; + uint signalSemaphoreCount; + uint * pSignalSemaphoreDeviceIndices; +} + +struct VkDeviceGroupBindSparseInfo +{ + VkStructureType sType; + void * pNext; + uint resourceDeviceIndex; + uint memoryDeviceIndex; +} + +struct VkDeviceGroupDeviceCreateInfo +{ + VkStructureType sType; + void * pNext; + uint physicalDeviceCount; + VkPhysicalDevice * pPhysicalDevices; +} + +struct VkDescriptorUpdateTemplateEntry +{ + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; + VkDescriptorType descriptorType; + usz offset; + usz stride; +} + +struct VkBufferMemoryRequirementsInfo2 +{ + VkStructureType sType; + void * pNext; + VkBuffer buffer; +} + +struct VkImageMemoryRequirementsInfo2 +{ + VkStructureType sType; + void * pNext; + VkImage image; +} + +struct VkImageSparseMemoryRequirementsInfo2 +{ + VkStructureType sType; + void * pNext; + VkImage image; +} + +struct VkPhysicalDevicePointClippingProperties +{ + VkStructureType sType; + void * pNext; + VkPointClippingBehavior pointClippingBehavior; +} + +struct VkMemoryDedicatedAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkImage image; + VkBuffer buffer; +} + +struct VkPipelineTessellationDomainOriginStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkTessellationDomainOrigin domainOrigin; +} + +struct VkSamplerYcbcrConversionInfo +{ + VkStructureType sType; + void * pNext; + VkSamplerYcbcrConversion conversion; +} + +struct VkBindImagePlaneMemoryInfo +{ + VkStructureType sType; + void * pNext; + VkImageAspectFlagBits planeAspect; +} + +struct VkImagePlaneMemoryRequirementsInfo +{ + VkStructureType sType; + void * pNext; + VkImageAspectFlagBits planeAspect; +} + +struct VkSamplerYcbcrConversionImageFormatProperties +{ + VkStructureType sType; + void * pNext; + uint combinedImageSamplerDescriptorCount; +} + +struct VkSamplerReductionModeCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSamplerReductionMode reductionMode; +} + +struct VkPhysicalDeviceInlineUniformBlockProperties +{ + VkStructureType sType; + void * pNext; + uint maxInlineUniformBlockSize; + uint maxPerStageDescriptorInlineUniformBlocks; + uint maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint maxDescriptorSetInlineUniformBlocks; + uint maxDescriptorSetUpdateAfterBindInlineUniformBlocks; +} + +struct VkWriteDescriptorSetInlineUniformBlock +{ + VkStructureType sType; + void * pNext; + uint dataSize; + void * pData; +} + +struct VkDescriptorPoolInlineUniformBlockCreateInfo +{ + VkStructureType sType; + void * pNext; + uint maxInlineUniformBlockBindings; +} + +struct VkImageFormatListCreateInfo +{ + VkStructureType sType; + void * pNext; + uint viewFormatCount; + VkFormat * pViewFormats; +} + +struct VkDescriptorSetVariableDescriptorCountAllocateInfo +{ + VkStructureType sType; + void * pNext; + uint descriptorSetCount; + uint * pDescriptorCounts; +} + +struct VkDescriptorSetVariableDescriptorCountLayoutSupport +{ + VkStructureType sType; + void * pNext; + uint maxVariableDescriptorCount; +} + +struct VkSubpassBeginInfo +{ + VkStructureType sType; + void * pNext; + VkSubpassContents contents; +} + +struct VkSubpassEndInfo +{ + VkStructureType sType; + void * pNext; +} + +struct VkPhysicalDeviceTimelineSemaphoreProperties +{ + VkStructureType sType; + void * pNext; + ulong maxTimelineSemaphoreValueDifference; +} + +struct VkSemaphoreTypeCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphoreType semaphoreType; + ulong initialValue; +} + +struct VkTimelineSemaphoreSubmitInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreValueCount; + ulong * pWaitSemaphoreValues; + uint signalSemaphoreValueCount; + ulong * pSignalSemaphoreValues; +} + +struct VkSemaphoreSignalInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphore semaphore; + ulong value; +} + +struct VkBufferDeviceAddressInfo +{ + VkStructureType sType; + void * pNext; + VkBuffer buffer; +} + +struct VkBufferOpaqueCaptureAddressCreateInfo +{ + VkStructureType sType; + void * pNext; + ulong opaqueCaptureAddress; +} + +struct VkRenderPassAttachmentBeginInfo +{ + VkStructureType sType; + void * pNext; + uint attachmentCount; + VkImageView * pAttachments; +} + +struct VkAttachmentReferenceStencilLayout +{ + VkStructureType sType; + void * pNext; + VkImageLayout stencilLayout; +} + +struct VkAttachmentDescriptionStencilLayout +{ + VkStructureType sType; + void * pNext; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; +} + +struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo +{ + VkStructureType sType; + void * pNext; + uint requiredSubgroupSize; +} + +struct VkMemoryOpaqueCaptureAddressAllocateInfo +{ + VkStructureType sType; + void * pNext; + ulong opaqueCaptureAddress; +} + +struct VkDeviceMemoryOpaqueCaptureAddressInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceMemory memory; +} + +struct VkCommandBufferSubmitInfo +{ + VkStructureType sType; + void * pNext; + VkCommandBuffer commandBuffer; + uint deviceMask; +} + +struct VkPipelineRenderingCreateInfo +{ + VkStructureType sType; + void * pNext; + uint viewMask; + uint colorAttachmentCount; + VkFormat * pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; +} + +struct VkRenderingAttachmentInfo +{ + VkStructureType sType; + void * pNext; + VkImageView imageView; + VkImageLayout imageLayout; + VkResolveModeFlagBits resolveMode; + VkImageView resolveImageView; + VkImageLayout resolveImageLayout; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkClearValue clearValue; +} + +def VkSampleMask = uint; +def VkBool32 = uint; +def VkFlags = uint; +def VkFlags64 = ulong; +def VkDeviceSize = ulong; +def VkDeviceAddress = ulong; +def VkFramebufferCreateFlags = VkFlags; +def VkQueryPoolCreateFlags = VkFlags; +def VkRenderPassCreateFlags = VkFlags; +def VkSamplerCreateFlags = VkFlags; +def VkPipelineLayoutCreateFlags = VkFlags; +def VkPipelineCacheCreateFlags = VkFlags; +def VkPipelineDepthStencilStateCreateFlags = VkFlags; +def VkPipelineDynamicStateCreateFlags = VkFlags; +def VkPipelineColorBlendStateCreateFlags = VkFlags; +def VkPipelineMultisampleStateCreateFlags = VkFlags; +def VkPipelineRasterizationStateCreateFlags = VkFlags; +def VkPipelineViewportStateCreateFlags = VkFlags; +def VkPipelineTessellationStateCreateFlags = VkFlags; +def VkPipelineInputAssemblyStateCreateFlags = VkFlags; +def VkPipelineVertexInputStateCreateFlags = VkFlags; +def VkPipelineShaderStageCreateFlags = VkFlags; +def VkDescriptorSetLayoutCreateFlags = VkFlags; +def VkBufferViewCreateFlags = VkFlags; +def VkInstanceCreateFlags = VkFlags; +def VkDeviceCreateFlags = VkFlags; +def VkDeviceQueueCreateFlags = VkFlags; +def VkQueueFlags = VkFlags; +def VkMemoryPropertyFlags = VkFlags; +def VkMemoryHeapFlags = VkFlags; +def VkAccessFlags = VkFlags; +def VkBufferUsageFlags = VkFlags; +def VkBufferCreateFlags = VkFlags; +def VkShaderStageFlags = VkFlags; +def VkImageUsageFlags = VkFlags; +def VkImageCreateFlags = VkFlags; +def VkImageViewCreateFlags = VkFlags; +def VkPipelineCreateFlags = VkFlags; +def VkColorComponentFlags = VkFlags; +def VkFenceCreateFlags = VkFlags; +def VkSemaphoreCreateFlags = VkFlags; +def VkFormatFeatureFlags = VkFlags; +def VkQueryControlFlags = VkFlags; +def VkQueryResultFlags = VkFlags; +def VkShaderModuleCreateFlags = VkFlags; +def VkEventCreateFlags = VkFlags; +def VkCommandPoolCreateFlags = VkFlags; +def VkCommandPoolResetFlags = VkFlags; +def VkCommandBufferResetFlags = VkFlags; +def VkCommandBufferUsageFlags = VkFlags; +def VkQueryPipelineStatisticFlags = VkFlags; +def VkMemoryMapFlags = VkFlags; +def VkImageAspectFlags = VkFlags; +def VkSparseMemoryBindFlags = VkFlags; +def VkSparseImageFormatFlags = VkFlags; +def VkSubpassDescriptionFlags = VkFlags; +def VkPipelineStageFlags = VkFlags; +def VkSampleCountFlags = VkFlags; +def VkAttachmentDescriptionFlags = VkFlags; +def VkStencilFaceFlags = VkFlags; +def VkCullModeFlags = VkFlags; +def VkDescriptorPoolCreateFlags = VkFlags; +def VkDescriptorPoolResetFlags = VkFlags; +def VkDependencyFlags = VkFlags; +def VkSubgroupFeatureFlags = VkFlags; +def VkPrivateDataSlotCreateFlags = VkFlags; +def VkDescriptorUpdateTemplateCreateFlags = VkFlags; +def VkPipelineCreationFeedbackFlags = VkFlags; +def VkSemaphoreWaitFlags = VkFlags; +def VkAccessFlags2 = VkFlags64; +def VkPipelineStageFlags2 = VkFlags64; +def VkFormatFeatureFlags2 = VkFlags64; +def VkRenderingFlags = VkFlags; +def VkPeerMemoryFeatureFlags = VkFlags; +def VkMemoryAllocateFlags = VkFlags; +def VkCommandPoolTrimFlags = VkFlags; +def VkExternalMemoryHandleTypeFlags = VkFlags; +def VkExternalMemoryFeatureFlags = VkFlags; +def VkExternalSemaphoreHandleTypeFlags = VkFlags; +def VkExternalSemaphoreFeatureFlags = VkFlags; +def VkSemaphoreImportFlags = VkFlags; +def VkExternalFenceHandleTypeFlags = VkFlags; +def VkExternalFenceFeatureFlags = VkFlags; +def VkFenceImportFlags = VkFlags; +def VkDescriptorBindingFlags = VkFlags; +def VkResolveModeFlags = VkFlags; +def VkToolPurposeFlags = VkFlags; +def VkSubmitFlags = VkFlags; +struct VkDeviceQueueCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceQueueCreateFlags flags; + uint queueFamilyIndex; + uint queueCount; + float * pQueuePriorities; +} + +struct VkInstanceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkInstanceCreateFlags flags; + VkApplicationInfo * pApplicationInfo; + uint enabledLayerCount; + ZString ppEnabledLayerNames; + uint enabledExtensionCount; + ZString ppEnabledExtensionNames; +} + +struct VkQueueFamilyProperties +{ + VkQueueFlags queueFlags; + uint queueCount; + uint timestampValidBits; + VkExtent3D minImageTransferGranularity; +} + +struct VkMemoryAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceSize allocationSize; + uint memoryTypeIndex; +} + +struct VkMemoryRequirements +{ + VkDeviceSize size; + VkDeviceSize alignment; + uint memoryTypeBits; +} + +struct VkSparseImageFormatProperties +{ + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} + +struct VkSparseImageMemoryRequirements +{ + VkSparseImageFormatProperties formatProperties; + uint imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} + +struct VkMemoryType +{ + VkMemoryPropertyFlags propertyFlags; + uint heapIndex; +} + +struct VkMemoryHeap +{ + VkDeviceSize size; + VkMemoryHeapFlags flags; +} + +struct VkMappedMemoryRange +{ + VkStructureType sType; + void * pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} + +struct VkFormatProperties +{ + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} + +struct VkImageFormatProperties +{ + VkExtent3D maxExtent; + uint maxMipLevels; + uint maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} + +struct VkDescriptorBufferInfo +{ + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} + +struct VkWriteDescriptorSet +{ + VkStructureType sType; + void * pNext; + VkDescriptorSet dstSet; + uint dstBinding; + uint dstArrayElement; + uint descriptorCount; + VkDescriptorType descriptorType; + VkDescriptorImageInfo * pImageInfo; + VkDescriptorBufferInfo * pBufferInfo; + VkBufferView * pTexelBufferView; +} + +struct VkBufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint queueFamilyIndexCount; + uint * pQueueFamilyIndices; +} + +struct VkBufferViewCreateInfo +{ + VkStructureType sType; + void * pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} + +struct VkImageSubresource +{ + VkImageAspectFlags aspectMask; + uint mipLevel; + uint arrayLayer; +} + +struct VkImageSubresourceLayers +{ + VkImageAspectFlags aspectMask; + uint mipLevel; + uint baseArrayLayer; + uint layerCount; +} + +struct VkImageSubresourceRange +{ + VkImageAspectFlags aspectMask; + uint baseMipLevel; + uint levelCount; + uint baseArrayLayer; + uint layerCount; +} + +struct VkMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} + +struct VkBufferMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint srcQueueFamilyIndex; + uint dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} + +struct VkImageMemoryBarrier +{ + VkStructureType sType; + void * pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint srcQueueFamilyIndex; + uint dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} + +struct VkImageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint mipLevels; + uint arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint queueFamilyIndexCount; + uint * pQueueFamilyIndices; + VkImageLayout initialLayout; +} + +struct VkSubresourceLayout +{ + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} + +struct VkImageViewCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} + +struct VkBufferCopy +{ + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} + +struct VkSparseMemoryBind +{ + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} + +struct VkSparseImageMemoryBind +{ + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} + +struct VkSparseBufferMemoryBindInfo +{ + VkBuffer buffer; + uint bindCount; + VkSparseMemoryBind * pBinds; +} + +struct VkSparseImageOpaqueMemoryBindInfo +{ + VkImage image; + uint bindCount; + VkSparseMemoryBind * pBinds; +} + +struct VkSparseImageMemoryBindInfo +{ + VkImage image; + uint bindCount; + VkSparseImageMemoryBind * pBinds; +} + +struct VkBindSparseInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + VkSemaphore * pWaitSemaphores; + uint bufferBindCount; + VkSparseBufferMemoryBindInfo * pBufferBinds; + uint imageOpaqueBindCount; + VkSparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds; + uint imageBindCount; + VkSparseImageMemoryBindInfo * pImageBinds; + uint signalSemaphoreCount; + VkSemaphore * pSignalSemaphores; +} + +struct VkImageCopy +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} + +struct VkImageBlit +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D[2] srcOffsets; + VkImageSubresourceLayers dstSubresource; + VkOffset3D[2] dstOffsets; +} + +struct VkBufferImageCopy +{ + VkDeviceSize bufferOffset; + uint bufferRowLength; + uint bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} + +struct VkImageResolve +{ + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} + +struct VkShaderModuleCreateInfo +{ + VkStructureType sType; + void * pNext; + VkShaderModuleCreateFlags flags; + usz codeSize; + uint * pCode; +} + +struct VkDescriptorSetLayoutBinding +{ + uint binding; + VkDescriptorType descriptorType; + uint descriptorCount; + VkShaderStageFlags stageFlags; + VkSampler * pImmutableSamplers; +} + +struct VkDescriptorSetLayoutCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint bindingCount; + VkDescriptorSetLayoutBinding * pBindings; +} + +struct VkDescriptorPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorPoolCreateFlags flags; + uint maxSets; + uint poolSizeCount; + VkDescriptorPoolSize * pPoolSizes; +} + +struct VkPipelineShaderStageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule vkmodule; + char * pName; + VkSpecializationInfo * pSpecializationInfo; +} + +struct VkComputePipelineCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int basePipelineIndex; +} + +struct VkPipelineVertexInputStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint vertexBindingDescriptionCount; + VkVertexInputBindingDescription * pVertexBindingDescriptions; + uint vertexAttributeDescriptionCount; + VkVertexInputAttributeDescription * pVertexAttributeDescriptions; +} + +struct VkPipelineInputAssemblyStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} + +struct VkPipelineTessellationStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineTessellationStateCreateFlags flags; + uint patchControlPoints; +} + +struct VkPipelineViewportStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineViewportStateCreateFlags flags; + uint viewportCount; + VkViewport * pViewports; + uint scissorCount; + VkRect2D * pScissors; +} + +struct VkPipelineRasterizationStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} + +struct VkPipelineMultisampleStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + VkSampleMask * pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} + +struct VkPipelineColorBlendAttachmentState +{ + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} + +struct VkPipelineColorBlendStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint attachmentCount; + VkPipelineColorBlendAttachmentState * pAttachments; + float[4] blendConstants; +} + +struct VkPipelineDynamicStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineDynamicStateCreateFlags flags; + uint dynamicStateCount; + VkDynamicState * pDynamicStates; +} + +struct VkPipelineDepthStencilStateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} + +struct VkGraphicsPipelineCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCreateFlags flags; + uint stageCount; + VkPipelineShaderStageCreateInfo * pStages; + VkPipelineVertexInputStateCreateInfo * pVertexInputState; + VkPipelineInputAssemblyStateCreateInfo * pInputAssemblyState; + VkPipelineTessellationStateCreateInfo * pTessellationState; + VkPipelineViewportStateCreateInfo * pViewportState; + VkPipelineRasterizationStateCreateInfo * pRasterizationState; + VkPipelineMultisampleStateCreateInfo * pMultisampleState; + VkPipelineDepthStencilStateCreateInfo * pDepthStencilState; + VkPipelineColorBlendStateCreateInfo * pColorBlendState; + VkPipelineDynamicStateCreateInfo * pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint subpass; + VkPipeline basePipelineHandle; + int basePipelineIndex; +} + +struct VkPipelineCacheCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCacheCreateFlags flags; + usz initialDataSize; + void * pInitialData; +} + +struct VkPushConstantRange +{ + VkShaderStageFlags stageFlags; + uint offset; + uint size; +} + +struct VkPipelineLayoutCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineLayoutCreateFlags flags; + uint setLayoutCount; + VkDescriptorSetLayout * pSetLayouts; + uint pushConstantRangeCount; + VkPushConstantRange * pPushConstantRanges; +} + +struct VkSamplerCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} + +struct VkCommandPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkCommandPoolCreateFlags flags; + uint queueFamilyIndex; +} + +struct VkCommandBufferInheritanceInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPass renderPass; + uint subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} + +struct VkCommandBufferBeginInfo +{ + VkStructureType sType; + void * pNext; + VkCommandBufferUsageFlags flags; + VkCommandBufferInheritanceInfo * pInheritanceInfo; +} + +struct VkRenderPassBeginInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint clearValueCount; + VkClearValue * pClearValues; +} + +struct VkClearAttachment +{ + VkImageAspectFlags aspectMask; + uint colorAttachment; + VkClearValue clearValue; +} + +struct VkAttachmentDescription +{ + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} + +struct VkSubpassDescription +{ + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint inputAttachmentCount; + VkAttachmentReference * pInputAttachments; + uint colorAttachmentCount; + VkAttachmentReference * pColorAttachments; + VkAttachmentReference * pResolveAttachments; + VkAttachmentReference * pDepthStencilAttachment; + uint preserveAttachmentCount; + uint * pPreserveAttachments; +} + +struct VkSubpassDependency +{ + uint srcSubpass; + uint dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} + +struct VkRenderPassCreateInfo +{ + VkStructureType sType; + void * pNext; + VkRenderPassCreateFlags flags; + uint attachmentCount; + VkAttachmentDescription * pAttachments; + uint subpassCount; + VkSubpassDescription * pSubpasses; + uint dependencyCount; + VkSubpassDependency * pDependencies; +} + +struct VkEventCreateInfo +{ + VkStructureType sType; + void * pNext; + VkEventCreateFlags flags; +} + +struct VkFenceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFenceCreateFlags flags; +} + +struct VkPhysicalDeviceFeatures +{ + VkBool32 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; +} + +struct VkPhysicalDeviceSparseProperties +{ + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} + +struct VkPhysicalDeviceLimits +{ + uint maxImageDimension1D; + uint maxImageDimension2D; + uint maxImageDimension3D; + uint maxImageDimensionCube; + uint maxImageArrayLayers; + uint maxTexelBufferElements; + uint maxUniformBufferRange; + uint maxStorageBufferRange; + uint maxPushConstantsSize; + uint maxMemoryAllocationCount; + uint maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint maxBoundDescriptorSets; + uint maxPerStageDescriptorSamplers; + uint maxPerStageDescriptorUniformBuffers; + uint maxPerStageDescriptorStorageBuffers; + uint maxPerStageDescriptorSampledImages; + uint maxPerStageDescriptorStorageImages; + uint maxPerStageDescriptorInputAttachments; + uint maxPerStageResources; + uint maxDescriptorSetSamplers; + uint maxDescriptorSetUniformBuffers; + uint maxDescriptorSetUniformBuffersDynamic; + uint maxDescriptorSetStorageBuffers; + uint maxDescriptorSetStorageBuffersDynamic; + uint maxDescriptorSetSampledImages; + uint maxDescriptorSetStorageImages; + uint maxDescriptorSetInputAttachments; + uint maxVertexInputAttributes; + uint maxVertexInputBindings; + uint maxVertexInputAttributeOffset; + uint maxVertexInputBindingStride; + uint maxVertexOutputComponents; + uint maxTessellationGenerationLevel; + uint maxTessellationPatchSize; + uint maxTessellationControlPerVertexInputComponents; + uint maxTessellationControlPerVertexOutputComponents; + uint maxTessellationControlPerPatchOutputComponents; + uint maxTessellationControlTotalOutputComponents; + uint maxTessellationEvaluationInputComponents; + uint maxTessellationEvaluationOutputComponents; + uint maxGeometryShaderInvocations; + uint maxGeometryInputComponents; + uint maxGeometryOutputComponents; + uint maxGeometryOutputVertices; + uint maxGeometryTotalOutputComponents; + uint maxFragmentInputComponents; + uint maxFragmentOutputAttachments; + uint maxFragmentDualSrcAttachments; + uint maxFragmentCombinedOutputResources; + uint maxComputeSharedMemorySize; + uint[3] maxComputeWorkGroupCount; + uint maxComputeWorkGroupInvocations; + uint[3] maxComputeWorkGroupSize; + uint subPixelPrecisionBits; + uint subTexelPrecisionBits; + uint mipmapPrecisionBits; + uint maxDrawIndexedIndexValue; + uint maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint maxViewports; + uint[2] maxViewportDimensions; + float[2] viewportBoundsRange; + uint viewportSubPixelBits; + usz minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int minTexelOffset; + uint maxTexelOffset; + int minTexelGatherOffset; + uint maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint subPixelInterpolationOffsetBits; + uint maxFramebufferWidth; + uint maxFramebufferHeight; + uint maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint maxClipDistances; + uint maxCullDistances; + uint maxCombinedClipAndCullDistances; + uint discreteQueuePriorities; + float[2] pointSizeRange; + float[2] lineWidthRange; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} + +struct VkSemaphoreCreateInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphoreCreateFlags flags; +} + +struct VkQueryPoolCreateInfo +{ + VkStructureType sType; + void * pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} + +struct VkFramebufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint attachmentCount; + VkImageView * pAttachments; + uint width; + uint height; + uint layers; +} + +struct VkSubmitInfo +{ + VkStructureType sType; + void * pNext; + uint waitSemaphoreCount; + VkSemaphore * pWaitSemaphores; + VkPipelineStageFlags * pWaitDstStageMask; + uint commandBufferCount; + VkCommandBuffer * pCommandBuffers; + uint signalSemaphoreCount; + VkSemaphore * pSignalSemaphores; +} + +struct VkPrivateDataSlotCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPrivateDataSlotCreateFlags flags; +} + +struct VkPhysicalDevicePrivateDataFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 privateData; +} + +struct VkPhysicalDeviceFeatures2 +{ + VkStructureType sType; + void * pNext; + VkPhysicalDeviceFeatures features; +} + +struct VkFormatProperties2 +{ + VkStructureType sType; + void * pNext; + VkFormatProperties formatProperties; +} + +struct VkImageFormatProperties2 +{ + VkStructureType sType; + void * pNext; + VkImageFormatProperties imageFormatProperties; +} + +struct VkPhysicalDeviceImageFormatInfo2 +{ + VkStructureType sType; + void * pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} + +struct VkQueueFamilyProperties2 +{ + VkStructureType sType; + void * pNext; + VkQueueFamilyProperties queueFamilyProperties; +} + +struct VkSparseImageFormatProperties2 +{ + VkStructureType sType; + void * pNext; + VkSparseImageFormatProperties properties; +} + +struct VkPhysicalDeviceSparseImageFormatInfo2 +{ + VkStructureType sType; + void * pNext; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; +} + +struct VkPhysicalDeviceVariablePointersFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} + +def VkPhysicalDeviceVariablePointerFeatures = VkPhysicalDeviceVariablePointersFeatures; + +struct VkExternalMemoryProperties +{ + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} + +struct VkExternalImageFormatProperties +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryProperties externalMemoryProperties; +} + +struct VkPhysicalDeviceExternalBufferInfo +{ + VkStructureType sType; + void * pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} + +struct VkExternalBufferProperties +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryProperties externalMemoryProperties; +} + +struct VkPhysicalDeviceIDProperties +{ + VkStructureType sType; + void * pNext; + char[ VK_UUID_SIZE ] deviceUUID; + char[ VK_UUID_SIZE ] driverUUID; + char[ VK_LUID_SIZE ] deviceLUID; + uint deviceNodeMask; + VkBool32 deviceLUIDValid; +} + +struct VkExternalMemoryImageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} + +struct VkExternalMemoryBufferCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} + +struct VkExportMemoryAllocateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} + +struct VkExternalSemaphoreProperties +{ + VkStructureType sType; + void * pNext; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} + +struct VkExportSemaphoreCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} + +struct VkExternalFenceProperties +{ + VkStructureType sType; + void * pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} + +struct VkExportFenceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} + +struct VkPhysicalDeviceMultiviewFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} + +struct VkPhysicalDeviceGroupProperties +{ + VkStructureType sType; + void * pNext; + uint physicalDeviceCount; + VkPhysicalDevice[ VK_MAX_DEVICE_GROUP_SIZE ] physicalDevices; + VkBool32 subsetAllocation; +} + +struct VkMemoryAllocateFlagsInfo +{ + VkStructureType sType; + void * pNext; + VkMemoryAllocateFlags flags; + uint deviceMask; +} + +struct VkBindBufferMemoryInfo +{ + VkStructureType sType; + void * pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} + +struct VkBindImageMemoryInfo +{ + VkStructureType sType; + void * pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} + +struct VkDescriptorUpdateTemplateCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDescriptorUpdateTemplateCreateFlags flags; + uint descriptorUpdateEntryCount; + VkDescriptorUpdateTemplateEntry * pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint set; +} + +struct VkInputAttachmentAspectReference +{ + uint subpass; + uint inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} + +struct VkRenderPassInputAttachmentAspectCreateInfo +{ + VkStructureType sType; + void * pNext; + uint aspectReferenceCount; + VkInputAttachmentAspectReference * pAspectReferences; +} + +struct VkPhysicalDevice16BitStorageFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} + +struct VkPhysicalDeviceSubgroupProperties +{ + VkStructureType sType; + void * pNext; + uint subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} + +struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderSubgroupExtendedTypes; +} + +struct VkDeviceBufferMemoryRequirements +{ + VkStructureType sType; + void * pNext; + VkBufferCreateInfo * pCreateInfo; +} + +struct VkDeviceImageMemoryRequirements +{ + VkStructureType sType; + void * pNext; + VkImageCreateInfo * pCreateInfo; + VkImageAspectFlagBits planeAspect; +} + +struct VkMemoryRequirements2 +{ + VkStructureType sType; + void * pNext; + VkMemoryRequirements memoryRequirements; +} + +struct VkSparseImageMemoryRequirements2 +{ + VkStructureType sType; + void * pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} + +struct VkMemoryDedicatedRequirements +{ + VkStructureType sType; + void * pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} + +struct VkImageViewUsageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageUsageFlags usage; +} + +struct VkSamplerYcbcrConversionCreateInfo +{ + VkStructureType sType; + void * pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} + +struct VkPhysicalDeviceSamplerYcbcrConversionFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 samplerYcbcrConversion; +} + +struct VkProtectedSubmitInfo +{ + VkStructureType sType; + void * pNext; + VkBool32 protectedSubmit; +} + +struct VkPhysicalDeviceProtectedMemoryFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 protectedMemory; +} + +struct VkPhysicalDeviceProtectedMemoryProperties +{ + VkStructureType sType; + void * pNext; + VkBool32 protectedNoFault; +} + +struct VkDeviceQueueInfo2 +{ + VkStructureType sType; + void * pNext; + VkDeviceQueueCreateFlags flags; + uint queueFamilyIndex; + uint queueIndex; +} + +struct VkPhysicalDeviceSamplerFilterMinmaxProperties +{ + VkStructureType sType; + void * pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} + +struct VkPhysicalDeviceInlineUniformBlockFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; +} + +struct VkPhysicalDeviceMaintenance3Properties +{ + VkStructureType sType; + void * pNext; + uint maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} + +struct VkPhysicalDeviceMaintenance4Features +{ + VkStructureType sType; + void * pNext; + VkBool32 maintenance4; +} + +struct VkPhysicalDeviceMaintenance4Properties +{ + VkStructureType sType; + void * pNext; + VkDeviceSize maxBufferSize; +} + +struct VkDescriptorSetLayoutSupport +{ + VkStructureType sType; + void * pNext; + VkBool32 supported; +} + +struct VkPhysicalDeviceShaderDrawParametersFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderDrawParameters; +} + +def VkPhysicalDeviceShaderDrawParameterFeatures = VkPhysicalDeviceShaderDrawParametersFeatures; + +struct VkPhysicalDeviceShaderFloat16Int8Features +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; +} + +struct VkPhysicalDeviceFloatControlsProperties +{ + VkStructureType sType; + void * pNext; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 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; +} + +struct VkPhysicalDeviceHostQueryResetFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 hostQueryReset; +} + +struct VkPhysicalDeviceDescriptorIndexingFeatures +{ + VkStructureType sType; + void * pNext; + 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; +} + +struct VkPhysicalDeviceDescriptorIndexingProperties +{ + VkStructureType sType; + void * pNext; + uint maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint maxPerStageDescriptorUpdateAfterBindSamplers; + uint maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint maxPerStageDescriptorUpdateAfterBindSampledImages; + uint maxPerStageDescriptorUpdateAfterBindStorageImages; + uint maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint maxPerStageUpdateAfterBindResources; + uint maxDescriptorSetUpdateAfterBindSamplers; + uint maxDescriptorSetUpdateAfterBindUniformBuffers; + uint maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint maxDescriptorSetUpdateAfterBindStorageBuffers; + uint maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint maxDescriptorSetUpdateAfterBindSampledImages; + uint maxDescriptorSetUpdateAfterBindStorageImages; + uint maxDescriptorSetUpdateAfterBindInputAttachments; +} + +struct VkDescriptorSetLayoutBindingFlagsCreateInfo +{ + VkStructureType sType; + void * pNext; + uint bindingCount; + VkDescriptorBindingFlags * pBindingFlags; +} + +struct VkAttachmentDescription2 +{ + VkStructureType sType; + void * pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} + +struct VkAttachmentReference2 +{ + VkStructureType sType; + void * pNext; + uint attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} + +struct VkSubpassDescription2 +{ + VkStructureType sType; + void * pNext; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint viewMask; + uint inputAttachmentCount; + VkAttachmentReference2 * pInputAttachments; + uint colorAttachmentCount; + VkAttachmentReference2 * pColorAttachments; + VkAttachmentReference2 * pResolveAttachments; + VkAttachmentReference2 * pDepthStencilAttachment; + uint preserveAttachmentCount; + uint * pPreserveAttachments; +} + +struct VkSubpassDependency2 +{ + VkStructureType sType; + void * pNext; + uint srcSubpass; + uint dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int viewOffset; +} + +struct VkRenderPassCreateInfo2 +{ + VkStructureType sType; + void * pNext; + VkRenderPassCreateFlags flags; + uint attachmentCount; + VkAttachmentDescription2 * pAttachments; + uint subpassCount; + VkSubpassDescription2 * pSubpasses; + uint dependencyCount; + VkSubpassDependency2 * pDependencies; + uint correlatedViewMaskCount; + uint * pCorrelatedViewMasks; +} + +struct VkPhysicalDeviceTimelineSemaphoreFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 timelineSemaphore; +} + +struct VkSemaphoreWaitInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphoreWaitFlags flags; + uint semaphoreCount; + VkSemaphore * pSemaphores; + ulong * pValues; +} + +struct VkPhysicalDevice8BitStorageFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} + +struct VkPhysicalDeviceVulkanMemoryModelFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; +} + +struct VkPhysicalDeviceShaderAtomicInt64Features +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} + +struct VkPhysicalDeviceDepthStencilResolveProperties +{ + VkStructureType sType; + void * pNext; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; +} + +struct VkSubpassDescriptionDepthStencilResolve +{ + VkStructureType sType; + void * pNext; + VkResolveModeFlagBits depthResolveMode; + VkResolveModeFlagBits stencilResolveMode; + VkAttachmentReference2 * pDepthStencilResolveAttachment; +} + +struct VkImageStencilUsageCreateInfo +{ + VkStructureType sType; + void * pNext; + VkImageUsageFlags stencilUsage; +} + +struct VkPhysicalDeviceScalarBlockLayoutFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 scalarBlockLayout; +} + +struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 uniformBufferStandardLayout; +} + +struct VkPhysicalDeviceBufferDeviceAddressFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} + +struct VkPhysicalDeviceImagelessFramebufferFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 imagelessFramebuffer; +} + +struct VkFramebufferAttachmentImageInfo +{ + VkStructureType sType; + void * pNext; + VkImageCreateFlags flags; + VkImageUsageFlags usage; + uint width; + uint height; + uint layerCount; + uint viewFormatCount; + VkFormat * pViewFormats; +} + +struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 textureCompressionASTC_HDR; +} + +struct VkPipelineCreationFeedback +{ + VkPipelineCreationFeedbackFlags flags; + ulong duration; +} + +struct VkPipelineCreationFeedbackCreateInfo +{ + VkStructureType sType; + void * pNext; + VkPipelineCreationFeedback * pPipelineCreationFeedback; + uint pipelineStageCreationFeedbackCount; + VkPipelineCreationFeedback * pPipelineStageCreationFeedbacks; +} + +struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 separateDepthStencilLayouts; +} + +struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderDemoteToHelperInvocation; +} + +struct VkPhysicalDeviceTexelBufferAlignmentProperties +{ + VkStructureType sType; + void * pNext; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; +} + +struct VkPhysicalDeviceSubgroupSizeControlFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; +} + +struct VkPhysicalDeviceSubgroupSizeControlProperties +{ + VkStructureType sType; + void * pNext; + uint minSubgroupSize; + uint maxSubgroupSize; + uint maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; +} + +struct VkPhysicalDevicePipelineCreationCacheControlFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 pipelineCreationCacheControl; +} + +struct VkPhysicalDeviceVulkan11Features +{ + VkStructureType sType; + void * pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; + VkBool32 protectedMemory; + VkBool32 samplerYcbcrConversion; + VkBool32 shaderDrawParameters; +} + +struct VkPhysicalDeviceVulkan11Properties +{ + VkStructureType sType; + void * pNext; + char[ VK_UUID_SIZE ] deviceUUID; + char[ VK_UUID_SIZE ] driverUUID; + char[ VK_LUID_SIZE ] deviceLUID; + uint deviceNodeMask; + VkBool32 deviceLUIDValid; + uint subgroupSize; + VkShaderStageFlags subgroupSupportedStages; + VkSubgroupFeatureFlags subgroupSupportedOperations; + VkBool32 subgroupQuadOperationsInAllStages; + VkPointClippingBehavior pointClippingBehavior; + uint maxMultiviewViewCount; + uint maxMultiviewInstanceIndex; + VkBool32 protectedNoFault; + uint maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} + +struct VkPhysicalDeviceVulkan12Features +{ + VkStructureType sType; + void * pNext; + VkBool32 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; +} + +struct VkPhysicalDeviceVulkan12Properties +{ + VkStructureType sType; + void * pNext; + VkDriverId driverID; + char[ VK_MAX_DRIVER_NAME_SIZE ] driverName; + char[ VK_MAX_DRIVER_INFO_SIZE ] driverInfo; + VkConformanceVersion conformanceVersion; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 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; + uint maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint maxPerStageDescriptorUpdateAfterBindSamplers; + uint maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint maxPerStageDescriptorUpdateAfterBindSampledImages; + uint maxPerStageDescriptorUpdateAfterBindStorageImages; + uint maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint maxPerStageUpdateAfterBindResources; + uint maxDescriptorSetUpdateAfterBindSamplers; + uint maxDescriptorSetUpdateAfterBindUniformBuffers; + uint maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint maxDescriptorSetUpdateAfterBindStorageBuffers; + uint maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint maxDescriptorSetUpdateAfterBindSampledImages; + uint maxDescriptorSetUpdateAfterBindStorageImages; + uint maxDescriptorSetUpdateAfterBindInputAttachments; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; + ulong maxTimelineSemaphoreValueDifference; + VkSampleCountFlags framebufferIntegerColorSampleCounts; +} + +struct VkPhysicalDeviceVulkan13Features +{ + VkStructureType sType; + void * pNext; + VkBool32 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; +} + +struct VkPhysicalDeviceVulkan13Properties +{ + VkStructureType sType; + void * pNext; + uint minSubgroupSize; + uint maxSubgroupSize; + uint maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; + uint maxInlineUniformBlockSize; + uint maxPerStageDescriptorInlineUniformBlocks; + uint maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint maxDescriptorSetInlineUniformBlocks; + uint maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + uint maxInlineUniformTotalSize; + VkBool32 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; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize maxBufferSize; +} + +struct VkPhysicalDeviceToolProperties +{ + VkStructureType sType; + void * pNext; + char[ VK_MAX_EXTENSION_NAME_SIZE ] name; + char[ VK_MAX_EXTENSION_NAME_SIZE ] version; + VkToolPurposeFlags purposes; + char[ VK_MAX_DESCRIPTION_SIZE ] description; + char[ VK_MAX_EXTENSION_NAME_SIZE ] layer; +} + +struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderZeroInitializeWorkgroupMemory; +} + +struct VkPhysicalDeviceImageRobustnessFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 robustImageAccess; +} + +struct VkBufferCopy2 +{ + VkStructureType sType; + void * pNext; + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} + +struct VkImageCopy2 +{ + VkStructureType sType; + void * pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} + +struct VkImageBlit2 +{ + VkStructureType sType; + void * pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D[2] srcOffsets; + VkImageSubresourceLayers dstSubresource; + VkOffset3D[2] dstOffsets; +} + +struct VkBufferImageCopy2 +{ + VkStructureType sType; + void * pNext; + VkDeviceSize bufferOffset; + uint bufferRowLength; + uint bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} + +struct VkImageResolve2 +{ + VkStructureType sType; + void * pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} + +struct VkCopyBufferInfo2 +{ + VkStructureType sType; + void * pNext; + VkBuffer srcBuffer; + VkBuffer dstBuffer; + uint regionCount; + VkBufferCopy2 * pRegions; +} + +struct VkCopyImageInfo2 +{ + VkStructureType sType; + void * pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint regionCount; + VkImageCopy2 * pRegions; +} + +struct VkBlitImageInfo2 +{ + VkStructureType sType; + void * pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint regionCount; + VkImageBlit2 * pRegions; + VkFilter filter; +} + +struct VkCopyBufferToImageInfo2 +{ + VkStructureType sType; + void * pNext; + VkBuffer srcBuffer; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint regionCount; + VkBufferImageCopy2 * pRegions; +} + +struct VkCopyImageToBufferInfo2 +{ + VkStructureType sType; + void * pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkBuffer dstBuffer; + uint regionCount; + VkBufferImageCopy2 * pRegions; +} + +struct VkResolveImageInfo2 +{ + VkStructureType sType; + void * pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint regionCount; + VkImageResolve2 * pRegions; +} + +struct VkPhysicalDeviceShaderTerminateInvocationFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderTerminateInvocation; +} + +struct VkMemoryBarrier2 +{ + VkStructureType sType; + void * pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; +} + +struct VkImageMemoryBarrier2 +{ + VkStructureType sType; + void * pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint srcQueueFamilyIndex; + uint dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} + +struct VkBufferMemoryBarrier2 +{ + VkStructureType sType; + void * pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + uint srcQueueFamilyIndex; + uint dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} + +struct VkDependencyInfo +{ + VkStructureType sType; + void * pNext; + VkDependencyFlags dependencyFlags; + uint memoryBarrierCount; + VkMemoryBarrier2 * pMemoryBarriers; + uint bufferMemoryBarrierCount; + VkBufferMemoryBarrier2 * pBufferMemoryBarriers; + uint imageMemoryBarrierCount; + VkImageMemoryBarrier2 * pImageMemoryBarriers; +} + +struct VkSemaphoreSubmitInfo +{ + VkStructureType sType; + void * pNext; + VkSemaphore semaphore; + ulong value; + VkPipelineStageFlags2 stageMask; + uint deviceIndex; +} + +struct VkSubmitInfo2 +{ + VkStructureType sType; + void * pNext; + VkSubmitFlags flags; + uint waitSemaphoreInfoCount; + VkSemaphoreSubmitInfo * pWaitSemaphoreInfos; + uint commandBufferInfoCount; + VkCommandBufferSubmitInfo * pCommandBufferInfos; + uint signalSemaphoreInfoCount; + VkSemaphoreSubmitInfo * pSignalSemaphoreInfos; +} + +struct VkPhysicalDeviceSynchronization2Features +{ + VkStructureType sType; + void * pNext; + VkBool32 synchronization2; +} + +struct VkPhysicalDeviceShaderIntegerDotProductFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 shaderIntegerDotProduct; +} + +struct VkPhysicalDeviceShaderIntegerDotProductProperties +{ + VkStructureType sType; + void * pNext; + VkBool32 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; +} + +struct VkFormatProperties3 +{ + VkStructureType sType; + void * pNext; + VkFormatFeatureFlags2 linearTilingFeatures; + VkFormatFeatureFlags2 optimalTilingFeatures; + VkFormatFeatureFlags2 bufferFeatures; +} + +struct VkRenderingInfo +{ + VkStructureType sType; + void * pNext; + VkRenderingFlags flags; + VkRect2D renderArea; + uint layerCount; + uint viewMask; + uint colorAttachmentCount; + VkRenderingAttachmentInfo * pColorAttachments; + VkRenderingAttachmentInfo * pDepthAttachment; + VkRenderingAttachmentInfo * pStencilAttachment; +} + +struct VkPhysicalDeviceDynamicRenderingFeatures +{ + VkStructureType sType; + void * pNext; + VkBool32 dynamicRendering; +} + +struct VkCommandBufferInheritanceRenderingInfo +{ + VkStructureType sType; + void * pNext; + VkRenderingFlags flags; + uint viewMask; + uint colorAttachmentCount; + VkFormat * pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; + VkSampleCountFlagBits rasterizationSamples; +} + +struct VkPhysicalDeviceProperties +{ + uint apiVersion; + uint driverVersion; + uint vendorID; + uint deviceID; + VkPhysicalDeviceType deviceType; + char[ VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ] deviceName; + char[ VK_UUID_SIZE ] pipelineCacheUUID; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} + +struct VkDeviceCreateInfo +{ + VkStructureType sType; + void * pNext; + VkDeviceCreateFlags flags; + uint queueCreateInfoCount; + VkDeviceQueueCreateInfo * pQueueCreateInfos; + uint enabledLayerCount; + ZString ppEnabledLayerNames; + uint enabledExtensionCount; + ZString ppEnabledExtensionNames; + VkPhysicalDeviceFeatures * pEnabledFeatures; +} + +struct VkPhysicalDeviceMemoryProperties +{ + uint memoryTypeCount; + VkMemoryType[ VK_MAX_MEMORY_TYPES ] memoryTypes; + uint memoryHeapCount; + VkMemoryHeap[ VK_MAX_MEMORY_HEAPS ] memoryHeaps; +} + +struct VkPhysicalDeviceProperties2 +{ + VkStructureType sType; + void * pNext; + VkPhysicalDeviceProperties properties; +} + +struct VkPhysicalDeviceMemoryProperties2 +{ + VkStructureType sType; + void * pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} + +struct VkFramebufferAttachmentsCreateInfo +{ + VkStructureType sType; + void * pNext; + uint attachmentImageInfoCount; + VkFramebufferAttachmentImageInfo * pAttachmentImageInfos; +} + + + +const VK_VERSION_1_0 = 1; +const VK_VERSION_1_1 = 1; +const VK_VERSION_1_2 = 1; +const VK_VERSION_1_3 = 1; + + + +fn VkResult allocateCommandBuffers (VkDevice device, VkCommandBufferAllocateInfo * pAllocateInfo, VkCommandBuffer * pCommandBuffers) @extern("vkAllocateCommandBuffers"); +fn VkResult allocateDescriptorSets (VkDevice device, VkDescriptorSetAllocateInfo * pAllocateInfo, VkDescriptorSet * pDescriptorSets) @extern("vkAllocateDescriptorSets"); +fn VkResult allocateMemory (VkDevice device, VkMemoryAllocateInfo * pAllocateInfo, VkAllocationCallbacks * pAllocator, VkDeviceMemory * pMemory) @extern("vkAllocateMemory"); +fn VkResult beginCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferBeginInfo * pBeginInfo) @extern("vkBeginCommandBuffer"); +fn VkResult bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) @extern("vkBindBufferMemory"); +fn VkResult bindBufferMemory2 (VkDevice device, uint bindInfoCount, VkBindBufferMemoryInfo * pBindInfos) @extern("vkBindBufferMemory2"); +fn VkResult bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) @extern("vkBindImageMemory"); +fn VkResult bindImageMemory2 (VkDevice device, uint bindInfoCount, VkBindImageMemoryInfo * pBindInfos) @extern("vkBindImageMemory2"); +fn void cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query, VkQueryControlFlags flags) @extern("vkCmdBeginQuery"); +fn void cmdBeginRenderPass (VkCommandBuffer commandBuffer, VkRenderPassBeginInfo * pRenderPassBegin, VkSubpassContents contents) @extern("vkCmdBeginRenderPass"); +fn void cmdBeginRenderPass2 (VkCommandBuffer commandBuffer, VkRenderPassBeginInfo * pRenderPassBegin, VkSubpassBeginInfo * pSubpassBeginInfo) @extern("vkCmdBeginRenderPass2"); +fn void cmdBeginRendering (VkCommandBuffer commandBuffer, VkRenderingInfo * pRenderingInfo) @extern("vkCmdBeginRendering"); +fn void cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint firstSet, uint descriptorSetCount, VkDescriptorSet * pDescriptorSets, uint dynamicOffsetCount, uint * pDynamicOffsets) @extern("vkCmdBindDescriptorSets"); +fn void cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) @extern("vkCmdBindIndexBuffer"); +fn void cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) @extern("vkCmdBindPipeline"); +fn void cmdBindVertexBuffers (VkCommandBuffer commandBuffer, uint firstBinding, uint bindingCount, VkBuffer * pBuffers, VkDeviceSize * pOffsets) @extern("vkCmdBindVertexBuffers"); +fn void cmdBindVertexBuffers2 (VkCommandBuffer commandBuffer, uint firstBinding, uint bindingCount, VkBuffer * pBuffers, VkDeviceSize * pOffsets, VkDeviceSize * pSizes, VkDeviceSize * pStrides) @extern("vkCmdBindVertexBuffers2"); +fn void cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageBlit * pRegions, VkFilter filter) @extern("vkCmdBlitImage"); +fn void cmdBlitImage2 (VkCommandBuffer commandBuffer, VkBlitImageInfo2 * pBlitImageInfo) @extern("vkCmdBlitImage2"); +fn void cmdClearAttachments (VkCommandBuffer commandBuffer, uint attachmentCount, VkClearAttachment * pAttachments, uint rectCount, VkClearRect * pRects) @extern("vkCmdClearAttachments"); +fn void cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearColorValue * pColor, uint rangeCount, VkImageSubresourceRange * pRanges) @extern("vkCmdClearColorImage"); +fn void cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkClearDepthStencilValue * pDepthStencil, uint rangeCount, VkImageSubresourceRange * pRanges) @extern("vkCmdClearDepthStencilImage"); +fn void cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint regionCount, VkBufferCopy * pRegions) @extern("vkCmdCopyBuffer"); +fn void cmdCopyBuffer2 (VkCommandBuffer commandBuffer, VkCopyBufferInfo2 * pCopyBufferInfo) @extern("vkCmdCopyBuffer2"); +fn void cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkBufferImageCopy * pRegions) @extern("vkCmdCopyBufferToImage"); +fn void cmdCopyBufferToImage2 (VkCommandBuffer commandBuffer, VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo) @extern("vkCmdCopyBufferToImage2"); +fn void cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageCopy * pRegions) @extern("vkCmdCopyImage"); +fn void cmdCopyImage2 (VkCommandBuffer commandBuffer, VkCopyImageInfo2 * pCopyImageInfo) @extern("vkCmdCopyImage2"); +fn void cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint regionCount, VkBufferImageCopy * pRegions) @extern("vkCmdCopyImageToBuffer"); +fn void cmdCopyImageToBuffer2 (VkCommandBuffer commandBuffer, VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo) @extern("vkCmdCopyImageToBuffer2"); +fn void cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) @extern("vkCmdCopyQueryPoolResults"); +fn void cmdDispatch (VkCommandBuffer commandBuffer, uint groupCountX, uint groupCountY, uint groupCountZ) @extern("vkCmdDispatch"); +fn void cmdDispatchBase (VkCommandBuffer commandBuffer, uint baseGroupX, uint baseGroupY, uint baseGroupZ, uint groupCountX, uint groupCountY, uint groupCountZ) @extern("vkCmdDispatchBase"); +fn void cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) @extern("vkCmdDispatchIndirect"); +fn void cmdDraw (VkCommandBuffer commandBuffer, uint vertexCount, uint instanceCount, uint firstVertex, uint firstInstance) @extern("vkCmdDraw"); +fn void cmdDrawIndexed (VkCommandBuffer commandBuffer, uint indexCount, uint instanceCount, uint firstIndex, int vertexOffset, uint firstInstance) @extern("vkCmdDrawIndexed"); +fn void cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride) @extern("vkCmdDrawIndexedIndirect"); +fn void cmdDrawIndexedIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint maxDrawCount, uint stride) @extern("vkCmdDrawIndexedIndirectCount"); +fn void cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint drawCount, uint stride) @extern("vkCmdDrawIndirect"); +fn void cmdDrawIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint maxDrawCount, uint stride) @extern("vkCmdDrawIndirectCount"); +fn void cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint query) @extern("vkCmdEndQuery"); +fn void cmdEndRenderPass (VkCommandBuffer commandBuffer) @extern("vkCmdEndRenderPass"); +fn void cmdEndRenderPass2 (VkCommandBuffer commandBuffer, VkSubpassEndInfo * pSubpassEndInfo) @extern("vkCmdEndRenderPass2"); +fn void cmdEndRendering (VkCommandBuffer commandBuffer) @extern("vkCmdEndRendering"); +fn void cmdExecuteCommands (VkCommandBuffer commandBuffer, uint commandBufferCount, VkCommandBuffer * pCommandBuffers) @extern("vkCmdExecuteCommands"); +fn void cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint data) @extern("vkCmdFillBuffer"); +fn void cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents) @extern("vkCmdNextSubpass"); +fn void cmdNextSubpass2 (VkCommandBuffer commandBuffer, VkSubpassBeginInfo * pSubpassBeginInfo, VkSubpassEndInfo * pSubpassEndInfo) @extern("vkCmdNextSubpass2"); +fn void cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint memoryBarrierCount, VkMemoryBarrier * pMemoryBarriers, uint bufferMemoryBarrierCount, VkBufferMemoryBarrier * pBufferMemoryBarriers, uint imageMemoryBarrierCount, VkImageMemoryBarrier * pImageMemoryBarriers) @extern("vkCmdPipelineBarrier"); +fn void cmdPipelineBarrier2 (VkCommandBuffer commandBuffer, VkDependencyInfo * pDependencyInfo) @extern("vkCmdPipelineBarrier2"); +fn void cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint offset, uint size, void * pValues) @extern("vkCmdPushConstants"); +fn void cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) @extern("vkCmdResetEvent"); +fn void cmdResetEvent2 (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) @extern("vkCmdResetEvent2"); +fn void cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint firstQuery, uint queryCount) @extern("vkCmdResetQueryPool"); +fn void cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint regionCount, VkImageResolve * pRegions) @extern("vkCmdResolveImage"); +fn void cmdResolveImage2 (VkCommandBuffer commandBuffer, VkResolveImageInfo2 * pResolveImageInfo) @extern("vkCmdResolveImage2"); +fn void cmdSetBlendConstants (VkCommandBuffer commandBuffer, float[4] blendConstants) @extern("vkCmdSetBlendConstants"); +fn void cmdSetCullMode (VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) @extern("vkCmdSetCullMode"); +fn void cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) @extern("vkCmdSetDepthBias"); +fn void cmdSetDepthBiasEnable (VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) @extern("vkCmdSetDepthBiasEnable"); +fn void cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) @extern("vkCmdSetDepthBounds"); +fn void cmdSetDepthBoundsTestEnable (VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) @extern("vkCmdSetDepthBoundsTestEnable"); +fn void cmdSetDepthCompareOp (VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) @extern("vkCmdSetDepthCompareOp"); +fn void cmdSetDepthTestEnable (VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) @extern("vkCmdSetDepthTestEnable"); +fn void cmdSetDepthWriteEnable (VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) @extern("vkCmdSetDepthWriteEnable"); +fn void cmdSetDeviceMask (VkCommandBuffer commandBuffer, uint deviceMask) @extern("vkCmdSetDeviceMask"); +fn void cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) @extern("vkCmdSetEvent"); +fn void cmdSetEvent2 (VkCommandBuffer commandBuffer, VkEvent event, VkDependencyInfo * pDependencyInfo) @extern("vkCmdSetEvent2"); +fn void cmdSetFrontFace (VkCommandBuffer commandBuffer, VkFrontFace frontFace) @extern("vkCmdSetFrontFace"); +fn void cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth) @extern("vkCmdSetLineWidth"); +fn void cmdSetPrimitiveRestartEnable (VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) @extern("vkCmdSetPrimitiveRestartEnable"); +fn void cmdSetPrimitiveTopology (VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) @extern("vkCmdSetPrimitiveTopology"); +fn void cmdSetRasterizerDiscardEnable (VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) @extern("vkCmdSetRasterizerDiscardEnable"); +fn void cmdSetScissor (VkCommandBuffer commandBuffer, uint firstScissor, uint scissorCount, VkRect2D * pScissors) @extern("vkCmdSetScissor"); +fn void cmdSetScissorWithCount (VkCommandBuffer commandBuffer, uint scissorCount, VkRect2D * pScissors) @extern("vkCmdSetScissorWithCount"); +fn void cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint compareMask) @extern("vkCmdSetStencilCompareMask"); +fn void cmdSetStencilOp (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) @extern("vkCmdSetStencilOp"); +fn void cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint reference) @extern("vkCmdSetStencilReference"); +fn void cmdSetStencilTestEnable (VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) @extern("vkCmdSetStencilTestEnable"); +fn void cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint writeMask) @extern("vkCmdSetStencilWriteMask"); +fn void cmdSetViewport (VkCommandBuffer commandBuffer, uint firstViewport, uint viewportCount, VkViewport * pViewports) @extern("vkCmdSetViewport"); +fn void cmdSetViewportWithCount (VkCommandBuffer commandBuffer, uint viewportCount, VkViewport * pViewports) @extern("vkCmdSetViewportWithCount"); +fn void cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, void * pData) @extern("vkCmdUpdateBuffer"); +fn void cmdWaitEvents (VkCommandBuffer commandBuffer, uint eventCount, VkEvent * pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint memoryBarrierCount, VkMemoryBarrier * pMemoryBarriers, uint bufferMemoryBarrierCount, VkBufferMemoryBarrier * pBufferMemoryBarriers, uint imageMemoryBarrierCount, VkImageMemoryBarrier * pImageMemoryBarriers) @extern("vkCmdWaitEvents"); +fn void cmdWaitEvents2 (VkCommandBuffer commandBuffer, uint eventCount, VkEvent * pEvents, VkDependencyInfo * pDependencyInfos) @extern("vkCmdWaitEvents2"); +fn void cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint query) @extern("vkCmdWriteTimestamp"); +fn void cmdWriteTimestamp2 (VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint query) @extern("vkCmdWriteTimestamp2"); +fn VkResult createBuffer (VkDevice device, VkBufferCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkBuffer * pBuffer) @extern("vkCreateBuffer"); +fn VkResult createBufferView (VkDevice device, VkBufferViewCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkBufferView * pView) @extern("vkCreateBufferView"); +fn VkResult createCommandPool (VkDevice device, VkCommandPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkCommandPool * pCommandPool) @extern("vkCreateCommandPool"); +fn VkResult createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkComputePipelineCreateInfo * pCreateInfos, VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines) @extern("vkCreateComputePipelines"); +fn VkResult createDescriptorPool (VkDevice device, VkDescriptorPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorPool * pDescriptorPool) @extern("vkCreateDescriptorPool"); +fn VkResult createDescriptorSetLayout (VkDevice device, VkDescriptorSetLayoutCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorSetLayout * pSetLayout) @extern("vkCreateDescriptorSetLayout"); +fn VkResult createDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate) @extern("vkCreateDescriptorUpdateTemplate"); +fn VkResult createDevice (VkPhysicalDevice physicalDevice, VkDeviceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkDevice * pDevice) @extern("vkCreateDevice"); +fn VkResult createEvent (VkDevice device, VkEventCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkEvent * pEvent) @extern("vkCreateEvent"); +fn VkResult createFence (VkDevice device, VkFenceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkFence * pFence) @extern("vkCreateFence"); +fn VkResult createFramebuffer (VkDevice device, VkFramebufferCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkFramebuffer * pFramebuffer) @extern("vkCreateFramebuffer"); +fn VkResult createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, uint createInfoCount, VkGraphicsPipelineCreateInfo * pCreateInfos, VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines) @extern("vkCreateGraphicsPipelines"); +fn VkResult createImage (VkDevice device, VkImageCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkImage * pImage) @extern("vkCreateImage"); +fn VkResult createImageView (VkDevice device, VkImageViewCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkImageView * pView) @extern("vkCreateImageView"); +fn VkResult createInstance (VkInstanceCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkInstance * pInstance) @extern("vkCreateInstance"); +fn VkResult createPipelineCache (VkDevice device, VkPipelineCacheCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkPipelineCache * pPipelineCache) @extern("vkCreatePipelineCache"); +fn VkResult createPipelineLayout (VkDevice device, VkPipelineLayoutCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkPipelineLayout * pPipelineLayout) @extern("vkCreatePipelineLayout"); +fn VkResult createPrivateDataSlot (VkDevice device, VkPrivateDataSlotCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkPrivateDataSlot * pPrivateDataSlot) @extern("vkCreatePrivateDataSlot"); +fn VkResult createQueryPool (VkDevice device, VkQueryPoolCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkQueryPool * pQueryPool) @extern("vkCreateQueryPool"); +fn VkResult createRenderPass (VkDevice device, VkRenderPassCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass) @extern("vkCreateRenderPass"); +fn VkResult createRenderPass2 (VkDevice device, VkRenderPassCreateInfo2 * pCreateInfo, VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass) @extern("vkCreateRenderPass2"); +fn VkResult createSampler (VkDevice device, VkSamplerCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSampler * pSampler) @extern("vkCreateSampler"); +fn VkResult createSamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversionCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSamplerYcbcrConversion * pYcbcrConversion) @extern("vkCreateSamplerYcbcrConversion"); +fn VkResult createSemaphore (VkDevice device, VkSemaphoreCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkSemaphore * pSemaphore) @extern("vkCreateSemaphore"); +fn VkResult createShaderModule (VkDevice device, VkShaderModuleCreateInfo * pCreateInfo, VkAllocationCallbacks * pAllocator, VkShaderModule * pShaderModule) @extern("vkCreateShaderModule"); +fn void destroyBuffer (VkDevice device, VkBuffer buffer, VkAllocationCallbacks * pAllocator) @extern("vkDestroyBuffer"); +fn void destroyBufferView (VkDevice device, VkBufferView bufferView, VkAllocationCallbacks * pAllocator) @extern("vkDestroyBufferView"); +fn void destroyCommandPool (VkDevice device, VkCommandPool commandPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyCommandPool"); +fn void destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorPool"); +fn void destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorSetLayout"); +fn void destroyDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDescriptorUpdateTemplate"); +fn void destroyDevice (VkDevice device, VkAllocationCallbacks * pAllocator) @extern("vkDestroyDevice"); +fn void destroyEvent (VkDevice device, VkEvent event, VkAllocationCallbacks * pAllocator) @extern("vkDestroyEvent"); +fn void destroyFence (VkDevice device, VkFence fence, VkAllocationCallbacks * pAllocator) @extern("vkDestroyFence"); +fn void destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, VkAllocationCallbacks * pAllocator) @extern("vkDestroyFramebuffer"); +fn void destroyImage (VkDevice device, VkImage image, VkAllocationCallbacks * pAllocator) @extern("vkDestroyImage"); +fn void destroyImageView (VkDevice device, VkImageView imageView, VkAllocationCallbacks * pAllocator) @extern("vkDestroyImageView"); +fn void destroyInstance (VkInstance instance, VkAllocationCallbacks * pAllocator) @extern("vkDestroyInstance"); +fn void destroyPipeline (VkDevice device, VkPipeline pipeline, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipeline"); +fn void destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipelineCache"); +fn void destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPipelineLayout"); +fn void destroyPrivateDataSlot (VkDevice device, VkPrivateDataSlot privateDataSlot, VkAllocationCallbacks * pAllocator) @extern("vkDestroyPrivateDataSlot"); +fn void destroyQueryPool (VkDevice device, VkQueryPool queryPool, VkAllocationCallbacks * pAllocator) @extern("vkDestroyQueryPool"); +fn void destroyRenderPass (VkDevice device, VkRenderPass renderPass, VkAllocationCallbacks * pAllocator) @extern("vkDestroyRenderPass"); +fn void destroySampler (VkDevice device, VkSampler sampler, VkAllocationCallbacks * pAllocator) @extern("vkDestroySampler"); +fn void destroySamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, VkAllocationCallbacks * pAllocator) @extern("vkDestroySamplerYcbcrConversion"); +fn void destroySemaphore (VkDevice device, VkSemaphore semaphore, VkAllocationCallbacks * pAllocator) @extern("vkDestroySemaphore"); +fn void destroyShaderModule (VkDevice device, VkShaderModule shaderModule, VkAllocationCallbacks * pAllocator) @extern("vkDestroyShaderModule"); +fn VkResult deviceWaitIdle (VkDevice device) @extern("vkDeviceWaitIdle"); +fn VkResult endCommandBuffer (VkCommandBuffer commandBuffer) @extern("vkEndCommandBuffer"); +fn VkResult enumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, ZString pLayerName, uint * pPropertyCount, VkExtensionProperties * pProperties) @extern("vkEnumerateDeviceExtensionProperties"); +fn VkResult enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, uint * pPropertyCount, VkLayerProperties * pProperties) @extern("vkEnumerateDeviceLayerProperties"); +fn VkResult enumerateInstanceExtensionProperties (ZString pLayerName, uint * pPropertyCount, VkExtensionProperties * pProperties) @extern("vkEnumerateInstanceExtensionProperties"); +fn VkResult enumerateInstanceLayerProperties (uint * pPropertyCount, VkLayerProperties * pProperties) @extern("vkEnumerateInstanceLayerProperties"); +fn VkResult enumerateInstanceVersion (uint * pApiVersion) @extern("vkEnumerateInstanceVersion"); +fn VkResult enumeratePhysicalDeviceGroups (VkInstance instance, uint * pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties) @extern("vkEnumeratePhysicalDeviceGroups"); +fn VkResult enumeratePhysicalDevices (VkInstance instance, uint * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices) @extern("vkEnumeratePhysicalDevices"); +fn VkResult flushMappedMemoryRanges (VkDevice device, uint memoryRangeCount, VkMappedMemoryRange * pMemoryRanges) @extern("vkFlushMappedMemoryRanges"); +fn void freeCommandBuffers (VkDevice device, VkCommandPool commandPool, uint commandBufferCount, VkCommandBuffer * pCommandBuffers) @extern("vkFreeCommandBuffers"); +fn VkResult freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, uint descriptorSetCount, VkDescriptorSet * pDescriptorSets) @extern("vkFreeDescriptorSets"); +fn void freeMemory (VkDevice device, VkDeviceMemory memory, VkAllocationCallbacks * pAllocator) @extern("vkFreeMemory"); +fn VkDeviceAddress getBufferDeviceAddress (VkDevice device, VkBufferDeviceAddressInfo * pInfo) @extern("vkGetBufferDeviceAddress"); +fn void getBufferMemoryRequirements (VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements) @extern("vkGetBufferMemoryRequirements"); +fn void getBufferMemoryRequirements2 (VkDevice device, VkBufferMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements) @extern("vkGetBufferMemoryRequirements2"); +fn ulong getBufferOpaqueCaptureAddress (VkDevice device, VkBufferDeviceAddressInfo * pInfo) @extern("vkGetBufferOpaqueCaptureAddress"); +fn void getDescriptorSetLayoutSupport (VkDevice device, VkDescriptorSetLayoutCreateInfo * pCreateInfo, VkDescriptorSetLayoutSupport * pSupport) @extern("vkGetDescriptorSetLayoutSupport"); +fn void getDeviceBufferMemoryRequirements (VkDevice device, VkDeviceBufferMemoryRequirements * pInfo, VkMemoryRequirements2 * pMemoryRequirements) @extern("vkGetDeviceBufferMemoryRequirements"); +fn void getDeviceGroupPeerMemoryFeatures (VkDevice device, uint heapIndex, uint localDeviceIndex, uint remoteDeviceIndex, VkPeerMemoryFeatureFlags * pPeerMemoryFeatures) @extern("vkGetDeviceGroupPeerMemoryFeatures"); +fn void getDeviceImageMemoryRequirements (VkDevice device, VkDeviceImageMemoryRequirements * pInfo, VkMemoryRequirements2 * pMemoryRequirements) @extern("vkGetDeviceImageMemoryRequirements"); +fn void getDeviceImageSparseMemoryRequirements (VkDevice device, VkDeviceImageMemoryRequirements * pInfo, uint * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements) @extern("vkGetDeviceImageSparseMemoryRequirements"); +fn void getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes) @extern("vkGetDeviceMemoryCommitment"); +fn ulong getDeviceMemoryOpaqueCaptureAddress (VkDevice device, VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo) @extern("vkGetDeviceMemoryOpaqueCaptureAddress"); +fn PFN_vkVoidFunction getDeviceProcAddr (VkDevice device, ZString pName) @extern("vkGetDeviceProcAddr"); +fn void getDeviceQueue (VkDevice device, uint queueFamilyIndex, uint queueIndex, VkQueue * pQueue) @extern("vkGetDeviceQueue"); +fn void getDeviceQueue2 (VkDevice device, VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue) @extern("vkGetDeviceQueue2"); +fn VkResult getEventStatus (VkDevice device, VkEvent event) @extern("vkGetEventStatus"); +fn VkResult getFenceStatus (VkDevice device, VkFence fence) @extern("vkGetFenceStatus"); +fn void getImageMemoryRequirements (VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements) @extern("vkGetImageMemoryRequirements"); +fn void getImageMemoryRequirements2 (VkDevice device, VkImageMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements) @extern("vkGetImageMemoryRequirements2"); +fn void getImageSparseMemoryRequirements (VkDevice device, VkImage image, uint * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements * pSparseMemoryRequirements) @extern("vkGetImageSparseMemoryRequirements"); +fn void getImageSparseMemoryRequirements2 (VkDevice device, VkImageSparseMemoryRequirementsInfo2 * pInfo, uint * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements) @extern("vkGetImageSparseMemoryRequirements2"); +fn void getImageSubresourceLayout (VkDevice device, VkImage image, VkImageSubresource * pSubresource, VkSubresourceLayout * pLayout) @extern("vkGetImageSubresourceLayout"); +fn PFN_vkVoidFunction getInstanceProcAddr (VkInstance instance, ZString pName) @extern("vkGetInstanceProcAddr"); +fn void getPhysicalDeviceExternalBufferProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VkExternalBufferProperties * pExternalBufferProperties) @extern("vkGetPhysicalDeviceExternalBufferProperties"); +fn void getPhysicalDeviceExternalFenceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VkExternalFenceProperties * pExternalFenceProperties) @extern("vkGetPhysicalDeviceExternalFenceProperties"); +fn void getPhysicalDeviceExternalSemaphoreProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VkExternalSemaphoreProperties * pExternalSemaphoreProperties) @extern("vkGetPhysicalDeviceExternalSemaphoreProperties"); +fn void getPhysicalDeviceFeatures (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures) @extern("vkGetPhysicalDeviceFeatures"); +fn void getPhysicalDeviceFeatures2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures) @extern("vkGetPhysicalDeviceFeatures2"); +fn void getPhysicalDeviceFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties) @extern("vkGetPhysicalDeviceFormatProperties"); +fn void getPhysicalDeviceFormatProperties2 (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 * pFormatProperties) @extern("vkGetPhysicalDeviceFormatProperties2"); +fn VkResult getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties * pImageFormatProperties) @extern("vkGetPhysicalDeviceImageFormatProperties"); +fn VkResult getPhysicalDeviceImageFormatProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VkImageFormatProperties2 * pImageFormatProperties) @extern("vkGetPhysicalDeviceImageFormatProperties2"); +fn void getPhysicalDeviceMemoryProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties) @extern("vkGetPhysicalDeviceMemoryProperties"); +fn void getPhysicalDeviceMemoryProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 * pMemoryProperties) @extern("vkGetPhysicalDeviceMemoryProperties2"); +fn void getPhysicalDeviceProperties (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties) @extern("vkGetPhysicalDeviceProperties"); +fn void getPhysicalDeviceProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties) @extern("vkGetPhysicalDeviceProperties2"); +fn void getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice physicalDevice, uint * pQueueFamilyPropertyCount, VkQueueFamilyProperties * pQueueFamilyProperties) @extern("vkGetPhysicalDeviceQueueFamilyProperties"); +fn void getPhysicalDeviceQueueFamilyProperties2 (VkPhysicalDevice physicalDevice, uint * pQueueFamilyPropertyCount, VkQueueFamilyProperties2 * pQueueFamilyProperties) @extern("vkGetPhysicalDeviceQueueFamilyProperties2"); +fn void getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint * pPropertyCount, VkSparseImageFormatProperties * pProperties) @extern("vkGetPhysicalDeviceSparseImageFormatProperties"); +fn void getPhysicalDeviceSparseImageFormatProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, uint * pPropertyCount, VkSparseImageFormatProperties2 * pProperties) @extern("vkGetPhysicalDeviceSparseImageFormatProperties2"); +fn VkResult getPhysicalDeviceToolProperties (VkPhysicalDevice physicalDevice, uint * pToolCount, VkPhysicalDeviceToolProperties * pToolProperties) @extern("vkGetPhysicalDeviceToolProperties"); +fn VkResult getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, usz * pDataSize, void * pData) @extern("vkGetPipelineCacheData"); +fn void getPrivateData (VkDevice device, VkObjectType objectType, ulong objectHandle, VkPrivateDataSlot privateDataSlot, ulong * pData) @extern("vkGetPrivateData"); +fn VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, uint firstQuery, uint queryCount, usz dataSize, void * pData, VkDeviceSize stride, VkQueryResultFlags flags) @extern("vkGetQueryPoolResults"); +fn void getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity) @extern("vkGetRenderAreaGranularity"); +fn VkResult getSemaphoreCounterValue (VkDevice device, VkSemaphore semaphore, ulong * pValue) @extern("vkGetSemaphoreCounterValue"); +fn VkResult invalidateMappedMemoryRanges (VkDevice device, uint memoryRangeCount, VkMappedMemoryRange * pMemoryRanges) @extern("vkInvalidateMappedMemoryRanges"); +fn VkResult mapMemory (VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData) @extern("vkMapMemory"); +fn VkResult mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, uint srcCacheCount, VkPipelineCache * pSrcCaches) @extern("vkMergePipelineCaches"); +fn VkResult queueBindSparse (VkQueue queue, uint bindInfoCount, VkBindSparseInfo * pBindInfo, VkFence fence) @extern("vkQueueBindSparse"); +fn VkResult queueSubmit (VkQueue queue, uint submitCount, VkSubmitInfo * pSubmits, VkFence fence) @extern("vkQueueSubmit"); +fn VkResult queueSubmit2 (VkQueue queue, uint submitCount, VkSubmitInfo2 * pSubmits, VkFence fence) @extern("vkQueueSubmit2"); +fn VkResult queueWaitIdle (VkQueue queue) @extern("vkQueueWaitIdle"); +fn VkResult resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) @extern("vkResetCommandBuffer"); +fn VkResult resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) @extern("vkResetCommandPool"); +fn VkResult resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) @extern("vkResetDescriptorPool"); +fn VkResult resetEvent (VkDevice device, VkEvent event) @extern("vkResetEvent"); +fn VkResult resetFences (VkDevice device, uint fenceCount, VkFence * pFences) @extern("vkResetFences"); +fn void resetQueryPool (VkDevice device, VkQueryPool queryPool, uint firstQuery, uint queryCount) @extern("vkResetQueryPool"); +fn VkResult setEvent (VkDevice device, VkEvent event) @extern("vkSetEvent"); +fn VkResult setPrivateData (VkDevice device, VkObjectType objectType, ulong objectHandle, VkPrivateDataSlot privateDataSlot, ulong data) @extern("vkSetPrivateData"); +fn VkResult signalSemaphore (VkDevice device, VkSemaphoreSignalInfo * pSignalInfo) @extern("vkSignalSemaphore"); +fn void trimCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) @extern("vkTrimCommandPool"); +fn void unmapMemory (VkDevice device, VkDeviceMemory memory) @extern("vkUnmapMemory"); +fn void updateDescriptorSetWithTemplate (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, void * pData) @extern("vkUpdateDescriptorSetWithTemplate"); +fn void updateDescriptorSets (VkDevice device, uint descriptorWriteCount, VkWriteDescriptorSet * pDescriptorWrites, uint descriptorCopyCount, VkCopyDescriptorSet * pDescriptorCopies) @extern("vkUpdateDescriptorSets"); +fn VkResult waitForFences (VkDevice device, uint fenceCount, VkFence * pFences, VkBool32 waitAll, ulong timeout) @extern("vkWaitForFences"); +fn VkResult waitSemaphores (VkDevice device, VkSemaphoreWaitInfo * pWaitInfo, ulong timeout) @extern("vkWaitSemaphores"); diff --git a/libraries/vulkan.c3l/vulkan.c3i b/libraries/vulkan.c3l/vulkan.c3i new file mode 100644 index 0000000..beef72c --- /dev/null +++ b/libraries/vulkan.c3l/vulkan.c3i @@ -0,0 +1,31 @@ +module vulkan; + +const VK_MAX_VERSION = vk::@make_api_version(0, 1, 3, 0); + +module vulkan::internal; +import vulkan; +macro int vk_version() +{ + $if($defined(vulkan::VK_VERSION)): + + return vulkan::VK_VERSION; + $else + return vulkan::VK_MAX_VERSION; + $endif +} + +module vulkan::vk; + +macro int @make_version($major, $minor, $patch) +{ + return (($major << 22U) | ($minor << 12U) | $patch); +} +macro int @make_api_version($variant, $major, $minor, $patch) +{ + return (($variant << 29U) | ($major << 22U) | ($minor << 12U) | $patch); +} + +const VK_API_VERSION_1_0 = @make_api_version(0, 1, 0, 0); +const VK_API_VERSION_1_1 = @make_api_version(0, 1, 1, 0); +const VK_API_VERSION_1_2 = @make_api_version(0, 1, 2, 0); +const VK_API_VERSION_1_3 = @make_api_version(0, 1, 3, 0);