From 7f30e22a05fd9c228cf1172b4129b5bbce6baebe Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Wed, 6 Sep 2017 17:10:25 -0400 Subject: [PATCH] Basic Vulkan header hookup and automation --- .gitignore | 7 + Cargo.toml | 12 + Makefile | 23 + native/test.c | 31 + src/lib.rs | 7815 +++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 7888 insertions(+) create mode 100644 .gitignore create mode 100644 Cargo.toml create mode 100644 Makefile create mode 100644 native/test.c create mode 100644 src/lib.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..87ec7b9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +/target/ +native/test +native/test.o +native/vulkan +src/original.rs +**/*.rs.bk +Cargo.lock diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..9ab61c6 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "portability" +version = "0.1.0" +authors = ["Dzmitry Malyshau "] + +[lib] +name = "vulkan" +crate-type = ["dylib"] + +[dependencies] +gfx_core = { path = "../gfx/src/core" } +gfx_backend_vulkan = { path = "../gfx/src/backend/vulkan" } diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..5fd9592 --- /dev/null +++ b/Makefile @@ -0,0 +1,23 @@ +HEADER=native/vulkan/vulkan.h +BINDING=src/original.rs +TARGET=native/test +OBJECTS=native/test.o +OUTPUT_DIR=target/debug +OUTPUT=${OUTPUT_DIR}/libvulkan.a + +all: ${TARGET} + +${BINDING}: ${HEADER} + bindgen --no-layout-tests --rustfmt-bindings ${HEADER} -o ${BINDING} + +portability: ${BINDING} + cargo build + +${TARGET}: portability ${OBJECTS} + gcc -o ${TARGET} -L${OUTPUT_DIR} -lvulkan ${OBJECTS} + +run: ${TARGET} + ${TARGET} + +clean: + rm -f ${OBJECTS} ${TARGET} ${BINDING} diff --git a/native/test.c b/native/test.c new file mode 100644 index 0000000..3a01c94 --- /dev/null +++ b/native/test.c @@ -0,0 +1,31 @@ +#include "vulkan/vulkan.h" +#include +#include + +int main() { + VkInstanceCreateInfo inst_info = {}; + inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + inst_info.pNext = NULL; + inst_info.flags = 0; + inst_info.pApplicationInfo = NULL; + inst_info.enabledExtensionCount = 0; + inst_info.ppEnabledExtensionNames = NULL; + inst_info.enabledLayerCount = 0; + inst_info.ppEnabledLayerNames = NULL; + + VkInstance inst; + VkResult res; + + res = vkCreateInstance(&inst_info, NULL, &inst); + if (res == VK_ERROR_INCOMPATIBLE_DRIVER) { + printf("cannot find a compatible Vulkan ICD\n"); + exit(-1); + } else if (res) { + printf("unknown error\n"); + exit(-1); + } + + vkDestroyInstance(inst, NULL); + + return 0; +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..c3f43d4 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,7815 @@ +#![allow(non_snake_case)] +#![allow(non_camel_case_types)] +#![allow(non_upper_case_globals)] + +extern crate gfx_core as core; +extern crate gfx_backend_vulkan as back; + +/* automatically generated by rust-bindgen */ + +pub const VULKAN_H_: ::std::os::raw::c_uint = 1; +pub const VK_VERSION_1_0: ::std::os::raw::c_uint = 1; +pub const _STDINT_H: ::std::os::raw::c_uint = 1; +pub const _FEATURES_H: ::std::os::raw::c_uint = 1; +pub const _DEFAULT_SOURCE: ::std::os::raw::c_uint = 1; +pub const __USE_ISOC11: ::std::os::raw::c_uint = 1; +pub const __USE_ISOC99: ::std::os::raw::c_uint = 1; +pub const __USE_ISOC95: ::std::os::raw::c_uint = 1; +pub const __USE_POSIX_IMPLICITLY: ::std::os::raw::c_uint = 1; +pub const _POSIX_SOURCE: ::std::os::raw::c_uint = 1; +pub const _POSIX_C_SOURCE: ::std::os::raw::c_uint = 200809; +pub const __USE_POSIX: ::std::os::raw::c_uint = 1; +pub const __USE_POSIX2: ::std::os::raw::c_uint = 1; +pub const __USE_POSIX199309: ::std::os::raw::c_uint = 1; +pub const __USE_POSIX199506: ::std::os::raw::c_uint = 1; +pub const __USE_XOPEN2K: ::std::os::raw::c_uint = 1; +pub const __USE_XOPEN2K8: ::std::os::raw::c_uint = 1; +pub const _ATFILE_SOURCE: ::std::os::raw::c_uint = 1; +pub const __USE_MISC: ::std::os::raw::c_uint = 1; +pub const __USE_ATFILE: ::std::os::raw::c_uint = 1; +pub const __USE_FORTIFY_LEVEL: ::std::os::raw::c_uint = 0; +pub const _STDC_PREDEF_H: ::std::os::raw::c_uint = 1; +pub const __STDC_IEC_559__: ::std::os::raw::c_uint = 1; +pub const __STDC_IEC_559_COMPLEX__: ::std::os::raw::c_uint = 1; +pub const __STDC_ISO_10646__: ::std::os::raw::c_uint = 201605; +pub const __STDC_NO_THREADS__: ::std::os::raw::c_uint = 1; +pub const __GNU_LIBRARY__: ::std::os::raw::c_uint = 6; +pub const __GLIBC__: ::std::os::raw::c_uint = 2; +pub const __GLIBC_MINOR__: ::std::os::raw::c_uint = 25; +pub const _SYS_CDEFS_H: ::std::os::raw::c_uint = 1; +pub const __glibc_c99_flexarr_available: ::std::os::raw::c_uint = 1; +pub const __WORDSIZE: ::std::os::raw::c_uint = 64; +pub const __WORDSIZE_TIME64_COMPAT32: ::std::os::raw::c_uint = 1; +pub const __SYSCALL_WORDSIZE: ::std::os::raw::c_uint = 64; +pub const __GLIBC_USE_LIB_EXT2: ::std::os::raw::c_uint = 0; +pub const __GLIBC_USE_IEC_60559_BFP_EXT: ::std::os::raw::c_uint = 0; +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: ::std::os::raw::c_uint = 0; +pub const _BITS_TYPES_H: ::std::os::raw::c_uint = 1; +pub const _BITS_TYPESIZES_H: ::std::os::raw::c_uint = 1; +pub const __OFF_T_MATCHES_OFF64_T: ::std::os::raw::c_uint = 1; +pub const __INO_T_MATCHES_INO64_T: ::std::os::raw::c_uint = 1; +pub const __RLIM_T_MATCHES_RLIM64_T: ::std::os::raw::c_uint = 1; +pub const __FD_SETSIZE: ::std::os::raw::c_uint = 1024; +pub const _BITS_WCHAR_H: ::std::os::raw::c_uint = 1; +pub const INT8_MIN: ::std::os::raw::c_int = -128; +pub const INT16_MIN: ::std::os::raw::c_int = -32768; +pub const INT32_MIN: ::std::os::raw::c_int = -2147483648; +pub const INT8_MAX: ::std::os::raw::c_uint = 127; +pub const INT16_MAX: ::std::os::raw::c_uint = 32767; +pub const INT32_MAX: ::std::os::raw::c_uint = 2147483647; +pub const UINT8_MAX: ::std::os::raw::c_uint = 255; +pub const UINT16_MAX: ::std::os::raw::c_uint = 65535; +pub const UINT32_MAX: ::std::os::raw::c_uint = 4294967295; +pub const INT_LEAST8_MIN: ::std::os::raw::c_int = -128; +pub const INT_LEAST16_MIN: ::std::os::raw::c_int = -32768; +pub const INT_LEAST32_MIN: ::std::os::raw::c_int = -2147483648; +pub const INT_LEAST8_MAX: ::std::os::raw::c_uint = 127; +pub const INT_LEAST16_MAX: ::std::os::raw::c_uint = 32767; +pub const INT_LEAST32_MAX: ::std::os::raw::c_uint = 2147483647; +pub const UINT_LEAST8_MAX: ::std::os::raw::c_uint = 255; +pub const UINT_LEAST16_MAX: ::std::os::raw::c_uint = 65535; +pub const UINT_LEAST32_MAX: ::std::os::raw::c_uint = 4294967295; +pub const INT_FAST8_MIN: ::std::os::raw::c_int = -128; +pub const INT_FAST16_MIN: ::std::os::raw::c_longlong = -9223372036854775808; +pub const INT_FAST32_MIN: ::std::os::raw::c_longlong = -9223372036854775808; +pub const INT_FAST8_MAX: ::std::os::raw::c_uint = 127; +pub const INT_FAST16_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807; +pub const INT_FAST32_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807; +pub const UINT_FAST8_MAX: ::std::os::raw::c_uint = 255; +pub const UINT_FAST16_MAX: ::std::os::raw::c_int = -1; +pub const UINT_FAST32_MAX: ::std::os::raw::c_int = -1; +pub const INTPTR_MIN: ::std::os::raw::c_longlong = -9223372036854775808; +pub const INTPTR_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807; +pub const UINTPTR_MAX: ::std::os::raw::c_int = -1; +pub const PTRDIFF_MIN: ::std::os::raw::c_longlong = -9223372036854775808; +pub const PTRDIFF_MAX: ::std::os::raw::c_ulonglong = 9223372036854775807; +pub const SIG_ATOMIC_MIN: ::std::os::raw::c_int = -2147483648; +pub const SIG_ATOMIC_MAX: ::std::os::raw::c_uint = 2147483647; +pub const SIZE_MAX: ::std::os::raw::c_int = -1; +pub const WINT_MIN: ::std::os::raw::c_uint = 0; +pub const WINT_MAX: ::std::os::raw::c_uint = 4294967295; +pub const VK_HEADER_VERSION: ::std::os::raw::c_uint = 42; +pub const VK_NULL_HANDLE: ::std::os::raw::c_uint = 0; +pub const VK_LOD_CLAMP_NONE: f64 = 1000.; +pub const VK_REMAINING_MIP_LEVELS: ::std::os::raw::c_int = -1; +pub const VK_REMAINING_ARRAY_LAYERS: ::std::os::raw::c_int = -1; +pub const VK_WHOLE_SIZE: ::std::os::raw::c_int = -1; +pub const VK_ATTACHMENT_UNUSED: ::std::os::raw::c_int = -1; +pub const VK_TRUE: ::std::os::raw::c_uint = 1; +pub const VK_FALSE: ::std::os::raw::c_uint = 0; +pub const VK_QUEUE_FAMILY_IGNORED: ::std::os::raw::c_int = -1; +pub const VK_SUBPASS_EXTERNAL: ::std::os::raw::c_int = -1; +pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: ::std::os::raw::c_uint = 256; +pub const VK_UUID_SIZE: ::std::os::raw::c_uint = 16; +pub const VK_MAX_MEMORY_TYPES: ::std::os::raw::c_uint = 32; +pub const VK_MAX_MEMORY_HEAPS: ::std::os::raw::c_uint = 16; +pub const VK_MAX_EXTENSION_NAME_SIZE: ::std::os::raw::c_uint = 256; +pub const VK_MAX_DESCRIPTION_SIZE: ::std::os::raw::c_uint = 256; +pub const VK_KHR_surface: ::std::os::raw::c_uint = 1; +pub const VK_KHR_SURFACE_SPEC_VERSION: ::std::os::raw::c_uint = 25; +pub const VK_KHR_SURFACE_EXTENSION_NAME: &'static [u8; 15usize] = + b"VK_KHR_surface\x00"; +pub const VK_KHR_swapchain: ::std::os::raw::c_uint = 1; +pub const VK_KHR_SWAPCHAIN_SPEC_VERSION: ::std::os::raw::c_uint = 68; +pub const VK_KHR_SWAPCHAIN_EXTENSION_NAME: &'static [u8; 17usize] = + b"VK_KHR_swapchain\x00"; +pub const VK_KHR_display: ::std::os::raw::c_uint = 1; +pub const VK_KHR_DISPLAY_SPEC_VERSION: ::std::os::raw::c_uint = 21; +pub const VK_KHR_DISPLAY_EXTENSION_NAME: &'static [u8; 15usize] = + b"VK_KHR_display\x00"; +pub const VK_KHR_display_swapchain: ::std::os::raw::c_uint = 1; +pub const VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION: ::std::os::raw::c_uint = 9; +pub const VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME: &'static [u8; 25usize] = + b"VK_KHR_display_swapchain\x00"; +pub const VK_KHR_sampler_mirror_clamp_to_edge: ::std::os::raw::c_uint = 1; +pub const VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME: + &'static [u8; 36usize] = + b"VK_KHR_sampler_mirror_clamp_to_edge\x00"; +pub const VK_KHR_get_physical_device_properties2: ::std::os::raw::c_uint = 1; +pub const VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME: + &'static [u8; 39usize] = + b"VK_KHR_get_physical_device_properties2\x00"; +pub const VK_KHR_shader_draw_parameters: ::std::os::raw::c_uint = 1; +pub const VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION: ::std::os::raw::c_uint = + 1; +pub const VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME: &'static [u8; 30usize] + = + b"VK_KHR_shader_draw_parameters\x00"; +pub const VK_KHR_maintenance1: ::std::os::raw::c_uint = 1; +pub const VK_KHR_MAINTENANCE1_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_KHR_MAINTENANCE1_EXTENSION_NAME: &'static [u8; 20usize] = + b"VK_KHR_maintenance1\x00"; +pub const VK_KHR_push_descriptor: ::std::os::raw::c_uint = 1; +pub const VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME: &'static [u8; 23usize] = + b"VK_KHR_push_descriptor\x00"; +pub const VK_KHR_descriptor_update_template: ::std::os::raw::c_uint = 1; +pub const VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME: + &'static [u8; 34usize] = + b"VK_KHR_descriptor_update_template\x00"; +pub const VK_EXT_debug_report: ::std::os::raw::c_uint = 1; +pub const VK_EXT_DEBUG_REPORT_SPEC_VERSION: ::std::os::raw::c_uint = 5; +pub const VK_EXT_DEBUG_REPORT_EXTENSION_NAME: &'static [u8; 20usize] = + b"VK_EXT_debug_report\x00"; +pub const VK_NV_glsl_shader: ::std::os::raw::c_uint = 1; +pub const VK_NV_GLSL_SHADER_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_NV_GLSL_SHADER_EXTENSION_NAME: &'static [u8; 18usize] = + b"VK_NV_glsl_shader\x00"; +pub const VK_IMG_filter_cubic: ::std::os::raw::c_uint = 1; +pub const VK_IMG_FILTER_CUBIC_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_IMG_FILTER_CUBIC_EXTENSION_NAME: &'static [u8; 20usize] = + b"VK_IMG_filter_cubic\x00"; +pub const VK_AMD_rasterization_order: ::std::os::raw::c_uint = 1; +pub const VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME: &'static [u8; 27usize] = + b"VK_AMD_rasterization_order\x00"; +pub const VK_AMD_shader_trinary_minmax: ::std::os::raw::c_uint = 1; +pub const VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION: ::std::os::raw::c_uint = + 1; +pub const VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME: &'static [u8; 29usize] + = + b"VK_AMD_shader_trinary_minmax\x00"; +pub const VK_AMD_shader_explicit_vertex_parameter: ::std::os::raw::c_uint = 1; +pub const VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME: + &'static [u8; 40usize] = + b"VK_AMD_shader_explicit_vertex_parameter\x00"; +pub const VK_EXT_debug_marker: ::std::os::raw::c_uint = 1; +pub const VK_EXT_DEBUG_MARKER_SPEC_VERSION: ::std::os::raw::c_uint = 4; +pub const VK_EXT_DEBUG_MARKER_EXTENSION_NAME: &'static [u8; 20usize] = + b"VK_EXT_debug_marker\x00"; +pub const VK_AMD_gcn_shader: ::std::os::raw::c_uint = 1; +pub const VK_AMD_GCN_SHADER_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_AMD_GCN_SHADER_EXTENSION_NAME: &'static [u8; 18usize] = + b"VK_AMD_gcn_shader\x00"; +pub const VK_NV_dedicated_allocation: ::std::os::raw::c_uint = 1; +pub const VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME: &'static [u8; 27usize] = + b"VK_NV_dedicated_allocation\x00"; +pub const VK_AMD_draw_indirect_count: ::std::os::raw::c_uint = 1; +pub const VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME: &'static [u8; 27usize] = + b"VK_AMD_draw_indirect_count\x00"; +pub const VK_AMD_negative_viewport_height: ::std::os::raw::c_uint = 1; +pub const VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION: ::std::os::raw::c_uint + = + 1; +pub const VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME: + &'static [u8; 32usize] = + b"VK_AMD_negative_viewport_height\x00"; +pub const VK_AMD_gpu_shader_half_float: ::std::os::raw::c_uint = 1; +pub const VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION: ::std::os::raw::c_uint = + 1; +pub const VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME: &'static [u8; 29usize] + = + b"VK_AMD_gpu_shader_half_float\x00"; +pub const VK_AMD_shader_ballot: ::std::os::raw::c_uint = 1; +pub const VK_AMD_SHADER_BALLOT_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_AMD_SHADER_BALLOT_EXTENSION_NAME: &'static [u8; 21usize] = + b"VK_AMD_shader_ballot\x00"; +pub const VK_KHX_multiview: ::std::os::raw::c_uint = 1; +pub const VK_KHX_MULTIVIEW_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_KHX_MULTIVIEW_EXTENSION_NAME: &'static [u8; 17usize] = + b"VK_KHX_multiview\x00"; +pub const VK_IMG_format_pvrtc: ::std::os::raw::c_uint = 1; +pub const VK_IMG_FORMAT_PVRTC_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_IMG_FORMAT_PVRTC_EXTENSION_NAME: &'static [u8; 20usize] = + b"VK_IMG_format_pvrtc\x00"; +pub const VK_NV_external_memory_capabilities: ::std::os::raw::c_uint = 1; +pub const VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME: + &'static [u8; 35usize] = + b"VK_NV_external_memory_capabilities\x00"; +pub const VK_NV_external_memory: ::std::os::raw::c_uint = 1; +pub const VK_NV_EXTERNAL_MEMORY_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME: &'static [u8; 22usize] = + b"VK_NV_external_memory\x00"; +pub const VK_KHX_device_group: ::std::os::raw::c_uint = 1; +pub const VK_MAX_DEVICE_GROUP_SIZE_KHX: ::std::os::raw::c_uint = 32; +pub const VK_KHX_DEVICE_GROUP_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_KHX_DEVICE_GROUP_EXTENSION_NAME: &'static [u8; 20usize] = + b"VK_KHX_device_group\x00"; +pub const VK_EXT_validation_flags: ::std::os::raw::c_uint = 1; +pub const VK_EXT_VALIDATION_FLAGS_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME: &'static [u8; 24usize] = + b"VK_EXT_validation_flags\x00"; +pub const VK_EXT_shader_subgroup_ballot: ::std::os::raw::c_uint = 1; +pub const VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION: ::std::os::raw::c_uint = + 1; +pub const VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME: &'static [u8; 30usize] + = + b"VK_EXT_shader_subgroup_ballot\x00"; +pub const VK_EXT_shader_subgroup_vote: ::std::os::raw::c_uint = 1; +pub const VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION: ::std::os::raw::c_uint = + 1; +pub const VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME: &'static [u8; 28usize] = + b"VK_EXT_shader_subgroup_vote\x00"; +pub const VK_KHX_device_group_creation: ::std::os::raw::c_uint = 1; +pub const VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION: ::std::os::raw::c_uint = + 1; +pub const VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME: &'static [u8; 29usize] + = + b"VK_KHX_device_group_creation\x00"; +pub const VK_KHX_external_memory_capabilities: ::std::os::raw::c_uint = 1; +pub const VK_LUID_SIZE_KHX: ::std::os::raw::c_uint = 8; +pub const VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME: + &'static [u8; 36usize] = + b"VK_KHX_external_memory_capabilities\x00"; +pub const VK_KHX_external_memory: ::std::os::raw::c_uint = 1; +pub const VK_KHX_EXTERNAL_MEMORY_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_KHX_EXTERNAL_MEMORY_EXTENSION_NAME: &'static [u8; 23usize] = + b"VK_KHX_external_memory\x00"; +pub const VK_QUEUE_FAMILY_EXTERNAL_KHX: ::std::os::raw::c_int = -2; +pub const VK_KHX_external_memory_fd: ::std::os::raw::c_uint = 1; +pub const VK_KHX_EXTERNAL_MEMORY_FD_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME: &'static [u8; 26usize] = + b"VK_KHX_external_memory_fd\x00"; +pub const VK_KHX_external_semaphore_capabilities: ::std::os::raw::c_uint = 1; +pub const VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME: + &'static [u8; 39usize] = + b"VK_KHX_external_semaphore_capabilities\x00"; +pub const VK_KHX_external_semaphore: ::std::os::raw::c_uint = 1; +pub const VK_KHX_EXTERNAL_SEMAPHORE_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_KHX_EXTERNAL_SEMAPHORE_EXTENSION_NAME: &'static [u8; 26usize] = + b"VK_KHX_external_semaphore\x00"; +pub const VK_KHX_external_semaphore_fd: ::std::os::raw::c_uint = 1; +pub const VK_KHX_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION: ::std::os::raw::c_uint = + 1; +pub const VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME: &'static [u8; 29usize] + = + b"VK_KHX_external_semaphore_fd\x00"; +pub const VK_NVX_device_generated_commands: ::std::os::raw::c_uint = 1; +pub const VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME: + &'static [u8; 33usize] = + b"VK_NVX_device_generated_commands\x00"; +pub const VK_NV_clip_space_w_scaling: ::std::os::raw::c_uint = 1; +pub const VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME: &'static [u8; 27usize] = + b"VK_NV_clip_space_w_scaling\x00"; +pub const VK_EXT_direct_mode_display: ::std::os::raw::c_uint = 1; +pub const VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME: &'static [u8; 27usize] = + b"VK_EXT_direct_mode_display\x00"; +pub const VK_EXT_display_surface_counter: ::std::os::raw::c_uint = 1; +pub const VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION: ::std::os::raw::c_uint + = + 1; +pub const VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME: + &'static [u8; 31usize] = + b"VK_EXT_display_surface_counter\x00"; +pub const VK_EXT_display_control: ::std::os::raw::c_uint = 1; +pub const VK_EXT_DISPLAY_CONTROL_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME: &'static [u8; 23usize] = + b"VK_EXT_display_control\x00"; +pub const VK_NV_sample_mask_override_coverage: ::std::os::raw::c_uint = 1; +pub const VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME: + &'static [u8; 36usize] = + b"VK_NV_sample_mask_override_coverage\x00"; +pub const VK_NV_geometry_shader_passthrough: ::std::os::raw::c_uint = 1; +pub const VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME: + &'static [u8; 34usize] = + b"VK_NV_geometry_shader_passthrough\x00"; +pub const VK_NV_viewport_array2: ::std::os::raw::c_uint = 1; +pub const VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME: &'static [u8; 22usize] = + b"VK_NV_viewport_array2\x00"; +pub const VK_NVX_multiview_per_view_attributes: ::std::os::raw::c_uint = 1; +pub const VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION: + ::std::os::raw::c_uint = + 1; +pub const VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME: + &'static [u8; 37usize] = + b"VK_NVX_multiview_per_view_attributes\x00"; +pub const VK_NV_viewport_swizzle: ::std::os::raw::c_uint = 1; +pub const VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME: &'static [u8; 23usize] = + b"VK_NV_viewport_swizzle\x00"; +pub const VK_EXT_discard_rectangles: ::std::os::raw::c_uint = 1; +pub const VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION: ::std::os::raw::c_uint = 1; +pub const VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME: &'static [u8; 26usize] = + b"VK_EXT_discard_rectangles\x00"; +pub type wchar_t = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct max_align_t { + pub __clang_max_align_nonce1: ::std::os::raw::c_longlong, + pub __bindgen_padding_0: u64, + pub __clang_max_align_nonce2: f64, +} +impl Clone for max_align_t { + fn clone(&self) -> Self { *self } +} +pub type __u_char = ::std::os::raw::c_uchar; +pub type __u_short = ::std::os::raw::c_ushort; +pub type __u_int = ::std::os::raw::c_uint; +pub type __u_long = ::std::os::raw::c_ulong; +pub type __int8_t = ::std::os::raw::c_schar; +pub type __uint8_t = ::std::os::raw::c_uchar; +pub type __int16_t = ::std::os::raw::c_short; +pub type __uint16_t = ::std::os::raw::c_ushort; +pub type __int32_t = ::std::os::raw::c_int; +pub type __uint32_t = ::std::os::raw::c_uint; +pub type __int64_t = ::std::os::raw::c_long; +pub type __uint64_t = ::std::os::raw::c_ulong; +pub type __quad_t = ::std::os::raw::c_long; +pub type __u_quad_t = ::std::os::raw::c_ulong; +pub type __intmax_t = ::std::os::raw::c_long; +pub type __uintmax_t = ::std::os::raw::c_ulong; +pub type __dev_t = ::std::os::raw::c_ulong; +pub type __uid_t = ::std::os::raw::c_uint; +pub type __gid_t = ::std::os::raw::c_uint; +pub type __ino_t = ::std::os::raw::c_ulong; +pub type __ino64_t = ::std::os::raw::c_ulong; +pub type __mode_t = ::std::os::raw::c_uint; +pub type __nlink_t = ::std::os::raw::c_ulong; +pub type __off_t = ::std::os::raw::c_long; +pub type __off64_t = ::std::os::raw::c_long; +pub type __pid_t = ::std::os::raw::c_int; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct __fsid_t { + pub __val: [::std::os::raw::c_int; 2usize], +} +impl Clone for __fsid_t { + fn clone(&self) -> Self { *self } +} +pub type __clock_t = ::std::os::raw::c_long; +pub type __rlim_t = ::std::os::raw::c_ulong; +pub type __rlim64_t = ::std::os::raw::c_ulong; +pub type __id_t = ::std::os::raw::c_uint; +pub type __time_t = ::std::os::raw::c_long; +pub type __useconds_t = ::std::os::raw::c_uint; +pub type __suseconds_t = ::std::os::raw::c_long; +pub type __daddr_t = ::std::os::raw::c_int; +pub type __key_t = ::std::os::raw::c_int; +pub type __clockid_t = ::std::os::raw::c_int; +pub type __timer_t = *mut ::std::os::raw::c_void; +pub type __blksize_t = ::std::os::raw::c_long; +pub type __blkcnt_t = ::std::os::raw::c_long; +pub type __blkcnt64_t = ::std::os::raw::c_long; +pub type __fsblkcnt_t = ::std::os::raw::c_ulong; +pub type __fsblkcnt64_t = ::std::os::raw::c_ulong; +pub type __fsfilcnt_t = ::std::os::raw::c_ulong; +pub type __fsfilcnt64_t = ::std::os::raw::c_ulong; +pub type __fsword_t = ::std::os::raw::c_long; +pub type __ssize_t = ::std::os::raw::c_long; +pub type __syscall_slong_t = ::std::os::raw::c_long; +pub type __syscall_ulong_t = ::std::os::raw::c_ulong; +pub type __loff_t = __off64_t; +pub type __qaddr_t = *mut __quad_t; +pub type __caddr_t = *mut ::std::os::raw::c_char; +pub type __intptr_t = ::std::os::raw::c_long; +pub type __socklen_t = ::std::os::raw::c_uint; +pub type int_least8_t = ::std::os::raw::c_schar; +pub type int_least16_t = ::std::os::raw::c_short; +pub type int_least32_t = ::std::os::raw::c_int; +pub type int_least64_t = ::std::os::raw::c_long; +pub type uint_least8_t = ::std::os::raw::c_uchar; +pub type uint_least16_t = ::std::os::raw::c_ushort; +pub type uint_least32_t = ::std::os::raw::c_uint; +pub type uint_least64_t = ::std::os::raw::c_ulong; +pub type int_fast8_t = ::std::os::raw::c_schar; +pub type int_fast16_t = ::std::os::raw::c_long; +pub type int_fast32_t = ::std::os::raw::c_long; +pub type int_fast64_t = ::std::os::raw::c_long; +pub type uint_fast8_t = ::std::os::raw::c_uchar; +pub type uint_fast16_t = ::std::os::raw::c_ulong; +pub type uint_fast32_t = ::std::os::raw::c_ulong; +pub type uint_fast64_t = ::std::os::raw::c_ulong; +pub type intmax_t = __intmax_t; +pub type uintmax_t = __uintmax_t; +pub type VkFlags = u32; +pub type VkBool32 = u32; +pub type VkDeviceSize = u64; +pub type VkSampleMask = u32; + +pub type VkInstance = *mut u8; + +#[no_mangle] +pub extern fn vkCreateInstance( + _pCreateInfo: *const VkInstanceCreateInfo, + _pAllocator: *const VkAllocationCallbacks, + pInstance: *mut VkInstance, +) -> VkResult { + let instance = back::Instance::create("portability", 1); + let pointer = Box::into_raw(Box::new(instance)); + unsafe { *pInstance = pointer as *mut _ }; + return VkResult::VK_SUCCESS; +} + +#[no_mangle] +pub extern fn vkDestroyInstance( + instance: VkInstance, + _pAllocator: *const VkAllocationCallbacks, +) { + let _instance = unsafe { Box::from_raw(instance as *mut _) }; + //let it drop +} + + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkPhysicalDevice_T { + _unused: [u8; 0], +} +pub type VkPhysicalDevice = *mut VkPhysicalDevice_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkDevice_T { + _unused: [u8; 0], +} +pub type VkDevice = *mut VkDevice_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkQueue_T { + _unused: [u8; 0], +} +pub type VkQueue = *mut VkQueue_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkSemaphore_T { + _unused: [u8; 0], +} +pub type VkSemaphore = *mut VkSemaphore_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkCommandBuffer_T { + _unused: [u8; 0], +} +pub type VkCommandBuffer = *mut VkCommandBuffer_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkFence_T { + _unused: [u8; 0], +} +pub type VkFence = *mut VkFence_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkDeviceMemory_T { + _unused: [u8; 0], +} +pub type VkDeviceMemory = *mut VkDeviceMemory_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkBuffer_T { + _unused: [u8; 0], +} +pub type VkBuffer = *mut VkBuffer_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkImage_T { + _unused: [u8; 0], +} +pub type VkImage = *mut VkImage_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkEvent_T { + _unused: [u8; 0], +} +pub type VkEvent = *mut VkEvent_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkQueryPool_T { + _unused: [u8; 0], +} +pub type VkQueryPool = *mut VkQueryPool_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkBufferView_T { + _unused: [u8; 0], +} +pub type VkBufferView = *mut VkBufferView_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkImageView_T { + _unused: [u8; 0], +} +pub type VkImageView = *mut VkImageView_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkShaderModule_T { + _unused: [u8; 0], +} +pub type VkShaderModule = *mut VkShaderModule_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkPipelineCache_T { + _unused: [u8; 0], +} +pub type VkPipelineCache = *mut VkPipelineCache_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkPipelineLayout_T { + _unused: [u8; 0], +} +pub type VkPipelineLayout = *mut VkPipelineLayout_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkRenderPass_T { + _unused: [u8; 0], +} +pub type VkRenderPass = *mut VkRenderPass_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkPipeline_T { + _unused: [u8; 0], +} +pub type VkPipeline = *mut VkPipeline_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkDescriptorSetLayout_T { + _unused: [u8; 0], +} +pub type VkDescriptorSetLayout = *mut VkDescriptorSetLayout_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkSampler_T { + _unused: [u8; 0], +} +pub type VkSampler = *mut VkSampler_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkDescriptorPool_T { + _unused: [u8; 0], +} +pub type VkDescriptorPool = *mut VkDescriptorPool_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkDescriptorSet_T { + _unused: [u8; 0], +} +pub type VkDescriptorSet = *mut VkDescriptorSet_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkFramebuffer_T { + _unused: [u8; 0], +} +pub type VkFramebuffer = *mut VkFramebuffer_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkCommandPool_T { + _unused: [u8; 0], +} +pub type VkCommandPool = *mut VkCommandPool_T; +pub const VkPipelineCacheHeaderVersion_VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE: + VkPipelineCacheHeaderVersion = + VkPipelineCacheHeaderVersion::VK_PIPELINE_CACHE_HEADER_VERSION_ONE; +pub const VkPipelineCacheHeaderVersion_VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE: + VkPipelineCacheHeaderVersion = + VkPipelineCacheHeaderVersion::VK_PIPELINE_CACHE_HEADER_VERSION_ONE; +pub const VkPipelineCacheHeaderVersion_VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE: + VkPipelineCacheHeaderVersion = + VkPipelineCacheHeaderVersion::VK_PIPELINE_CACHE_HEADER_VERSION_ONE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 2147483647, +} +pub const VkResult_VK_RESULT_BEGIN_RANGE: VkResult = + VkResult::VK_ERROR_FRAGMENTED_POOL; +pub const VkResult_VK_RESULT_END_RANGE: VkResult = VkResult::VK_INCOMPLETE; +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkResult { + 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_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, + VK_ERROR_INVALID_SHADER_NV = -1000012000, + VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX = -1000072003, + VK_RESULT_RANGE_SIZE = 18, + VK_RESULT_MAX_ENUM = 2147483647, +} +pub const VkStructureType_VK_STRUCTURE_TYPE_BEGIN_RANGE: VkStructureType = + VkStructureType::VK_STRUCTURE_TYPE_APPLICATION_INFO; +pub const VkStructureType_VK_STRUCTURE_TYPE_END_RANGE: VkStructureType = + VkStructureType::VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkStructureType { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, + VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = + 1000018000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = + 1000026002, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = + 1000059008, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = 1000060000, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX = 1000060001, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX = 1000060002, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = 1000060006, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = 1000060012, + VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = 1000070001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX = + 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX = 1000071004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX = 1000071005, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX = 1000071006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX = 1000071007, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX = 1000072002, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX = 1000073002, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX = 1000074001, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX = 1000075000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX = + 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX = 1000076001, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX = 1000077000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = 1000078002, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = 1000079000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = + 1000080000, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000, + VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, + VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, + VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, + VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, + VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = + 1000087000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = 1000090000, + VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX + = 1000097000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = + 1000098000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = + 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = + 1000099001, + VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + VK_STRUCTURE_TYPE_RANGE_SIZE = 49, + VK_STRUCTURE_TYPE_MAX_ENUM = 2147483647, +} +pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE: + VkSystemAllocationScope = + VkSystemAllocationScope::VK_SYSTEM_ALLOCATION_SCOPE_COMMAND; +pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE: + VkSystemAllocationScope = + VkSystemAllocationScope::VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSystemAllocationScope { + 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_RANGE_SIZE = 5, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 2147483647, +} +pub const VkInternalAllocationType_VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE: + VkInternalAllocationType = + VkInternalAllocationType::VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE; +pub const VkInternalAllocationType_VK_INTERNAL_ALLOCATION_TYPE_END_RANGE: + VkInternalAllocationType = + VkInternalAllocationType::VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkInternalAllocationType { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = 1, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 2147483647, +} +pub const VkFormat_VK_FORMAT_BEGIN_RANGE: VkFormat = + VkFormat::VK_FORMAT_UNDEFINED; +pub const VkFormat_VK_FORMAT_END_RANGE: VkFormat = + VkFormat::VK_FORMAT_ASTC_12x12_SRGB_BLOCK; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkFormat { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + VK_FORMAT_RANGE_SIZE = 185, + VK_FORMAT_MAX_ENUM = 2147483647, +} +pub const VkImageType_VK_IMAGE_TYPE_BEGIN_RANGE: VkImageType = + VkImageType::VK_IMAGE_TYPE_1D; +pub const VkImageType_VK_IMAGE_TYPE_END_RANGE: VkImageType = + VkImageType::VK_IMAGE_TYPE_3D; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkImageType { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_RANGE_SIZE = 3, + VK_IMAGE_TYPE_MAX_ENUM = 2147483647, +} +pub const VkImageTiling_VK_IMAGE_TILING_BEGIN_RANGE: VkImageTiling = + VkImageTiling::VK_IMAGE_TILING_OPTIMAL; +pub const VkImageTiling_VK_IMAGE_TILING_END_RANGE: VkImageTiling = + VkImageTiling::VK_IMAGE_TILING_LINEAR; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkImageTiling { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_RANGE_SIZE = 2, + VK_IMAGE_TILING_MAX_ENUM = 2147483647, +} +pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE: + VkPhysicalDeviceType = + VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_OTHER; +pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_END_RANGE: + VkPhysicalDeviceType = + VkPhysicalDeviceType::VK_PHYSICAL_DEVICE_TYPE_CPU; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkPhysicalDeviceType { + 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_RANGE_SIZE = 5, + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 2147483647, +} +pub const VkQueryType_VK_QUERY_TYPE_BEGIN_RANGE: VkQueryType = + VkQueryType::VK_QUERY_TYPE_OCCLUSION; +pub const VkQueryType_VK_QUERY_TYPE_END_RANGE: VkQueryType = + VkQueryType::VK_QUERY_TYPE_TIMESTAMP; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkQueryType { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_RANGE_SIZE = 3, + VK_QUERY_TYPE_MAX_ENUM = 2147483647, +} +pub const VkSharingMode_VK_SHARING_MODE_BEGIN_RANGE: VkSharingMode = + VkSharingMode::VK_SHARING_MODE_EXCLUSIVE; +pub const VkSharingMode_VK_SHARING_MODE_END_RANGE: VkSharingMode = + VkSharingMode::VK_SHARING_MODE_CONCURRENT; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSharingMode { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_RANGE_SIZE = 2, + VK_SHARING_MODE_MAX_ENUM = 2147483647, +} +pub const VkImageLayout_VK_IMAGE_LAYOUT_BEGIN_RANGE: VkImageLayout = + VkImageLayout::VK_IMAGE_LAYOUT_UNDEFINED; +pub const VkImageLayout_VK_IMAGE_LAYOUT_END_RANGE: VkImageLayout = + VkImageLayout::VK_IMAGE_LAYOUT_PREINITIALIZED; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkImageLayout { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_RANGE_SIZE = 9, + VK_IMAGE_LAYOUT_MAX_ENUM = 2147483647, +} +pub const VkImageViewType_VK_IMAGE_VIEW_TYPE_BEGIN_RANGE: VkImageViewType = + VkImageViewType::VK_IMAGE_VIEW_TYPE_1D; +pub const VkImageViewType_VK_IMAGE_VIEW_TYPE_END_RANGE: VkImageViewType = + VkImageViewType::VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkImageViewType { + 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_RANGE_SIZE = 7, + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 2147483647, +} +pub const VkComponentSwizzle_VK_COMPONENT_SWIZZLE_BEGIN_RANGE: + VkComponentSwizzle = + VkComponentSwizzle::VK_COMPONENT_SWIZZLE_IDENTITY; +pub const VkComponentSwizzle_VK_COMPONENT_SWIZZLE_END_RANGE: + VkComponentSwizzle = + VkComponentSwizzle::VK_COMPONENT_SWIZZLE_A; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkComponentSwizzle { + 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_RANGE_SIZE = 7, + VK_COMPONENT_SWIZZLE_MAX_ENUM = 2147483647, +} +pub const VkVertexInputRate_VK_VERTEX_INPUT_RATE_BEGIN_RANGE: + VkVertexInputRate = + VkVertexInputRate::VK_VERTEX_INPUT_RATE_VERTEX; +pub const VkVertexInputRate_VK_VERTEX_INPUT_RATE_END_RANGE: VkVertexInputRate + = + VkVertexInputRate::VK_VERTEX_INPUT_RATE_INSTANCE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkVertexInputRate { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_RANGE_SIZE = 2, + VK_VERTEX_INPUT_RATE_MAX_ENUM = 2147483647, +} +pub const VkPrimitiveTopology_VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE: + VkPrimitiveTopology = + VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_POINT_LIST; +pub const VkPrimitiveTopology_VK_PRIMITIVE_TOPOLOGY_END_RANGE: + VkPrimitiveTopology = + VkPrimitiveTopology::VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkPrimitiveTopology { + 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_RANGE_SIZE = 11, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 2147483647, +} +pub const VkPolygonMode_VK_POLYGON_MODE_BEGIN_RANGE: VkPolygonMode = + VkPolygonMode::VK_POLYGON_MODE_FILL; +pub const VkPolygonMode_VK_POLYGON_MODE_END_RANGE: VkPolygonMode = + VkPolygonMode::VK_POLYGON_MODE_POINT; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkPolygonMode { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_RANGE_SIZE = 3, + VK_POLYGON_MODE_MAX_ENUM = 2147483647, +} +pub const VkFrontFace_VK_FRONT_FACE_BEGIN_RANGE: VkFrontFace = + VkFrontFace::VK_FRONT_FACE_COUNTER_CLOCKWISE; +pub const VkFrontFace_VK_FRONT_FACE_END_RANGE: VkFrontFace = + VkFrontFace::VK_FRONT_FACE_CLOCKWISE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkFrontFace { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_RANGE_SIZE = 2, + VK_FRONT_FACE_MAX_ENUM = 2147483647, +} +pub const VkCompareOp_VK_COMPARE_OP_BEGIN_RANGE: VkCompareOp = + VkCompareOp::VK_COMPARE_OP_NEVER; +pub const VkCompareOp_VK_COMPARE_OP_END_RANGE: VkCompareOp = + VkCompareOp::VK_COMPARE_OP_ALWAYS; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkCompareOp { + 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_RANGE_SIZE = 8, + VK_COMPARE_OP_MAX_ENUM = 2147483647, +} +pub const VkStencilOp_VK_STENCIL_OP_BEGIN_RANGE: VkStencilOp = + VkStencilOp::VK_STENCIL_OP_KEEP; +pub const VkStencilOp_VK_STENCIL_OP_END_RANGE: VkStencilOp = + VkStencilOp::VK_STENCIL_OP_DECREMENT_AND_WRAP; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkStencilOp { + 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_RANGE_SIZE = 8, + VK_STENCIL_OP_MAX_ENUM = 2147483647, +} +pub const VkLogicOp_VK_LOGIC_OP_BEGIN_RANGE: VkLogicOp = + VkLogicOp::VK_LOGIC_OP_CLEAR; +pub const VkLogicOp_VK_LOGIC_OP_END_RANGE: VkLogicOp = + VkLogicOp::VK_LOGIC_OP_SET; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkLogicOp { + 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_RANGE_SIZE = 16, + VK_LOGIC_OP_MAX_ENUM = 2147483647, +} +pub const VkBlendFactor_VK_BLEND_FACTOR_BEGIN_RANGE: VkBlendFactor = + VkBlendFactor::VK_BLEND_FACTOR_ZERO; +pub const VkBlendFactor_VK_BLEND_FACTOR_END_RANGE: VkBlendFactor = + VkBlendFactor::VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkBlendFactor { + 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_RANGE_SIZE = 19, + VK_BLEND_FACTOR_MAX_ENUM = 2147483647, +} +pub const VkBlendOp_VK_BLEND_OP_BEGIN_RANGE: VkBlendOp = + VkBlendOp::VK_BLEND_OP_ADD; +pub const VkBlendOp_VK_BLEND_OP_END_RANGE: VkBlendOp = + VkBlendOp::VK_BLEND_OP_MAX; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkBlendOp { + 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_RANGE_SIZE = 5, + VK_BLEND_OP_MAX_ENUM = 2147483647, +} +pub const VkDynamicState_VK_DYNAMIC_STATE_BEGIN_RANGE: VkDynamicState = + VkDynamicState::VK_DYNAMIC_STATE_VIEWPORT; +pub const VkDynamicState_VK_DYNAMIC_STATE_END_RANGE: VkDynamicState = + VkDynamicState::VK_DYNAMIC_STATE_STENCIL_REFERENCE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDynamicState { + 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_VIEWPORT_W_SCALING_NV = 1000087000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + VK_DYNAMIC_STATE_RANGE_SIZE = 9, + VK_DYNAMIC_STATE_MAX_ENUM = 2147483647, +} +pub const VkFilter_VK_FILTER_BEGIN_RANGE: VkFilter = + VkFilter::VK_FILTER_NEAREST; +pub const VkFilter_VK_FILTER_END_RANGE: VkFilter = VkFilter::VK_FILTER_LINEAR; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_CUBIC_IMG = 1000015000, + VK_FILTER_RANGE_SIZE = 2, + VK_FILTER_MAX_ENUM = 2147483647, +} +pub const VkSamplerMipmapMode_VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE: + VkSamplerMipmapMode = + VkSamplerMipmapMode::VK_SAMPLER_MIPMAP_MODE_NEAREST; +pub const VkSamplerMipmapMode_VK_SAMPLER_MIPMAP_MODE_END_RANGE: + VkSamplerMipmapMode = + VkSamplerMipmapMode::VK_SAMPLER_MIPMAP_MODE_LINEAR; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = 2, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 2147483647, +} +pub const VkSamplerAddressMode_VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE: + VkSamplerAddressMode = + VkSamplerAddressMode::VK_SAMPLER_ADDRESS_MODE_REPEAT; +pub const VkSamplerAddressMode_VK_SAMPLER_ADDRESS_MODE_END_RANGE: + VkSamplerAddressMode = + VkSamplerAddressMode::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; +pub const VkSamplerAddressMode_VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE: + VkSamplerAddressMode = + VkSamplerAddressMode::VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSamplerAddressMode { + 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 = 2147483647, +} +pub const VkBorderColor_VK_BORDER_COLOR_BEGIN_RANGE: VkBorderColor = + VkBorderColor::VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK; +pub const VkBorderColor_VK_BORDER_COLOR_END_RANGE: VkBorderColor = + VkBorderColor::VK_BORDER_COLOR_INT_OPAQUE_WHITE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkBorderColor { + 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_RANGE_SIZE = 6, + VK_BORDER_COLOR_MAX_ENUM = 2147483647, +} +pub const VkDescriptorType_VK_DESCRIPTOR_TYPE_BEGIN_RANGE: VkDescriptorType = + VkDescriptorType::VK_DESCRIPTOR_TYPE_SAMPLER; +pub const VkDescriptorType_VK_DESCRIPTOR_TYPE_END_RANGE: VkDescriptorType = + VkDescriptorType::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDescriptorType { + 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_RANGE_SIZE = 11, + VK_DESCRIPTOR_TYPE_MAX_ENUM = 2147483647, +} +pub const VkAttachmentLoadOp_VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE: + VkAttachmentLoadOp = + VkAttachmentLoadOp::VK_ATTACHMENT_LOAD_OP_LOAD; +pub const VkAttachmentLoadOp_VK_ATTACHMENT_LOAD_OP_END_RANGE: + VkAttachmentLoadOp = + VkAttachmentLoadOp::VK_ATTACHMENT_LOAD_OP_DONT_CARE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkAttachmentLoadOp { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = 3, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 2147483647, +} +pub const VkAttachmentStoreOp_VK_ATTACHMENT_STORE_OP_BEGIN_RANGE: + VkAttachmentStoreOp = + VkAttachmentStoreOp::VK_ATTACHMENT_STORE_OP_STORE; +pub const VkAttachmentStoreOp_VK_ATTACHMENT_STORE_OP_END_RANGE: + VkAttachmentStoreOp = + VkAttachmentStoreOp::VK_ATTACHMENT_STORE_OP_DONT_CARE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkAttachmentStoreOp { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_RANGE_SIZE = 2, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 2147483647, +} +pub const VkPipelineBindPoint_VK_PIPELINE_BIND_POINT_BEGIN_RANGE: + VkPipelineBindPoint = + VkPipelineBindPoint::VK_PIPELINE_BIND_POINT_GRAPHICS; +pub const VkPipelineBindPoint_VK_PIPELINE_BIND_POINT_END_RANGE: + VkPipelineBindPoint = + VkPipelineBindPoint::VK_PIPELINE_BIND_POINT_COMPUTE; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_RANGE_SIZE = 2, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 2147483647, +} +pub const VkCommandBufferLevel_VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE: + VkCommandBufferLevel = + VkCommandBufferLevel::VK_COMMAND_BUFFER_LEVEL_PRIMARY; +pub const VkCommandBufferLevel_VK_COMMAND_BUFFER_LEVEL_END_RANGE: + VkCommandBufferLevel = + VkCommandBufferLevel::VK_COMMAND_BUFFER_LEVEL_SECONDARY; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = 2, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 2147483647, +} +pub const VkIndexType_VK_INDEX_TYPE_BEGIN_RANGE: VkIndexType = + VkIndexType::VK_INDEX_TYPE_UINT16; +pub const VkIndexType_VK_INDEX_TYPE_END_RANGE: VkIndexType = + VkIndexType::VK_INDEX_TYPE_UINT32; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_RANGE_SIZE = 2, + VK_INDEX_TYPE_MAX_ENUM = 2147483647, +} +pub const VkSubpassContents_VK_SUBPASS_CONTENTS_BEGIN_RANGE: VkSubpassContents + = + VkSubpassContents::VK_SUBPASS_CONTENTS_INLINE; +pub const VkSubpassContents_VK_SUBPASS_CONTENTS_END_RANGE: VkSubpassContents = + VkSubpassContents::VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSubpassContents { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_RANGE_SIZE = 2, + VK_SUBPASS_CONTENTS_MAX_ENUM = 2147483647, +} +pub type VkInstanceCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkFormatFeatureFlagBits { + 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_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 8192, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 16384, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 32768, + VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkFormatFeatureFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkImageUsageFlagBits { + 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 = 2147483647, +} +pub type VkImageUsageFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkImageCreateFlagBits { + 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_BIND_SFR_BIT_KHX = 64, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 32, + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkImageCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSampleCountFlagBits { + 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 = 2147483647, +} +pub type VkSampleCountFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkQueueFlagBits { + 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 = 2147483647, +} +pub type VkQueueFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkMemoryPropertyFlagBits { + 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 = 2147483647, +} +pub type VkMemoryPropertyFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkMemoryHeapFlagBits { + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 2, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkMemoryHeapFlags = VkFlags; +pub type VkDeviceCreateFlags = VkFlags; +pub type VkDeviceQueueCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkPipelineStageFlagBits { + 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_COMMAND_PROCESS_BIT_NVX = 131072, + VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkPipelineStageFlags = VkFlags; +pub type VkMemoryMapFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkImageAspectFlagBits { + 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 = 2147483647, +} +pub type VkImageAspectFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSparseImageFormatFlagBits { + 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 = 2147483647, +} +pub type VkSparseImageFormatFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSparseMemoryBindFlagBits { + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkSparseMemoryBindFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkFenceCreateFlagBits { + VK_FENCE_CREATE_SIGNALED_BIT = 1, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkFenceCreateFlags = VkFlags; +pub type VkSemaphoreCreateFlags = VkFlags; +pub type VkEventCreateFlags = VkFlags; +pub type VkQueryPoolCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkQueryPipelineStatisticFlagBits { + 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 = 2147483647, +} +pub type VkQueryPipelineStatisticFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkQueryResultFlagBits { + 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 = 2147483647, +} +pub type VkQueryResultFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkBufferCreateFlagBits { + 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 = 2147483647, +} +pub type VkBufferCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkBufferUsageFlagBits { + 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 = 2147483647, +} +pub type VkBufferUsageFlags = VkFlags; +pub type VkBufferViewCreateFlags = VkFlags; +pub type VkImageViewCreateFlags = VkFlags; +pub type VkShaderModuleCreateFlags = VkFlags; +pub type VkPipelineCacheCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkPipelineCreateFlagBits { + 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_KHX = 8, + VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 16, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkPipelineCreateFlags = VkFlags; +pub type VkPipelineShaderStageCreateFlags = VkFlags; +pub const VkShaderStageFlagBits_VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM: + VkShaderStageFlagBits = + VkShaderStageFlagBits::VK_SHADER_STAGE_ALL; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkShaderStageFlagBits { + 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 = 31, + VK_SHADER_STAGE_ALL = 2147483647, +} +pub type VkPipelineVertexInputStateCreateFlags = VkFlags; +pub type VkPipelineInputAssemblyStateCreateFlags = VkFlags; +pub type VkPipelineTessellationStateCreateFlags = VkFlags; +pub type VkPipelineViewportStateCreateFlags = VkFlags; +pub type VkPipelineRasterizationStateCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkCullModeFlagBits { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 1, + VK_CULL_MODE_BACK_BIT = 2, + VK_CULL_MODE_FRONT_AND_BACK = 3, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkCullModeFlags = VkFlags; +pub type VkPipelineMultisampleStateCreateFlags = VkFlags; +pub type VkPipelineDepthStencilStateCreateFlags = VkFlags; +pub type VkPipelineColorBlendStateCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkColorComponentFlagBits { + 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 = 2147483647, +} +pub type VkColorComponentFlags = VkFlags; +pub type VkPipelineDynamicStateCreateFlags = VkFlags; +pub type VkPipelineLayoutCreateFlags = VkFlags; +pub type VkShaderStageFlags = VkFlags; +pub type VkSamplerCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDescriptorSetLayoutCreateFlagBits { + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 1, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkDescriptorSetLayoutCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDescriptorPoolCreateFlagBits { + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkDescriptorPoolCreateFlags = VkFlags; +pub type VkDescriptorPoolResetFlags = VkFlags; +pub type VkFramebufferCreateFlags = VkFlags; +pub type VkRenderPassCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkAttachmentDescriptionFlagBits { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkAttachmentDescriptionFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSubpassDescriptionFlagBits { + VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 1, + VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 2, + VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkSubpassDescriptionFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkAccessFlagBits { + 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_COMMAND_PROCESS_READ_BIT_NVX = 131072, + VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 262144, + VK_ACCESS_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkAccessFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDependencyFlagBits { + VK_DEPENDENCY_BY_REGION_BIT = 1, + VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 2, + VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 4, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkDependencyFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkCommandPoolCreateFlagBits { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkCommandPoolCreateFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkCommandPoolResetFlagBits { + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkCommandPoolResetFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkCommandBufferUsageFlagBits { + 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 = 2147483647, +} +pub type VkCommandBufferUsageFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkQueryControlFlagBits { + VK_QUERY_CONTROL_PRECISE_BIT = 1, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkQueryControlFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkCommandBufferResetFlagBits { + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkCommandBufferResetFlags = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkStencilFaceFlagBits { + VK_STENCIL_FACE_FRONT_BIT = 1, + VK_STENCIL_FACE_BACK_BIT = 2, + VK_STENCIL_FRONT_AND_BACK = 3, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 2147483647, +} +pub type VkStencilFaceFlags = VkFlags; +pub type PFN_vkAllocationFunction = + ::std::option::Option *mut ::std::os::raw::c_void>; +pub type PFN_vkReallocationFunction = + ::std::option::Option *mut ::std::os::raw::c_void>; +pub type PFN_vkFreeFunction = + ::std::option::Option; +pub type PFN_vkInternalAllocationNotification = + ::std::option::Option; +pub type PFN_vkInternalFreeNotification = + ::std::option::Option; +pub type PFN_vkVoidFunction = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkApplicationInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub pApplicationName: *const ::std::os::raw::c_char, + pub applicationVersion: u32, + pub pEngineName: *const ::std::os::raw::c_char, + pub engineVersion: u32, + pub apiVersion: u32, +} +impl Clone for VkApplicationInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkInstanceCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkInstanceCreateFlags, + pub pApplicationInfo: *const VkApplicationInfo, + pub enabledLayerCount: u32, + pub ppEnabledLayerNames: *const *const ::std::os::raw::c_char, + pub enabledExtensionCount: u32, + pub ppEnabledExtensionNames: *const *const ::std::os::raw::c_char, +} +impl Clone for VkInstanceCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkAllocationCallbacks { + pub pUserData: *mut ::std::os::raw::c_void, + pub pfnAllocation: PFN_vkAllocationFunction, + pub pfnReallocation: PFN_vkReallocationFunction, + pub pfnFree: PFN_vkFreeFunction, + pub pfnInternalAllocation: PFN_vkInternalAllocationNotification, + pub pfnInternalFree: PFN_vkInternalFreeNotification, +} +impl Clone for VkAllocationCallbacks { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceFeatures { + pub robustBufferAccess: VkBool32, + pub fullDrawIndexUint32: VkBool32, + pub imageCubeArray: VkBool32, + pub independentBlend: VkBool32, + pub geometryShader: VkBool32, + pub tessellationShader: VkBool32, + pub sampleRateShading: VkBool32, + pub dualSrcBlend: VkBool32, + pub logicOp: VkBool32, + pub multiDrawIndirect: VkBool32, + pub drawIndirectFirstInstance: VkBool32, + pub depthClamp: VkBool32, + pub depthBiasClamp: VkBool32, + pub fillModeNonSolid: VkBool32, + pub depthBounds: VkBool32, + pub wideLines: VkBool32, + pub largePoints: VkBool32, + pub alphaToOne: VkBool32, + pub multiViewport: VkBool32, + pub samplerAnisotropy: VkBool32, + pub textureCompressionETC2: VkBool32, + pub textureCompressionASTC_LDR: VkBool32, + pub textureCompressionBC: VkBool32, + pub occlusionQueryPrecise: VkBool32, + pub pipelineStatisticsQuery: VkBool32, + pub vertexPipelineStoresAndAtomics: VkBool32, + pub fragmentStoresAndAtomics: VkBool32, + pub shaderTessellationAndGeometryPointSize: VkBool32, + pub shaderImageGatherExtended: VkBool32, + pub shaderStorageImageExtendedFormats: VkBool32, + pub shaderStorageImageMultisample: VkBool32, + pub shaderStorageImageReadWithoutFormat: VkBool32, + pub shaderStorageImageWriteWithoutFormat: VkBool32, + pub shaderUniformBufferArrayDynamicIndexing: VkBool32, + pub shaderSampledImageArrayDynamicIndexing: VkBool32, + pub shaderStorageBufferArrayDynamicIndexing: VkBool32, + pub shaderStorageImageArrayDynamicIndexing: VkBool32, + pub shaderClipDistance: VkBool32, + pub shaderCullDistance: VkBool32, + pub shaderFloat64: VkBool32, + pub shaderInt64: VkBool32, + pub shaderInt16: VkBool32, + pub shaderResourceResidency: VkBool32, + pub shaderResourceMinLod: VkBool32, + pub sparseBinding: VkBool32, + pub sparseResidencyBuffer: VkBool32, + pub sparseResidencyImage2D: VkBool32, + pub sparseResidencyImage3D: VkBool32, + pub sparseResidency2Samples: VkBool32, + pub sparseResidency4Samples: VkBool32, + pub sparseResidency8Samples: VkBool32, + pub sparseResidency16Samples: VkBool32, + pub sparseResidencyAliased: VkBool32, + pub variableMultisampleRate: VkBool32, + pub inheritedQueries: VkBool32, +} +impl Clone for VkPhysicalDeviceFeatures { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkFormatProperties { + pub linearTilingFeatures: VkFormatFeatureFlags, + pub optimalTilingFeatures: VkFormatFeatureFlags, + pub bufferFeatures: VkFormatFeatureFlags, +} +impl Clone for VkFormatProperties { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExtent3D { + pub width: u32, + pub height: u32, + pub depth: u32, +} +impl Clone for VkExtent3D { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageFormatProperties { + pub maxExtent: VkExtent3D, + pub maxMipLevels: u32, + pub maxArrayLayers: u32, + pub sampleCounts: VkSampleCountFlags, + pub maxResourceSize: VkDeviceSize, +} +impl Clone for VkImageFormatProperties { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceLimits { + pub maxImageDimension1D: u32, + pub maxImageDimension2D: u32, + pub maxImageDimension3D: u32, + pub maxImageDimensionCube: u32, + pub maxImageArrayLayers: u32, + pub maxTexelBufferElements: u32, + pub maxUniformBufferRange: u32, + pub maxStorageBufferRange: u32, + pub maxPushConstantsSize: u32, + pub maxMemoryAllocationCount: u32, + pub maxSamplerAllocationCount: u32, + pub bufferImageGranularity: VkDeviceSize, + pub sparseAddressSpaceSize: VkDeviceSize, + pub maxBoundDescriptorSets: u32, + pub maxPerStageDescriptorSamplers: u32, + pub maxPerStageDescriptorUniformBuffers: u32, + pub maxPerStageDescriptorStorageBuffers: u32, + pub maxPerStageDescriptorSampledImages: u32, + pub maxPerStageDescriptorStorageImages: u32, + pub maxPerStageDescriptorInputAttachments: u32, + pub maxPerStageResources: u32, + pub maxDescriptorSetSamplers: u32, + pub maxDescriptorSetUniformBuffers: u32, + pub maxDescriptorSetUniformBuffersDynamic: u32, + pub maxDescriptorSetStorageBuffers: u32, + pub maxDescriptorSetStorageBuffersDynamic: u32, + pub maxDescriptorSetSampledImages: u32, + pub maxDescriptorSetStorageImages: u32, + pub maxDescriptorSetInputAttachments: u32, + pub maxVertexInputAttributes: u32, + pub maxVertexInputBindings: u32, + pub maxVertexInputAttributeOffset: u32, + pub maxVertexInputBindingStride: u32, + pub maxVertexOutputComponents: u32, + pub maxTessellationGenerationLevel: u32, + pub maxTessellationPatchSize: u32, + pub maxTessellationControlPerVertexInputComponents: u32, + pub maxTessellationControlPerVertexOutputComponents: u32, + pub maxTessellationControlPerPatchOutputComponents: u32, + pub maxTessellationControlTotalOutputComponents: u32, + pub maxTessellationEvaluationInputComponents: u32, + pub maxTessellationEvaluationOutputComponents: u32, + pub maxGeometryShaderInvocations: u32, + pub maxGeometryInputComponents: u32, + pub maxGeometryOutputComponents: u32, + pub maxGeometryOutputVertices: u32, + pub maxGeometryTotalOutputComponents: u32, + pub maxFragmentInputComponents: u32, + pub maxFragmentOutputAttachments: u32, + pub maxFragmentDualSrcAttachments: u32, + pub maxFragmentCombinedOutputResources: u32, + pub maxComputeSharedMemorySize: u32, + pub maxComputeWorkGroupCount: [u32; 3usize], + pub maxComputeWorkGroupInvocations: u32, + pub maxComputeWorkGroupSize: [u32; 3usize], + pub subPixelPrecisionBits: u32, + pub subTexelPrecisionBits: u32, + pub mipmapPrecisionBits: u32, + pub maxDrawIndexedIndexValue: u32, + pub maxDrawIndirectCount: u32, + pub maxSamplerLodBias: f32, + pub maxSamplerAnisotropy: f32, + pub maxViewports: u32, + pub maxViewportDimensions: [u32; 2usize], + pub viewportBoundsRange: [f32; 2usize], + pub viewportSubPixelBits: u32, + pub minMemoryMapAlignment: usize, + pub minTexelBufferOffsetAlignment: VkDeviceSize, + pub minUniformBufferOffsetAlignment: VkDeviceSize, + pub minStorageBufferOffsetAlignment: VkDeviceSize, + pub minTexelOffset: i32, + pub maxTexelOffset: u32, + pub minTexelGatherOffset: i32, + pub maxTexelGatherOffset: u32, + pub minInterpolationOffset: f32, + pub maxInterpolationOffset: f32, + pub subPixelInterpolationOffsetBits: u32, + pub maxFramebufferWidth: u32, + pub maxFramebufferHeight: u32, + pub maxFramebufferLayers: u32, + pub framebufferColorSampleCounts: VkSampleCountFlags, + pub framebufferDepthSampleCounts: VkSampleCountFlags, + pub framebufferStencilSampleCounts: VkSampleCountFlags, + pub framebufferNoAttachmentsSampleCounts: VkSampleCountFlags, + pub maxColorAttachments: u32, + pub sampledImageColorSampleCounts: VkSampleCountFlags, + pub sampledImageIntegerSampleCounts: VkSampleCountFlags, + pub sampledImageDepthSampleCounts: VkSampleCountFlags, + pub sampledImageStencilSampleCounts: VkSampleCountFlags, + pub storageImageSampleCounts: VkSampleCountFlags, + pub maxSampleMaskWords: u32, + pub timestampComputeAndGraphics: VkBool32, + pub timestampPeriod: f32, + pub maxClipDistances: u32, + pub maxCullDistances: u32, + pub maxCombinedClipAndCullDistances: u32, + pub discreteQueuePriorities: u32, + pub pointSizeRange: [f32; 2usize], + pub lineWidthRange: [f32; 2usize], + pub pointSizeGranularity: f32, + pub lineWidthGranularity: f32, + pub strictLines: VkBool32, + pub standardSampleLocations: VkBool32, + pub optimalBufferCopyOffsetAlignment: VkDeviceSize, + pub optimalBufferCopyRowPitchAlignment: VkDeviceSize, + pub nonCoherentAtomSize: VkDeviceSize, +} +impl Clone for VkPhysicalDeviceLimits { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceSparseProperties { + pub residencyStandard2DBlockShape: VkBool32, + pub residencyStandard2DMultisampleBlockShape: VkBool32, + pub residencyStandard3DBlockShape: VkBool32, + pub residencyAlignedMipSize: VkBool32, + pub residencyNonResidentStrict: VkBool32, +} +impl Clone for VkPhysicalDeviceSparseProperties { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct VkPhysicalDeviceProperties { + pub apiVersion: u32, + pub driverVersion: u32, + pub vendorID: u32, + pub deviceID: u32, + pub deviceType: VkPhysicalDeviceType, + pub deviceName: [::std::os::raw::c_char; 256usize], + pub pipelineCacheUUID: [u8; 16usize], + pub limits: VkPhysicalDeviceLimits, + pub sparseProperties: VkPhysicalDeviceSparseProperties, +} +impl Clone for VkPhysicalDeviceProperties { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkQueueFamilyProperties { + pub queueFlags: VkQueueFlags, + pub queueCount: u32, + pub timestampValidBits: u32, + pub minImageTransferGranularity: VkExtent3D, +} +impl Clone for VkQueueFamilyProperties { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkMemoryType { + pub propertyFlags: VkMemoryPropertyFlags, + pub heapIndex: u32, +} +impl Clone for VkMemoryType { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkMemoryHeap { + pub size: VkDeviceSize, + pub flags: VkMemoryHeapFlags, +} +impl Clone for VkMemoryHeap { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceMemoryProperties { + pub memoryTypeCount: u32, + pub memoryTypes: [VkMemoryType; 32usize], + pub memoryHeapCount: u32, + pub memoryHeaps: [VkMemoryHeap; 16usize], +} +impl Clone for VkPhysicalDeviceMemoryProperties { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceQueueCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkDeviceQueueCreateFlags, + pub queueFamilyIndex: u32, + pub queueCount: u32, + pub pQueuePriorities: *const f32, +} +impl Clone for VkDeviceQueueCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkDeviceCreateFlags, + pub queueCreateInfoCount: u32, + pub pQueueCreateInfos: *const VkDeviceQueueCreateInfo, + pub enabledLayerCount: u32, + pub ppEnabledLayerNames: *const *const ::std::os::raw::c_char, + pub enabledExtensionCount: u32, + pub ppEnabledExtensionNames: *const *const ::std::os::raw::c_char, + pub pEnabledFeatures: *const VkPhysicalDeviceFeatures, +} +impl Clone for VkDeviceCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct VkExtensionProperties { + pub extensionName: [::std::os::raw::c_char; 256usize], + pub specVersion: u32, +} +impl Clone for VkExtensionProperties { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct VkLayerProperties { + pub layerName: [::std::os::raw::c_char; 256usize], + pub specVersion: u32, + pub implementationVersion: u32, + pub description: [::std::os::raw::c_char; 256usize], +} +impl Clone for VkLayerProperties { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSubmitInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub waitSemaphoreCount: u32, + pub pWaitSemaphores: *const VkSemaphore, + pub pWaitDstStageMask: *const VkPipelineStageFlags, + pub commandBufferCount: u32, + pub pCommandBuffers: *const VkCommandBuffer, + pub signalSemaphoreCount: u32, + pub pSignalSemaphores: *const VkSemaphore, +} +impl Clone for VkSubmitInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkMemoryAllocateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub allocationSize: VkDeviceSize, + pub memoryTypeIndex: u32, +} +impl Clone for VkMemoryAllocateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkMappedMemoryRange { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub memory: VkDeviceMemory, + pub offset: VkDeviceSize, + pub size: VkDeviceSize, +} +impl Clone for VkMappedMemoryRange { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkMemoryRequirements { + pub size: VkDeviceSize, + pub alignment: VkDeviceSize, + pub memoryTypeBits: u32, +} +impl Clone for VkMemoryRequirements { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSparseImageFormatProperties { + pub aspectMask: VkImageAspectFlags, + pub imageGranularity: VkExtent3D, + pub flags: VkSparseImageFormatFlags, +} +impl Clone for VkSparseImageFormatProperties { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSparseImageMemoryRequirements { + pub formatProperties: VkSparseImageFormatProperties, + pub imageMipTailFirstLod: u32, + pub imageMipTailSize: VkDeviceSize, + pub imageMipTailOffset: VkDeviceSize, + pub imageMipTailStride: VkDeviceSize, +} +impl Clone for VkSparseImageMemoryRequirements { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSparseMemoryBind { + pub resourceOffset: VkDeviceSize, + pub size: VkDeviceSize, + pub memory: VkDeviceMemory, + pub memoryOffset: VkDeviceSize, + pub flags: VkSparseMemoryBindFlags, +} +impl Clone for VkSparseMemoryBind { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSparseBufferMemoryBindInfo { + pub buffer: VkBuffer, + pub bindCount: u32, + pub pBinds: *const VkSparseMemoryBind, +} +impl Clone for VkSparseBufferMemoryBindInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSparseImageOpaqueMemoryBindInfo { + pub image: VkImage, + pub bindCount: u32, + pub pBinds: *const VkSparseMemoryBind, +} +impl Clone for VkSparseImageOpaqueMemoryBindInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageSubresource { + pub aspectMask: VkImageAspectFlags, + pub mipLevel: u32, + pub arrayLayer: u32, +} +impl Clone for VkImageSubresource { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkOffset3D { + pub x: i32, + pub y: i32, + pub z: i32, +} +impl Clone for VkOffset3D { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSparseImageMemoryBind { + pub subresource: VkImageSubresource, + pub offset: VkOffset3D, + pub extent: VkExtent3D, + pub memory: VkDeviceMemory, + pub memoryOffset: VkDeviceSize, + pub flags: VkSparseMemoryBindFlags, +} +impl Clone for VkSparseImageMemoryBind { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSparseImageMemoryBindInfo { + pub image: VkImage, + pub bindCount: u32, + pub pBinds: *const VkSparseImageMemoryBind, +} +impl Clone for VkSparseImageMemoryBindInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkBindSparseInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub waitSemaphoreCount: u32, + pub pWaitSemaphores: *const VkSemaphore, + pub bufferBindCount: u32, + pub pBufferBinds: *const VkSparseBufferMemoryBindInfo, + pub imageOpaqueBindCount: u32, + pub pImageOpaqueBinds: *const VkSparseImageOpaqueMemoryBindInfo, + pub imageBindCount: u32, + pub pImageBinds: *const VkSparseImageMemoryBindInfo, + pub signalSemaphoreCount: u32, + pub pSignalSemaphores: *const VkSemaphore, +} +impl Clone for VkBindSparseInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkFenceCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkFenceCreateFlags, +} +impl Clone for VkFenceCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSemaphoreCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkSemaphoreCreateFlags, +} +impl Clone for VkSemaphoreCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkEventCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkEventCreateFlags, +} +impl Clone for VkEventCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkQueryPoolCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkQueryPoolCreateFlags, + pub queryType: VkQueryType, + pub queryCount: u32, + pub pipelineStatistics: VkQueryPipelineStatisticFlags, +} +impl Clone for VkQueryPoolCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkBufferCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkBufferCreateFlags, + pub size: VkDeviceSize, + pub usage: VkBufferUsageFlags, + pub sharingMode: VkSharingMode, + pub queueFamilyIndexCount: u32, + pub pQueueFamilyIndices: *const u32, +} +impl Clone for VkBufferCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkBufferViewCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkBufferViewCreateFlags, + pub buffer: VkBuffer, + pub format: VkFormat, + pub offset: VkDeviceSize, + pub range: VkDeviceSize, +} +impl Clone for VkBufferViewCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkImageCreateFlags, + pub imageType: VkImageType, + pub format: VkFormat, + pub extent: VkExtent3D, + pub mipLevels: u32, + pub arrayLayers: u32, + pub samples: VkSampleCountFlagBits, + pub tiling: VkImageTiling, + pub usage: VkImageUsageFlags, + pub sharingMode: VkSharingMode, + pub queueFamilyIndexCount: u32, + pub pQueueFamilyIndices: *const u32, + pub initialLayout: VkImageLayout, +} +impl Clone for VkImageCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSubresourceLayout { + pub offset: VkDeviceSize, + pub size: VkDeviceSize, + pub rowPitch: VkDeviceSize, + pub arrayPitch: VkDeviceSize, + pub depthPitch: VkDeviceSize, +} +impl Clone for VkSubresourceLayout { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkComponentMapping { + pub r: VkComponentSwizzle, + pub g: VkComponentSwizzle, + pub b: VkComponentSwizzle, + pub a: VkComponentSwizzle, +} +impl Clone for VkComponentMapping { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageSubresourceRange { + pub aspectMask: VkImageAspectFlags, + pub baseMipLevel: u32, + pub levelCount: u32, + pub baseArrayLayer: u32, + pub layerCount: u32, +} +impl Clone for VkImageSubresourceRange { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageViewCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkImageViewCreateFlags, + pub image: VkImage, + pub viewType: VkImageViewType, + pub format: VkFormat, + pub components: VkComponentMapping, + pub subresourceRange: VkImageSubresourceRange, +} +impl Clone for VkImageViewCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkShaderModuleCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkShaderModuleCreateFlags, + pub codeSize: usize, + pub pCode: *const u32, +} +impl Clone for VkShaderModuleCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineCacheCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineCacheCreateFlags, + pub initialDataSize: usize, + pub pInitialData: *const ::std::os::raw::c_void, +} +impl Clone for VkPipelineCacheCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSpecializationMapEntry { + pub constantID: u32, + pub offset: u32, + pub size: usize, +} +impl Clone for VkSpecializationMapEntry { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSpecializationInfo { + pub mapEntryCount: u32, + pub pMapEntries: *const VkSpecializationMapEntry, + pub dataSize: usize, + pub pData: *const ::std::os::raw::c_void, +} +impl Clone for VkSpecializationInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineShaderStageCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineShaderStageCreateFlags, + pub stage: VkShaderStageFlagBits, + pub module: VkShaderModule, + pub pName: *const ::std::os::raw::c_char, + pub pSpecializationInfo: *const VkSpecializationInfo, +} +impl Clone for VkPipelineShaderStageCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkVertexInputBindingDescription { + pub binding: u32, + pub stride: u32, + pub inputRate: VkVertexInputRate, +} +impl Clone for VkVertexInputBindingDescription { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkVertexInputAttributeDescription { + pub location: u32, + pub binding: u32, + pub format: VkFormat, + pub offset: u32, +} +impl Clone for VkVertexInputAttributeDescription { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineVertexInputStateCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineVertexInputStateCreateFlags, + pub vertexBindingDescriptionCount: u32, + pub pVertexBindingDescriptions: *const VkVertexInputBindingDescription, + pub vertexAttributeDescriptionCount: u32, + pub pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription, +} +impl Clone for VkPipelineVertexInputStateCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineInputAssemblyStateCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineInputAssemblyStateCreateFlags, + pub topology: VkPrimitiveTopology, + pub primitiveRestartEnable: VkBool32, +} +impl Clone for VkPipelineInputAssemblyStateCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineTessellationStateCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineTessellationStateCreateFlags, + pub patchControlPoints: u32, +} +impl Clone for VkPipelineTessellationStateCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkViewport { + pub x: f32, + pub y: f32, + pub width: f32, + pub height: f32, + pub minDepth: f32, + pub maxDepth: f32, +} +impl Clone for VkViewport { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkOffset2D { + pub x: i32, + pub y: i32, +} +impl Clone for VkOffset2D { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExtent2D { + pub width: u32, + pub height: u32, +} +impl Clone for VkExtent2D { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkRect2D { + pub offset: VkOffset2D, + pub extent: VkExtent2D, +} +impl Clone for VkRect2D { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineViewportStateCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineViewportStateCreateFlags, + pub viewportCount: u32, + pub pViewports: *const VkViewport, + pub scissorCount: u32, + pub pScissors: *const VkRect2D, +} +impl Clone for VkPipelineViewportStateCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineRasterizationStateCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineRasterizationStateCreateFlags, + pub depthClampEnable: VkBool32, + pub rasterizerDiscardEnable: VkBool32, + pub polygonMode: VkPolygonMode, + pub cullMode: VkCullModeFlags, + pub frontFace: VkFrontFace, + pub depthBiasEnable: VkBool32, + pub depthBiasConstantFactor: f32, + pub depthBiasClamp: f32, + pub depthBiasSlopeFactor: f32, + pub lineWidth: f32, +} +impl Clone for VkPipelineRasterizationStateCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineMultisampleStateCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineMultisampleStateCreateFlags, + pub rasterizationSamples: VkSampleCountFlagBits, + pub sampleShadingEnable: VkBool32, + pub minSampleShading: f32, + pub pSampleMask: *const VkSampleMask, + pub alphaToCoverageEnable: VkBool32, + pub alphaToOneEnable: VkBool32, +} +impl Clone for VkPipelineMultisampleStateCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkStencilOpState { + pub failOp: VkStencilOp, + pub passOp: VkStencilOp, + pub depthFailOp: VkStencilOp, + pub compareOp: VkCompareOp, + pub compareMask: u32, + pub writeMask: u32, + pub reference: u32, +} +impl Clone for VkStencilOpState { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineDepthStencilStateCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineDepthStencilStateCreateFlags, + pub depthTestEnable: VkBool32, + pub depthWriteEnable: VkBool32, + pub depthCompareOp: VkCompareOp, + pub depthBoundsTestEnable: VkBool32, + pub stencilTestEnable: VkBool32, + pub front: VkStencilOpState, + pub back: VkStencilOpState, + pub minDepthBounds: f32, + pub maxDepthBounds: f32, +} +impl Clone for VkPipelineDepthStencilStateCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineColorBlendAttachmentState { + pub blendEnable: VkBool32, + pub srcColorBlendFactor: VkBlendFactor, + pub dstColorBlendFactor: VkBlendFactor, + pub colorBlendOp: VkBlendOp, + pub srcAlphaBlendFactor: VkBlendFactor, + pub dstAlphaBlendFactor: VkBlendFactor, + pub alphaBlendOp: VkBlendOp, + pub colorWriteMask: VkColorComponentFlags, +} +impl Clone for VkPipelineColorBlendAttachmentState { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineColorBlendStateCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineColorBlendStateCreateFlags, + pub logicOpEnable: VkBool32, + pub logicOp: VkLogicOp, + pub attachmentCount: u32, + pub pAttachments: *const VkPipelineColorBlendAttachmentState, + pub blendConstants: [f32; 4usize], +} +impl Clone for VkPipelineColorBlendStateCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineDynamicStateCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineDynamicStateCreateFlags, + pub dynamicStateCount: u32, + pub pDynamicStates: *const VkDynamicState, +} +impl Clone for VkPipelineDynamicStateCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkGraphicsPipelineCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineCreateFlags, + pub stageCount: u32, + pub pStages: *const VkPipelineShaderStageCreateInfo, + pub pVertexInputState: *const VkPipelineVertexInputStateCreateInfo, + pub pInputAssemblyState: *const VkPipelineInputAssemblyStateCreateInfo, + pub pTessellationState: *const VkPipelineTessellationStateCreateInfo, + pub pViewportState: *const VkPipelineViewportStateCreateInfo, + pub pRasterizationState: *const VkPipelineRasterizationStateCreateInfo, + pub pMultisampleState: *const VkPipelineMultisampleStateCreateInfo, + pub pDepthStencilState: *const VkPipelineDepthStencilStateCreateInfo, + pub pColorBlendState: *const VkPipelineColorBlendStateCreateInfo, + pub pDynamicState: *const VkPipelineDynamicStateCreateInfo, + pub layout: VkPipelineLayout, + pub renderPass: VkRenderPass, + pub subpass: u32, + pub basePipelineHandle: VkPipeline, + pub basePipelineIndex: i32, +} +impl Clone for VkGraphicsPipelineCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkComputePipelineCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineCreateFlags, + pub stage: VkPipelineShaderStageCreateInfo, + pub layout: VkPipelineLayout, + pub basePipelineHandle: VkPipeline, + pub basePipelineIndex: i32, +} +impl Clone for VkComputePipelineCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPushConstantRange { + pub stageFlags: VkShaderStageFlags, + pub offset: u32, + pub size: u32, +} +impl Clone for VkPushConstantRange { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineLayoutCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineLayoutCreateFlags, + pub setLayoutCount: u32, + pub pSetLayouts: *const VkDescriptorSetLayout, + pub pushConstantRangeCount: u32, + pub pPushConstantRanges: *const VkPushConstantRange, +} +impl Clone for VkPipelineLayoutCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSamplerCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkSamplerCreateFlags, + pub magFilter: VkFilter, + pub minFilter: VkFilter, + pub mipmapMode: VkSamplerMipmapMode, + pub addressModeU: VkSamplerAddressMode, + pub addressModeV: VkSamplerAddressMode, + pub addressModeW: VkSamplerAddressMode, + pub mipLodBias: f32, + pub anisotropyEnable: VkBool32, + pub maxAnisotropy: f32, + pub compareEnable: VkBool32, + pub compareOp: VkCompareOp, + pub minLod: f32, + pub maxLod: f32, + pub borderColor: VkBorderColor, + pub unnormalizedCoordinates: VkBool32, +} +impl Clone for VkSamplerCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDescriptorSetLayoutBinding { + pub binding: u32, + pub descriptorType: VkDescriptorType, + pub descriptorCount: u32, + pub stageFlags: VkShaderStageFlags, + pub pImmutableSamplers: *const VkSampler, +} +impl Clone for VkDescriptorSetLayoutBinding { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDescriptorSetLayoutCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkDescriptorSetLayoutCreateFlags, + pub bindingCount: u32, + pub pBindings: *const VkDescriptorSetLayoutBinding, +} +impl Clone for VkDescriptorSetLayoutCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDescriptorPoolSize { + pub type_: VkDescriptorType, + pub descriptorCount: u32, +} +impl Clone for VkDescriptorPoolSize { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDescriptorPoolCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkDescriptorPoolCreateFlags, + pub maxSets: u32, + pub poolSizeCount: u32, + pub pPoolSizes: *const VkDescriptorPoolSize, +} +impl Clone for VkDescriptorPoolCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDescriptorSetAllocateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub descriptorPool: VkDescriptorPool, + pub descriptorSetCount: u32, + pub pSetLayouts: *const VkDescriptorSetLayout, +} +impl Clone for VkDescriptorSetAllocateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDescriptorImageInfo { + pub sampler: VkSampler, + pub imageView: VkImageView, + pub imageLayout: VkImageLayout, +} +impl Clone for VkDescriptorImageInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDescriptorBufferInfo { + pub buffer: VkBuffer, + pub offset: VkDeviceSize, + pub range: VkDeviceSize, +} +impl Clone for VkDescriptorBufferInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkWriteDescriptorSet { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub dstSet: VkDescriptorSet, + pub dstBinding: u32, + pub dstArrayElement: u32, + pub descriptorCount: u32, + pub descriptorType: VkDescriptorType, + pub pImageInfo: *const VkDescriptorImageInfo, + pub pBufferInfo: *const VkDescriptorBufferInfo, + pub pTexelBufferView: *const VkBufferView, +} +impl Clone for VkWriteDescriptorSet { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkCopyDescriptorSet { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub srcSet: VkDescriptorSet, + pub srcBinding: u32, + pub srcArrayElement: u32, + pub dstSet: VkDescriptorSet, + pub dstBinding: u32, + pub dstArrayElement: u32, + pub descriptorCount: u32, +} +impl Clone for VkCopyDescriptorSet { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkFramebufferCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkFramebufferCreateFlags, + pub renderPass: VkRenderPass, + pub attachmentCount: u32, + pub pAttachments: *const VkImageView, + pub width: u32, + pub height: u32, + pub layers: u32, +} +impl Clone for VkFramebufferCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkAttachmentDescription { + pub flags: VkAttachmentDescriptionFlags, + pub format: VkFormat, + pub samples: VkSampleCountFlagBits, + pub loadOp: VkAttachmentLoadOp, + pub storeOp: VkAttachmentStoreOp, + pub stencilLoadOp: VkAttachmentLoadOp, + pub stencilStoreOp: VkAttachmentStoreOp, + pub initialLayout: VkImageLayout, + pub finalLayout: VkImageLayout, +} +impl Clone for VkAttachmentDescription { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkAttachmentReference { + pub attachment: u32, + pub layout: VkImageLayout, +} +impl Clone for VkAttachmentReference { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSubpassDescription { + pub flags: VkSubpassDescriptionFlags, + pub pipelineBindPoint: VkPipelineBindPoint, + pub inputAttachmentCount: u32, + pub pInputAttachments: *const VkAttachmentReference, + pub colorAttachmentCount: u32, + pub pColorAttachments: *const VkAttachmentReference, + pub pResolveAttachments: *const VkAttachmentReference, + pub pDepthStencilAttachment: *const VkAttachmentReference, + pub preserveAttachmentCount: u32, + pub pPreserveAttachments: *const u32, +} +impl Clone for VkSubpassDescription { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSubpassDependency { + pub srcSubpass: u32, + pub dstSubpass: u32, + pub srcStageMask: VkPipelineStageFlags, + pub dstStageMask: VkPipelineStageFlags, + pub srcAccessMask: VkAccessFlags, + pub dstAccessMask: VkAccessFlags, + pub dependencyFlags: VkDependencyFlags, +} +impl Clone for VkSubpassDependency { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkRenderPassCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkRenderPassCreateFlags, + pub attachmentCount: u32, + pub pAttachments: *const VkAttachmentDescription, + pub subpassCount: u32, + pub pSubpasses: *const VkSubpassDescription, + pub dependencyCount: u32, + pub pDependencies: *const VkSubpassDependency, +} +impl Clone for VkRenderPassCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkCommandPoolCreateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkCommandPoolCreateFlags, + pub queueFamilyIndex: u32, +} +impl Clone for VkCommandPoolCreateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkCommandBufferAllocateInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub commandPool: VkCommandPool, + pub level: VkCommandBufferLevel, + pub commandBufferCount: u32, +} +impl Clone for VkCommandBufferAllocateInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkCommandBufferInheritanceInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub renderPass: VkRenderPass, + pub subpass: u32, + pub framebuffer: VkFramebuffer, + pub occlusionQueryEnable: VkBool32, + pub queryFlags: VkQueryControlFlags, + pub pipelineStatistics: VkQueryPipelineStatisticFlags, +} +impl Clone for VkCommandBufferInheritanceInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkCommandBufferBeginInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkCommandBufferUsageFlags, + pub pInheritanceInfo: *const VkCommandBufferInheritanceInfo, +} +impl Clone for VkCommandBufferBeginInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkBufferCopy { + pub srcOffset: VkDeviceSize, + pub dstOffset: VkDeviceSize, + pub size: VkDeviceSize, +} +impl Clone for VkBufferCopy { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageSubresourceLayers { + pub aspectMask: VkImageAspectFlags, + pub mipLevel: u32, + pub baseArrayLayer: u32, + pub layerCount: u32, +} +impl Clone for VkImageSubresourceLayers { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageCopy { + pub srcSubresource: VkImageSubresourceLayers, + pub srcOffset: VkOffset3D, + pub dstSubresource: VkImageSubresourceLayers, + pub dstOffset: VkOffset3D, + pub extent: VkExtent3D, +} +impl Clone for VkImageCopy { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageBlit { + pub srcSubresource: VkImageSubresourceLayers, + pub srcOffsets: [VkOffset3D; 2usize], + pub dstSubresource: VkImageSubresourceLayers, + pub dstOffsets: [VkOffset3D; 2usize], +} +impl Clone for VkImageBlit { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkBufferImageCopy { + pub bufferOffset: VkDeviceSize, + pub bufferRowLength: u32, + pub bufferImageHeight: u32, + pub imageSubresource: VkImageSubresourceLayers, + pub imageOffset: VkOffset3D, + pub imageExtent: VkExtent3D, +} +impl Clone for VkBufferImageCopy { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub union VkClearColorValue { + pub float32: [f32; 4usize], + pub int32: [i32; 4usize], + pub uint32: [u32; 4usize], + _bindgen_union_align: [u32; 4usize], +} +impl Clone for VkClearColorValue { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkClearDepthStencilValue { + pub depth: f32, + pub stencil: u32, +} +impl Clone for VkClearDepthStencilValue { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub union VkClearValue { + pub color: VkClearColorValue, + pub depthStencil: VkClearDepthStencilValue, + _bindgen_union_align: [u32; 4usize], +} +impl Clone for VkClearValue { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct VkClearAttachment { + pub aspectMask: VkImageAspectFlags, + pub colorAttachment: u32, + pub clearValue: VkClearValue, +} +impl Clone for VkClearAttachment { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkClearRect { + pub rect: VkRect2D, + pub baseArrayLayer: u32, + pub layerCount: u32, +} +impl Clone for VkClearRect { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageResolve { + pub srcSubresource: VkImageSubresourceLayers, + pub srcOffset: VkOffset3D, + pub dstSubresource: VkImageSubresourceLayers, + pub dstOffset: VkOffset3D, + pub extent: VkExtent3D, +} +impl Clone for VkImageResolve { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkMemoryBarrier { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub srcAccessMask: VkAccessFlags, + pub dstAccessMask: VkAccessFlags, +} +impl Clone for VkMemoryBarrier { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkBufferMemoryBarrier { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub srcAccessMask: VkAccessFlags, + pub dstAccessMask: VkAccessFlags, + pub srcQueueFamilyIndex: u32, + pub dstQueueFamilyIndex: u32, + pub buffer: VkBuffer, + pub offset: VkDeviceSize, + pub size: VkDeviceSize, +} +impl Clone for VkBufferMemoryBarrier { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageMemoryBarrier { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub srcAccessMask: VkAccessFlags, + pub dstAccessMask: VkAccessFlags, + pub oldLayout: VkImageLayout, + pub newLayout: VkImageLayout, + pub srcQueueFamilyIndex: u32, + pub dstQueueFamilyIndex: u32, + pub image: VkImage, + pub subresourceRange: VkImageSubresourceRange, +} +impl Clone for VkImageMemoryBarrier { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkRenderPassBeginInfo { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub renderPass: VkRenderPass, + pub framebuffer: VkFramebuffer, + pub renderArea: VkRect2D, + pub clearValueCount: u32, + pub pClearValues: *const VkClearValue, +} +impl Clone for VkRenderPassBeginInfo { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDispatchIndirectCommand { + pub x: u32, + pub y: u32, + pub z: u32, +} +impl Clone for VkDispatchIndirectCommand { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDrawIndexedIndirectCommand { + pub indexCount: u32, + pub instanceCount: u32, + pub firstIndex: u32, + pub vertexOffset: i32, + pub firstInstance: u32, +} +impl Clone for VkDrawIndexedIndirectCommand { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDrawIndirectCommand { + pub vertexCount: u32, + pub instanceCount: u32, + pub firstVertex: u32, + pub firstInstance: u32, +} +impl Clone for VkDrawIndirectCommand { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkCreateInstance = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyInstance = + ::std::option::Option; +pub type PFN_vkEnumeratePhysicalDevices = + ::std::option::Option VkResult>; +pub type PFN_vkGetPhysicalDeviceFeatures = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceFormatProperties = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceImageFormatProperties = + ::std::option::Option VkResult>; +pub type PFN_vkGetPhysicalDeviceProperties = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceMemoryProperties = + ::std::option::Option; +pub type PFN_vkGetInstanceProcAddr = + ::std::option::Option PFN_vkVoidFunction>; +pub type PFN_vkGetDeviceProcAddr = + ::std::option::Option PFN_vkVoidFunction>; +pub type PFN_vkCreateDevice = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyDevice = + ::std::option::Option; +pub type PFN_vkEnumerateInstanceExtensionProperties = + ::std::option::Option VkResult>; +pub type PFN_vkEnumerateDeviceExtensionProperties = + ::std::option::Option VkResult>; +pub type PFN_vkEnumerateInstanceLayerProperties = + ::std::option::Option VkResult>; +pub type PFN_vkEnumerateDeviceLayerProperties = + ::std::option::Option VkResult>; +pub type PFN_vkGetDeviceQueue = + ::std::option::Option; +pub type PFN_vkQueueSubmit = + ::std::option::Option VkResult>; +pub type PFN_vkQueueWaitIdle = + ::std::option::Option VkResult>; +pub type PFN_vkDeviceWaitIdle = + ::std::option::Option VkResult>; +pub type PFN_vkAllocateMemory = + ::std::option::Option VkResult>; +pub type PFN_vkFreeMemory = + ::std::option::Option; +pub type PFN_vkMapMemory = + ::std::option::Option VkResult>; +pub type PFN_vkUnmapMemory = + ::std::option::Option; +pub type PFN_vkFlushMappedMemoryRanges = + ::std::option::Option VkResult>; +pub type PFN_vkInvalidateMappedMemoryRanges = + ::std::option::Option VkResult>; +pub type PFN_vkGetDeviceMemoryCommitment = + ::std::option::Option; +pub type PFN_vkBindBufferMemory = + ::std::option::Option VkResult>; +pub type PFN_vkBindImageMemory = + ::std::option::Option VkResult>; +pub type PFN_vkGetBufferMemoryRequirements = + ::std::option::Option; +pub type PFN_vkGetImageMemoryRequirements = + ::std::option::Option; +pub type PFN_vkGetImageSparseMemoryRequirements = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = + ::std::option::Option; +pub type PFN_vkQueueBindSparse = + ::std::option::Option VkResult>; +pub type PFN_vkCreateFence = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyFence = + ::std::option::Option; +pub type PFN_vkResetFences = + ::std::option::Option VkResult>; +pub type PFN_vkGetFenceStatus = + ::std::option::Option VkResult>; +pub type PFN_vkWaitForFences = + ::std::option::Option VkResult>; +pub type PFN_vkCreateSemaphore = + ::std::option::Option VkResult>; +pub type PFN_vkDestroySemaphore = + ::std::option::Option; +pub type PFN_vkCreateEvent = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyEvent = + ::std::option::Option; +pub type PFN_vkGetEventStatus = + ::std::option::Option VkResult>; +pub type PFN_vkSetEvent = + ::std::option::Option VkResult>; +pub type PFN_vkResetEvent = + ::std::option::Option VkResult>; +pub type PFN_vkCreateQueryPool = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyQueryPool = + ::std::option::Option; +pub type PFN_vkGetQueryPoolResults = + ::std::option::Option VkResult>; +pub type PFN_vkCreateBuffer = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyBuffer = + ::std::option::Option; +pub type PFN_vkCreateBufferView = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyBufferView = + ::std::option::Option; +pub type PFN_vkCreateImage = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyImage = + ::std::option::Option; +pub type PFN_vkGetImageSubresourceLayout = + ::std::option::Option; +pub type PFN_vkCreateImageView = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyImageView = + ::std::option::Option; +pub type PFN_vkCreateShaderModule = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyShaderModule = + ::std::option::Option; +pub type PFN_vkCreatePipelineCache = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyPipelineCache = + ::std::option::Option; +pub type PFN_vkGetPipelineCacheData = + ::std::option::Option VkResult>; +pub type PFN_vkMergePipelineCaches = + ::std::option::Option VkResult>; +pub type PFN_vkCreateGraphicsPipelines = + ::std::option::Option VkResult>; +pub type PFN_vkCreateComputePipelines = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyPipeline = + ::std::option::Option; +pub type PFN_vkCreatePipelineLayout = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyPipelineLayout = + ::std::option::Option; +pub type PFN_vkCreateSampler = + ::std::option::Option VkResult>; +pub type PFN_vkDestroySampler = + ::std::option::Option; +pub type PFN_vkCreateDescriptorSetLayout = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyDescriptorSetLayout = + ::std::option::Option; +pub type PFN_vkCreateDescriptorPool = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyDescriptorPool = + ::std::option::Option; +pub type PFN_vkResetDescriptorPool = + ::std::option::Option VkResult>; +pub type PFN_vkAllocateDescriptorSets = + ::std::option::Option VkResult>; +pub type PFN_vkFreeDescriptorSets = + ::std::option::Option VkResult>; +pub type PFN_vkUpdateDescriptorSets = + ::std::option::Option; +pub type PFN_vkCreateFramebuffer = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyFramebuffer = + ::std::option::Option; +pub type PFN_vkCreateRenderPass = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyRenderPass = + ::std::option::Option; +pub type PFN_vkGetRenderAreaGranularity = + ::std::option::Option; +pub type PFN_vkCreateCommandPool = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyCommandPool = + ::std::option::Option; +pub type PFN_vkResetCommandPool = + ::std::option::Option VkResult>; +pub type PFN_vkAllocateCommandBuffers = + ::std::option::Option VkResult>; +pub type PFN_vkFreeCommandBuffers = + ::std::option::Option; +pub type PFN_vkBeginCommandBuffer = + ::std::option::Option VkResult>; +pub type PFN_vkEndCommandBuffer = + ::std::option::Option VkResult>; +pub type PFN_vkResetCommandBuffer = + ::std::option::Option VkResult>; +pub type PFN_vkCmdBindPipeline = + ::std::option::Option; +pub type PFN_vkCmdSetViewport = + ::std::option::Option; +pub type PFN_vkCmdSetScissor = + ::std::option::Option; +pub type PFN_vkCmdSetLineWidth = + ::std::option::Option; +pub type PFN_vkCmdSetDepthBias = + ::std::option::Option; +pub type PFN_vkCmdSetBlendConstants = + ::std::option::Option; +pub type PFN_vkCmdSetDepthBounds = + ::std::option::Option; +pub type PFN_vkCmdSetStencilCompareMask = + ::std::option::Option; +pub type PFN_vkCmdSetStencilWriteMask = + ::std::option::Option; +pub type PFN_vkCmdSetStencilReference = + ::std::option::Option; +pub type PFN_vkCmdBindDescriptorSets = + ::std::option::Option; +pub type PFN_vkCmdBindIndexBuffer = + ::std::option::Option; +pub type PFN_vkCmdBindVertexBuffers = + ::std::option::Option; +pub type PFN_vkCmdDraw = + ::std::option::Option; +pub type PFN_vkCmdDrawIndexed = + ::std::option::Option; +pub type PFN_vkCmdDrawIndirect = + ::std::option::Option; +pub type PFN_vkCmdDrawIndexedIndirect = + ::std::option::Option; +pub type PFN_vkCmdDispatch = + ::std::option::Option; +pub type PFN_vkCmdDispatchIndirect = + ::std::option::Option; +pub type PFN_vkCmdCopyBuffer = + ::std::option::Option; +pub type PFN_vkCmdCopyImage = + ::std::option::Option; +pub type PFN_vkCmdBlitImage = + ::std::option::Option; +pub type PFN_vkCmdCopyBufferToImage = + ::std::option::Option; +pub type PFN_vkCmdCopyImageToBuffer = + ::std::option::Option; +pub type PFN_vkCmdUpdateBuffer = + ::std::option::Option; +pub type PFN_vkCmdFillBuffer = + ::std::option::Option; +pub type PFN_vkCmdClearColorImage = + ::std::option::Option; +pub type PFN_vkCmdClearDepthStencilImage = + ::std::option::Option; +pub type PFN_vkCmdClearAttachments = + ::std::option::Option; +pub type PFN_vkCmdResolveImage = + ::std::option::Option; +pub type PFN_vkCmdSetEvent = + ::std::option::Option; +pub type PFN_vkCmdResetEvent = + ::std::option::Option; +pub type PFN_vkCmdWaitEvents = + ::std::option::Option; +pub type PFN_vkCmdPipelineBarrier = + ::std::option::Option; +pub type PFN_vkCmdBeginQuery = + ::std::option::Option; +pub type PFN_vkCmdEndQuery = + ::std::option::Option; +pub type PFN_vkCmdResetQueryPool = + ::std::option::Option; +pub type PFN_vkCmdWriteTimestamp = + ::std::option::Option; +pub type PFN_vkCmdCopyQueryPoolResults = + ::std::option::Option; +pub type PFN_vkCmdPushConstants = + ::std::option::Option; +pub type PFN_vkCmdBeginRenderPass = + ::std::option::Option; +pub type PFN_vkCmdNextSubpass = + ::std::option::Option; +pub type PFN_vkCmdEndRenderPass = + ::std::option::Option; +pub type PFN_vkCmdExecuteCommands = + ::std::option::Option; + +extern "C" { + pub fn vkEnumeratePhysicalDevices(instance: VkInstance, + pPhysicalDeviceCount: *mut u32, + pPhysicalDevices: *mut VkPhysicalDevice) + -> VkResult; +} +extern "C" { + pub fn vkGetPhysicalDeviceFeatures(physicalDevice: VkPhysicalDevice, + pFeatures: + *mut VkPhysicalDeviceFeatures); +} +extern "C" { + pub fn vkGetPhysicalDeviceFormatProperties(physicalDevice: + VkPhysicalDevice, + format: VkFormat, + pFormatProperties: + *mut VkFormatProperties); +} +extern "C" { + pub fn vkGetPhysicalDeviceImageFormatProperties(physicalDevice: + VkPhysicalDevice, + format: VkFormat, + type_: VkImageType, + tiling: VkImageTiling, + usage: VkImageUsageFlags, + flags: VkImageCreateFlags, + pImageFormatProperties: + *mut VkImageFormatProperties) + -> VkResult; +} +extern "C" { + pub fn vkGetPhysicalDeviceProperties(physicalDevice: VkPhysicalDevice, + pProperties: + *mut VkPhysicalDeviceProperties); +} +extern "C" { + pub fn vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice: + VkPhysicalDevice, + pQueueFamilyPropertyCount: + *mut u32, + pQueueFamilyProperties: + *mut VkQueueFamilyProperties); +} +extern "C" { + pub fn vkGetPhysicalDeviceMemoryProperties(physicalDevice: + VkPhysicalDevice, + pMemoryProperties: + *mut VkPhysicalDeviceMemoryProperties); +} +extern "C" { + pub fn vkGetInstanceProcAddr(instance: VkInstance, + pName: *const ::std::os::raw::c_char) + -> PFN_vkVoidFunction; +} +extern "C" { + pub fn vkGetDeviceProcAddr(device: VkDevice, + pName: *const ::std::os::raw::c_char) + -> PFN_vkVoidFunction; +} +extern "C" { + pub fn vkCreateDevice(physicalDevice: VkPhysicalDevice, + pCreateInfo: *const VkDeviceCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pDevice: *mut VkDevice) -> VkResult; +} +extern "C" { + pub fn vkDestroyDevice(device: VkDevice, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkEnumerateInstanceExtensionProperties(pLayerName: + *const ::std::os::raw::c_char, + pPropertyCount: *mut u32, + pProperties: + *mut VkExtensionProperties) + -> VkResult; +} +extern "C" { + pub fn vkEnumerateDeviceExtensionProperties(physicalDevice: + VkPhysicalDevice, + pLayerName: + *const ::std::os::raw::c_char, + pPropertyCount: *mut u32, + pProperties: + *mut VkExtensionProperties) + -> VkResult; +} +extern "C" { + pub fn vkEnumerateInstanceLayerProperties(pPropertyCount: *mut u32, + pProperties: + *mut VkLayerProperties) + -> VkResult; +} +extern "C" { + pub fn vkEnumerateDeviceLayerProperties(physicalDevice: VkPhysicalDevice, + pPropertyCount: *mut u32, + pProperties: + *mut VkLayerProperties) + -> VkResult; +} +extern "C" { + pub fn vkGetDeviceQueue(device: VkDevice, queueFamilyIndex: u32, + queueIndex: u32, pQueue: *mut VkQueue); +} +extern "C" { + pub fn vkQueueSubmit(queue: VkQueue, submitCount: u32, + pSubmits: *const VkSubmitInfo, fence: VkFence) + -> VkResult; +} +extern "C" { + pub fn vkQueueWaitIdle(queue: VkQueue) -> VkResult; +} +extern "C" { + pub fn vkDeviceWaitIdle(device: VkDevice) -> VkResult; +} +extern "C" { + pub fn vkAllocateMemory(device: VkDevice, + pAllocateInfo: *const VkMemoryAllocateInfo, + pAllocator: *const VkAllocationCallbacks, + pMemory: *mut VkDeviceMemory) -> VkResult; +} +extern "C" { + pub fn vkFreeMemory(device: VkDevice, memory: VkDeviceMemory, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkMapMemory(device: VkDevice, memory: VkDeviceMemory, + offset: VkDeviceSize, size: VkDeviceSize, + flags: VkMemoryMapFlags, + ppData: *mut *mut ::std::os::raw::c_void) -> VkResult; +} +extern "C" { + pub fn vkUnmapMemory(device: VkDevice, memory: VkDeviceMemory); +} +extern "C" { + pub fn vkFlushMappedMemoryRanges(device: VkDevice, memoryRangeCount: u32, + pMemoryRanges: + *const VkMappedMemoryRange) + -> VkResult; +} +extern "C" { + pub fn vkInvalidateMappedMemoryRanges(device: VkDevice, + memoryRangeCount: u32, + pMemoryRanges: + *const VkMappedMemoryRange) + -> VkResult; +} +extern "C" { + pub fn vkGetDeviceMemoryCommitment(device: VkDevice, + memory: VkDeviceMemory, + pCommittedMemoryInBytes: + *mut VkDeviceSize); +} +extern "C" { + pub fn vkBindBufferMemory(device: VkDevice, buffer: VkBuffer, + memory: VkDeviceMemory, + memoryOffset: VkDeviceSize) -> VkResult; +} +extern "C" { + pub fn vkBindImageMemory(device: VkDevice, image: VkImage, + memory: VkDeviceMemory, + memoryOffset: VkDeviceSize) -> VkResult; +} +extern "C" { + pub fn vkGetBufferMemoryRequirements(device: VkDevice, buffer: VkBuffer, + pMemoryRequirements: + *mut VkMemoryRequirements); +} +extern "C" { + pub fn vkGetImageMemoryRequirements(device: VkDevice, image: VkImage, + pMemoryRequirements: + *mut VkMemoryRequirements); +} +extern "C" { + pub fn vkGetImageSparseMemoryRequirements(device: VkDevice, + image: VkImage, + pSparseMemoryRequirementCount: + *mut u32, + pSparseMemoryRequirements: + *mut VkSparseImageMemoryRequirements); +} +extern "C" { + pub fn vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice: + VkPhysicalDevice, + format: VkFormat, + type_: VkImageType, + samples: + VkSampleCountFlagBits, + usage: + VkImageUsageFlags, + tiling: + VkImageTiling, + pPropertyCount: + *mut u32, + pProperties: + *mut VkSparseImageFormatProperties); +} +extern "C" { + pub fn vkQueueBindSparse(queue: VkQueue, bindInfoCount: u32, + pBindInfo: *const VkBindSparseInfo, + fence: VkFence) -> VkResult; +} +extern "C" { + pub fn vkCreateFence(device: VkDevice, + pCreateInfo: *const VkFenceCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pFence: *mut VkFence) -> VkResult; +} +extern "C" { + pub fn vkDestroyFence(device: VkDevice, fence: VkFence, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkResetFences(device: VkDevice, fenceCount: u32, + pFences: *const VkFence) -> VkResult; +} +extern "C" { + pub fn vkGetFenceStatus(device: VkDevice, fence: VkFence) -> VkResult; +} +extern "C" { + pub fn vkWaitForFences(device: VkDevice, fenceCount: u32, + pFences: *const VkFence, waitAll: VkBool32, + timeout: u64) -> VkResult; +} +extern "C" { + pub fn vkCreateSemaphore(device: VkDevice, + pCreateInfo: *const VkSemaphoreCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pSemaphore: *mut VkSemaphore) -> VkResult; +} +extern "C" { + pub fn vkDestroySemaphore(device: VkDevice, semaphore: VkSemaphore, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreateEvent(device: VkDevice, + pCreateInfo: *const VkEventCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pEvent: *mut VkEvent) -> VkResult; +} +extern "C" { + pub fn vkDestroyEvent(device: VkDevice, event: VkEvent, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkGetEventStatus(device: VkDevice, event: VkEvent) -> VkResult; +} +extern "C" { + pub fn vkSetEvent(device: VkDevice, event: VkEvent) -> VkResult; +} +extern "C" { + pub fn vkResetEvent(device: VkDevice, event: VkEvent) -> VkResult; +} +extern "C" { + pub fn vkCreateQueryPool(device: VkDevice, + pCreateInfo: *const VkQueryPoolCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pQueryPool: *mut VkQueryPool) -> VkResult; +} +extern "C" { + pub fn vkDestroyQueryPool(device: VkDevice, queryPool: VkQueryPool, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkGetQueryPoolResults(device: VkDevice, queryPool: VkQueryPool, + firstQuery: u32, queryCount: u32, + dataSize: usize, + pData: *mut ::std::os::raw::c_void, + stride: VkDeviceSize, + flags: VkQueryResultFlags) -> VkResult; +} +extern "C" { + pub fn vkCreateBuffer(device: VkDevice, + pCreateInfo: *const VkBufferCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pBuffer: *mut VkBuffer) -> VkResult; +} +extern "C" { + pub fn vkDestroyBuffer(device: VkDevice, buffer: VkBuffer, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreateBufferView(device: VkDevice, + pCreateInfo: *const VkBufferViewCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pView: *mut VkBufferView) -> VkResult; +} +extern "C" { + pub fn vkDestroyBufferView(device: VkDevice, bufferView: VkBufferView, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreateImage(device: VkDevice, + pCreateInfo: *const VkImageCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pImage: *mut VkImage) -> VkResult; +} +extern "C" { + pub fn vkDestroyImage(device: VkDevice, image: VkImage, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkGetImageSubresourceLayout(device: VkDevice, image: VkImage, + pSubresource: + *const VkImageSubresource, + pLayout: *mut VkSubresourceLayout); +} +extern "C" { + pub fn vkCreateImageView(device: VkDevice, + pCreateInfo: *const VkImageViewCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pView: *mut VkImageView) -> VkResult; +} +extern "C" { + pub fn vkDestroyImageView(device: VkDevice, imageView: VkImageView, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreateShaderModule(device: VkDevice, + pCreateInfo: *const VkShaderModuleCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pShaderModule: *mut VkShaderModule) + -> VkResult; +} +extern "C" { + pub fn vkDestroyShaderModule(device: VkDevice, + shaderModule: VkShaderModule, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreatePipelineCache(device: VkDevice, + pCreateInfo: + *const VkPipelineCacheCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pPipelineCache: *mut VkPipelineCache) + -> VkResult; +} +extern "C" { + pub fn vkDestroyPipelineCache(device: VkDevice, + pipelineCache: VkPipelineCache, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkGetPipelineCacheData(device: VkDevice, + pipelineCache: VkPipelineCache, + pDataSize: *mut usize, + pData: *mut ::std::os::raw::c_void) + -> VkResult; +} +extern "C" { + pub fn vkMergePipelineCaches(device: VkDevice, dstCache: VkPipelineCache, + srcCacheCount: u32, + pSrcCaches: *const VkPipelineCache) + -> VkResult; +} +extern "C" { + pub fn vkCreateGraphicsPipelines(device: VkDevice, + pipelineCache: VkPipelineCache, + createInfoCount: u32, + pCreateInfos: + *const VkGraphicsPipelineCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pPipelines: *mut VkPipeline) -> VkResult; +} +extern "C" { + pub fn vkCreateComputePipelines(device: VkDevice, + pipelineCache: VkPipelineCache, + createInfoCount: u32, + pCreateInfos: + *const VkComputePipelineCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pPipelines: *mut VkPipeline) -> VkResult; +} +extern "C" { + pub fn vkDestroyPipeline(device: VkDevice, pipeline: VkPipeline, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreatePipelineLayout(device: VkDevice, + pCreateInfo: + *const VkPipelineLayoutCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pPipelineLayout: *mut VkPipelineLayout) + -> VkResult; +} +extern "C" { + pub fn vkDestroyPipelineLayout(device: VkDevice, + pipelineLayout: VkPipelineLayout, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreateSampler(device: VkDevice, + pCreateInfo: *const VkSamplerCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pSampler: *mut VkSampler) -> VkResult; +} +extern "C" { + pub fn vkDestroySampler(device: VkDevice, sampler: VkSampler, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreateDescriptorSetLayout(device: VkDevice, + pCreateInfo: + *const VkDescriptorSetLayoutCreateInfo, + pAllocator: + *const VkAllocationCallbacks, + pSetLayout: *mut VkDescriptorSetLayout) + -> VkResult; +} +extern "C" { + pub fn vkDestroyDescriptorSetLayout(device: VkDevice, + descriptorSetLayout: + VkDescriptorSetLayout, + pAllocator: + *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreateDescriptorPool(device: VkDevice, + pCreateInfo: + *const VkDescriptorPoolCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pDescriptorPool: *mut VkDescriptorPool) + -> VkResult; +} +extern "C" { + pub fn vkDestroyDescriptorPool(device: VkDevice, + descriptorPool: VkDescriptorPool, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkResetDescriptorPool(device: VkDevice, + descriptorPool: VkDescriptorPool, + flags: VkDescriptorPoolResetFlags) + -> VkResult; +} +extern "C" { + pub fn vkAllocateDescriptorSets(device: VkDevice, + pAllocateInfo: + *const VkDescriptorSetAllocateInfo, + pDescriptorSets: *mut VkDescriptorSet) + -> VkResult; +} +extern "C" { + pub fn vkFreeDescriptorSets(device: VkDevice, + descriptorPool: VkDescriptorPool, + descriptorSetCount: u32, + pDescriptorSets: *const VkDescriptorSet) + -> VkResult; +} +extern "C" { + pub fn vkUpdateDescriptorSets(device: VkDevice, descriptorWriteCount: u32, + pDescriptorWrites: + *const VkWriteDescriptorSet, + descriptorCopyCount: u32, + pDescriptorCopies: + *const VkCopyDescriptorSet); +} +extern "C" { + pub fn vkCreateFramebuffer(device: VkDevice, + pCreateInfo: *const VkFramebufferCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pFramebuffer: *mut VkFramebuffer) -> VkResult; +} +extern "C" { + pub fn vkDestroyFramebuffer(device: VkDevice, framebuffer: VkFramebuffer, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreateRenderPass(device: VkDevice, + pCreateInfo: *const VkRenderPassCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pRenderPass: *mut VkRenderPass) -> VkResult; +} +extern "C" { + pub fn vkDestroyRenderPass(device: VkDevice, renderPass: VkRenderPass, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkGetRenderAreaGranularity(device: VkDevice, + renderPass: VkRenderPass, + pGranularity: *mut VkExtent2D); +} +extern "C" { + pub fn vkCreateCommandPool(device: VkDevice, + pCreateInfo: *const VkCommandPoolCreateInfo, + pAllocator: *const VkAllocationCallbacks, + pCommandPool: *mut VkCommandPool) -> VkResult; +} +extern "C" { + pub fn vkDestroyCommandPool(device: VkDevice, commandPool: VkCommandPool, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkResetCommandPool(device: VkDevice, commandPool: VkCommandPool, + flags: VkCommandPoolResetFlags) -> VkResult; +} +extern "C" { + pub fn vkAllocateCommandBuffers(device: VkDevice, + pAllocateInfo: + *const VkCommandBufferAllocateInfo, + pCommandBuffers: *mut VkCommandBuffer) + -> VkResult; +} +extern "C" { + pub fn vkFreeCommandBuffers(device: VkDevice, commandPool: VkCommandPool, + commandBufferCount: u32, + pCommandBuffers: *const VkCommandBuffer); +} +extern "C" { + pub fn vkBeginCommandBuffer(commandBuffer: VkCommandBuffer, + pBeginInfo: *const VkCommandBufferBeginInfo) + -> VkResult; +} +extern "C" { + pub fn vkEndCommandBuffer(commandBuffer: VkCommandBuffer) -> VkResult; +} +extern "C" { + pub fn vkResetCommandBuffer(commandBuffer: VkCommandBuffer, + flags: VkCommandBufferResetFlags) -> VkResult; +} +extern "C" { + pub fn vkCmdBindPipeline(commandBuffer: VkCommandBuffer, + pipelineBindPoint: VkPipelineBindPoint, + pipeline: VkPipeline); +} +extern "C" { + pub fn vkCmdSetViewport(commandBuffer: VkCommandBuffer, + firstViewport: u32, viewportCount: u32, + pViewports: *const VkViewport); +} +extern "C" { + pub fn vkCmdSetScissor(commandBuffer: VkCommandBuffer, firstScissor: u32, + scissorCount: u32, pScissors: *const VkRect2D); +} +extern "C" { + pub fn vkCmdSetLineWidth(commandBuffer: VkCommandBuffer, lineWidth: f32); +} +extern "C" { + pub fn vkCmdSetDepthBias(commandBuffer: VkCommandBuffer, + depthBiasConstantFactor: f32, + depthBiasClamp: f32, depthBiasSlopeFactor: f32); +} +extern "C" { + pub fn vkCmdSetBlendConstants(commandBuffer: VkCommandBuffer, + blendConstants: *const f32); +} +extern "C" { + pub fn vkCmdSetDepthBounds(commandBuffer: VkCommandBuffer, + minDepthBounds: f32, maxDepthBounds: f32); +} +extern "C" { + pub fn vkCmdSetStencilCompareMask(commandBuffer: VkCommandBuffer, + faceMask: VkStencilFaceFlags, + compareMask: u32); +} +extern "C" { + pub fn vkCmdSetStencilWriteMask(commandBuffer: VkCommandBuffer, + faceMask: VkStencilFaceFlags, + writeMask: u32); +} +extern "C" { + pub fn vkCmdSetStencilReference(commandBuffer: VkCommandBuffer, + faceMask: VkStencilFaceFlags, + reference: u32); +} +extern "C" { + pub fn vkCmdBindDescriptorSets(commandBuffer: VkCommandBuffer, + pipelineBindPoint: VkPipelineBindPoint, + layout: VkPipelineLayout, firstSet: u32, + descriptorSetCount: u32, + pDescriptorSets: *const VkDescriptorSet, + dynamicOffsetCount: u32, + pDynamicOffsets: *const u32); +} +extern "C" { + pub fn vkCmdBindIndexBuffer(commandBuffer: VkCommandBuffer, + buffer: VkBuffer, offset: VkDeviceSize, + indexType: VkIndexType); +} +extern "C" { + pub fn vkCmdBindVertexBuffers(commandBuffer: VkCommandBuffer, + firstBinding: u32, bindingCount: u32, + pBuffers: *const VkBuffer, + pOffsets: *const VkDeviceSize); +} +extern "C" { + pub fn vkCmdDraw(commandBuffer: VkCommandBuffer, vertexCount: u32, + instanceCount: u32, firstVertex: u32, + firstInstance: u32); +} +extern "C" { + pub fn vkCmdDrawIndexed(commandBuffer: VkCommandBuffer, indexCount: u32, + instanceCount: u32, firstIndex: u32, + vertexOffset: i32, firstInstance: u32); +} +extern "C" { + pub fn vkCmdDrawIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, + offset: VkDeviceSize, drawCount: u32, + stride: u32); +} +extern "C" { + pub fn vkCmdDrawIndexedIndirect(commandBuffer: VkCommandBuffer, + buffer: VkBuffer, offset: VkDeviceSize, + drawCount: u32, stride: u32); +} +extern "C" { + pub fn vkCmdDispatch(commandBuffer: VkCommandBuffer, groupCountX: u32, + groupCountY: u32, groupCountZ: u32); +} +extern "C" { + pub fn vkCmdDispatchIndirect(commandBuffer: VkCommandBuffer, + buffer: VkBuffer, offset: VkDeviceSize); +} +extern "C" { + pub fn vkCmdCopyBuffer(commandBuffer: VkCommandBuffer, + srcBuffer: VkBuffer, dstBuffer: VkBuffer, + regionCount: u32, pRegions: *const VkBufferCopy); +} +extern "C" { + pub fn vkCmdCopyImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, + srcImageLayout: VkImageLayout, dstImage: VkImage, + dstImageLayout: VkImageLayout, regionCount: u32, + pRegions: *const VkImageCopy); +} +extern "C" { + pub fn vkCmdBlitImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, + srcImageLayout: VkImageLayout, dstImage: VkImage, + dstImageLayout: VkImageLayout, regionCount: u32, + pRegions: *const VkImageBlit, filter: VkFilter); +} +extern "C" { + pub fn vkCmdCopyBufferToImage(commandBuffer: VkCommandBuffer, + srcBuffer: VkBuffer, dstImage: VkImage, + dstImageLayout: VkImageLayout, + regionCount: u32, + pRegions: *const VkBufferImageCopy); +} +extern "C" { + pub fn vkCmdCopyImageToBuffer(commandBuffer: VkCommandBuffer, + srcImage: VkImage, + srcImageLayout: VkImageLayout, + dstBuffer: VkBuffer, regionCount: u32, + pRegions: *const VkBufferImageCopy); +} +extern "C" { + pub fn vkCmdUpdateBuffer(commandBuffer: VkCommandBuffer, + dstBuffer: VkBuffer, dstOffset: VkDeviceSize, + dataSize: VkDeviceSize, + pData: *const ::std::os::raw::c_void); +} +extern "C" { + pub fn vkCmdFillBuffer(commandBuffer: VkCommandBuffer, + dstBuffer: VkBuffer, dstOffset: VkDeviceSize, + size: VkDeviceSize, data: u32); +} +extern "C" { + pub fn vkCmdClearColorImage(commandBuffer: VkCommandBuffer, + image: VkImage, imageLayout: VkImageLayout, + pColor: *const VkClearColorValue, + rangeCount: u32, + pRanges: *const VkImageSubresourceRange); +} +extern "C" { + pub fn vkCmdClearDepthStencilImage(commandBuffer: VkCommandBuffer, + image: VkImage, + imageLayout: VkImageLayout, + pDepthStencil: + *const VkClearDepthStencilValue, + rangeCount: u32, + pRanges: + *const VkImageSubresourceRange); +} +extern "C" { + pub fn vkCmdClearAttachments(commandBuffer: VkCommandBuffer, + attachmentCount: u32, + pAttachments: *const VkClearAttachment, + rectCount: u32, pRects: *const VkClearRect); +} +extern "C" { + pub fn vkCmdResolveImage(commandBuffer: VkCommandBuffer, + srcImage: VkImage, srcImageLayout: VkImageLayout, + dstImage: VkImage, dstImageLayout: VkImageLayout, + regionCount: u32, + pRegions: *const VkImageResolve); +} +extern "C" { + pub fn vkCmdSetEvent(commandBuffer: VkCommandBuffer, event: VkEvent, + stageMask: VkPipelineStageFlags); +} +extern "C" { + pub fn vkCmdResetEvent(commandBuffer: VkCommandBuffer, event: VkEvent, + stageMask: VkPipelineStageFlags); +} +extern "C" { + pub fn vkCmdWaitEvents(commandBuffer: VkCommandBuffer, eventCount: u32, + pEvents: *const VkEvent, + srcStageMask: VkPipelineStageFlags, + dstStageMask: VkPipelineStageFlags, + memoryBarrierCount: u32, + pMemoryBarriers: *const VkMemoryBarrier, + bufferMemoryBarrierCount: u32, + pBufferMemoryBarriers: + *const VkBufferMemoryBarrier, + imageMemoryBarrierCount: u32, + pImageMemoryBarriers: *const VkImageMemoryBarrier); +} +extern "C" { + pub fn vkCmdPipelineBarrier(commandBuffer: VkCommandBuffer, + srcStageMask: VkPipelineStageFlags, + dstStageMask: VkPipelineStageFlags, + dependencyFlags: VkDependencyFlags, + memoryBarrierCount: u32, + pMemoryBarriers: *const VkMemoryBarrier, + bufferMemoryBarrierCount: u32, + pBufferMemoryBarriers: + *const VkBufferMemoryBarrier, + imageMemoryBarrierCount: u32, + pImageMemoryBarriers: + *const VkImageMemoryBarrier); +} +extern "C" { + pub fn vkCmdBeginQuery(commandBuffer: VkCommandBuffer, + queryPool: VkQueryPool, query: u32, + flags: VkQueryControlFlags); +} +extern "C" { + pub fn vkCmdEndQuery(commandBuffer: VkCommandBuffer, + queryPool: VkQueryPool, query: u32); +} +extern "C" { + pub fn vkCmdResetQueryPool(commandBuffer: VkCommandBuffer, + queryPool: VkQueryPool, firstQuery: u32, + queryCount: u32); +} +extern "C" { + pub fn vkCmdWriteTimestamp(commandBuffer: VkCommandBuffer, + pipelineStage: VkPipelineStageFlagBits, + queryPool: VkQueryPool, query: u32); +} +extern "C" { + pub fn vkCmdCopyQueryPoolResults(commandBuffer: VkCommandBuffer, + queryPool: VkQueryPool, firstQuery: u32, + queryCount: u32, dstBuffer: VkBuffer, + dstOffset: VkDeviceSize, + stride: VkDeviceSize, + flags: VkQueryResultFlags); +} +extern "C" { + pub fn vkCmdPushConstants(commandBuffer: VkCommandBuffer, + layout: VkPipelineLayout, + stageFlags: VkShaderStageFlags, offset: u32, + size: u32, + pValues: *const ::std::os::raw::c_void); +} +extern "C" { + pub fn vkCmdBeginRenderPass(commandBuffer: VkCommandBuffer, + pRenderPassBegin: + *const VkRenderPassBeginInfo, + contents: VkSubpassContents); +} +extern "C" { + pub fn vkCmdNextSubpass(commandBuffer: VkCommandBuffer, + contents: VkSubpassContents); +} +extern "C" { + pub fn vkCmdEndRenderPass(commandBuffer: VkCommandBuffer); +} +extern "C" { + pub fn vkCmdExecuteCommands(commandBuffer: VkCommandBuffer, + commandBufferCount: u32, + pCommandBuffers: *const VkCommandBuffer); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkSurfaceKHR_T { + _unused: [u8; 0], +} +pub type VkSurfaceKHR = *mut VkSurfaceKHR_T; +pub const VkColorSpaceKHR_VK_COLOR_SPACE_BEGIN_RANGE_KHR: VkColorSpaceKHR = + VkColorSpaceKHR::VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; +pub const VkColorSpaceKHR_VK_COLOR_SPACE_END_RANGE_KHR: VkColorSpaceKHR = + VkColorSpaceKHR::VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkColorSpaceKHR { + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLOR_SPACE_RANGE_SIZE_KHR = 1, + VK_COLOR_SPACE_MAX_ENUM_KHR = 2147483647, +} +pub const VkPresentModeKHR_VK_PRESENT_MODE_BEGIN_RANGE_KHR: VkPresentModeKHR = + VkPresentModeKHR::VK_PRESENT_MODE_IMMEDIATE_KHR; +pub const VkPresentModeKHR_VK_PRESENT_MODE_END_RANGE_KHR: VkPresentModeKHR = + VkPresentModeKHR::VK_PRESENT_MODE_FIFO_RELAXED_KHR; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkPresentModeKHR { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_RANGE_SIZE_KHR = 4, + VK_PRESENT_MODE_MAX_ENUM_KHR = 2147483647, +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSurfaceTransformFlagBitsKHR { + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 1, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 2, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 4, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 8, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 16, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 32, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 64, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 128, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 256, + VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 2147483647, +} +pub type VkSurfaceTransformFlagsKHR = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkCompositeAlphaFlagBitsKHR { + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 1, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 2, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 4, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 8, + VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 2147483647, +} +pub type VkCompositeAlphaFlagsKHR = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSurfaceCapabilitiesKHR { + pub minImageCount: u32, + pub maxImageCount: u32, + pub currentExtent: VkExtent2D, + pub minImageExtent: VkExtent2D, + pub maxImageExtent: VkExtent2D, + pub maxImageArrayLayers: u32, + pub supportedTransforms: VkSurfaceTransformFlagsKHR, + pub currentTransform: VkSurfaceTransformFlagBitsKHR, + pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR, + pub supportedUsageFlags: VkImageUsageFlags, +} +impl Clone for VkSurfaceCapabilitiesKHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSurfaceFormatKHR { + pub format: VkFormat, + pub colorSpace: VkColorSpaceKHR, +} +impl Clone for VkSurfaceFormatKHR { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkDestroySurfaceKHR = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceSurfaceSupportKHR = + ::std::option::Option VkResult>; +pub type PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = + ::std::option::Option VkResult>; +pub type PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = + ::std::option::Option VkResult>; +pub type PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkDestroySurfaceKHR(instance: VkInstance, surface: VkSurfaceKHR, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice: + VkPhysicalDevice, + queueFamilyIndex: u32, + surface: VkSurfaceKHR, + pSupported: *mut VkBool32) + -> VkResult; +} +extern "C" { + pub fn vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice: + VkPhysicalDevice, + surface: VkSurfaceKHR, + pSurfaceCapabilities: + *mut VkSurfaceCapabilitiesKHR) + -> VkResult; +} +extern "C" { + pub fn vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice: + VkPhysicalDevice, + surface: VkSurfaceKHR, + pSurfaceFormatCount: *mut u32, + pSurfaceFormats: + *mut VkSurfaceFormatKHR) + -> VkResult; +} +extern "C" { + pub fn vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice: + VkPhysicalDevice, + surface: VkSurfaceKHR, + pPresentModeCount: + *mut u32, + pPresentModes: + *mut VkPresentModeKHR) + -> VkResult; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkSwapchainKHR_T { + _unused: [u8; 0], +} +pub type VkSwapchainKHR = *mut VkSwapchainKHR_T; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSwapchainCreateFlagBitsKHR { + VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 1, + VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 2147483647, +} +pub type VkSwapchainCreateFlagsKHR = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSwapchainCreateInfoKHR { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkSwapchainCreateFlagsKHR, + pub surface: VkSurfaceKHR, + pub minImageCount: u32, + pub imageFormat: VkFormat, + pub imageColorSpace: VkColorSpaceKHR, + pub imageExtent: VkExtent2D, + pub imageArrayLayers: u32, + pub imageUsage: VkImageUsageFlags, + pub imageSharingMode: VkSharingMode, + pub queueFamilyIndexCount: u32, + pub pQueueFamilyIndices: *const u32, + pub preTransform: VkSurfaceTransformFlagBitsKHR, + pub compositeAlpha: VkCompositeAlphaFlagBitsKHR, + pub presentMode: VkPresentModeKHR, + pub clipped: VkBool32, + pub oldSwapchain: VkSwapchainKHR, +} +impl Clone for VkSwapchainCreateInfoKHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPresentInfoKHR { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub waitSemaphoreCount: u32, + pub pWaitSemaphores: *const VkSemaphore, + pub swapchainCount: u32, + pub pSwapchains: *const VkSwapchainKHR, + pub pImageIndices: *const u32, + pub pResults: *mut VkResult, +} +impl Clone for VkPresentInfoKHR { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkCreateSwapchainKHR = + ::std::option::Option VkResult>; +pub type PFN_vkDestroySwapchainKHR = + ::std::option::Option; +pub type PFN_vkGetSwapchainImagesKHR = + ::std::option::Option VkResult>; +pub type PFN_vkAcquireNextImageKHR = + ::std::option::Option VkResult>; +pub type PFN_vkQueuePresentKHR = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkCreateSwapchainKHR(device: VkDevice, + pCreateInfo: *const VkSwapchainCreateInfoKHR, + pAllocator: *const VkAllocationCallbacks, + pSwapchain: *mut VkSwapchainKHR) -> VkResult; +} +extern "C" { + pub fn vkDestroySwapchainKHR(device: VkDevice, swapchain: VkSwapchainKHR, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkGetSwapchainImagesKHR(device: VkDevice, + swapchain: VkSwapchainKHR, + pSwapchainImageCount: *mut u32, + pSwapchainImages: *mut VkImage) + -> VkResult; +} +extern "C" { + pub fn vkAcquireNextImageKHR(device: VkDevice, swapchain: VkSwapchainKHR, + timeout: u64, semaphore: VkSemaphore, + fence: VkFence, pImageIndex: *mut u32) + -> VkResult; +} +extern "C" { + pub fn vkQueuePresentKHR(queue: VkQueue, + pPresentInfo: *const VkPresentInfoKHR) + -> VkResult; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkDisplayKHR_T { + _unused: [u8; 0], +} +pub type VkDisplayKHR = *mut VkDisplayKHR_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkDisplayModeKHR_T { + _unused: [u8; 0], +} +pub type VkDisplayModeKHR = *mut VkDisplayModeKHR_T; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDisplayPlaneAlphaFlagBitsKHR { + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 1, + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 2, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 4, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 8, + VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 2147483647, +} +pub type VkDisplayPlaneAlphaFlagsKHR = VkFlags; +pub type VkDisplayModeCreateFlagsKHR = VkFlags; +pub type VkDisplaySurfaceCreateFlagsKHR = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDisplayPropertiesKHR { + pub display: VkDisplayKHR, + pub displayName: *const ::std::os::raw::c_char, + pub physicalDimensions: VkExtent2D, + pub physicalResolution: VkExtent2D, + pub supportedTransforms: VkSurfaceTransformFlagsKHR, + pub planeReorderPossible: VkBool32, + pub persistentContent: VkBool32, +} +impl Clone for VkDisplayPropertiesKHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDisplayModeParametersKHR { + pub visibleRegion: VkExtent2D, + pub refreshRate: u32, +} +impl Clone for VkDisplayModeParametersKHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDisplayModePropertiesKHR { + pub displayMode: VkDisplayModeKHR, + pub parameters: VkDisplayModeParametersKHR, +} +impl Clone for VkDisplayModePropertiesKHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDisplayModeCreateInfoKHR { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkDisplayModeCreateFlagsKHR, + pub parameters: VkDisplayModeParametersKHR, +} +impl Clone for VkDisplayModeCreateInfoKHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDisplayPlaneCapabilitiesKHR { + pub supportedAlpha: VkDisplayPlaneAlphaFlagsKHR, + pub minSrcPosition: VkOffset2D, + pub maxSrcPosition: VkOffset2D, + pub minSrcExtent: VkExtent2D, + pub maxSrcExtent: VkExtent2D, + pub minDstPosition: VkOffset2D, + pub maxDstPosition: VkOffset2D, + pub minDstExtent: VkExtent2D, + pub maxDstExtent: VkExtent2D, +} +impl Clone for VkDisplayPlaneCapabilitiesKHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDisplayPlanePropertiesKHR { + pub currentDisplay: VkDisplayKHR, + pub currentStackIndex: u32, +} +impl Clone for VkDisplayPlanePropertiesKHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDisplaySurfaceCreateInfoKHR { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkDisplaySurfaceCreateFlagsKHR, + pub displayMode: VkDisplayModeKHR, + pub planeIndex: u32, + pub planeStackIndex: u32, + pub transform: VkSurfaceTransformFlagBitsKHR, + pub globalAlpha: f32, + pub alphaMode: VkDisplayPlaneAlphaFlagBitsKHR, + pub imageExtent: VkExtent2D, +} +impl Clone for VkDisplaySurfaceCreateInfoKHR { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = + ::std::option::Option VkResult>; +pub type PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = + ::std::option::Option VkResult>; +pub type PFN_vkGetDisplayPlaneSupportedDisplaysKHR = + ::std::option::Option VkResult>; +pub type PFN_vkGetDisplayModePropertiesKHR = + ::std::option::Option VkResult>; +pub type PFN_vkCreateDisplayModeKHR = + ::std::option::Option VkResult>; +pub type PFN_vkGetDisplayPlaneCapabilitiesKHR = + ::std::option::Option VkResult>; +pub type PFN_vkCreateDisplayPlaneSurfaceKHR = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice: + VkPhysicalDevice, + pPropertyCount: *mut u32, + pProperties: + *mut VkDisplayPropertiesKHR) + -> VkResult; +} +extern "C" { + pub fn vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice: + VkPhysicalDevice, + pPropertyCount: + *mut u32, + pProperties: + *mut VkDisplayPlanePropertiesKHR) + -> VkResult; +} +extern "C" { + pub fn vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice: + VkPhysicalDevice, + planeIndex: u32, + pDisplayCount: *mut u32, + pDisplays: *mut VkDisplayKHR) + -> VkResult; +} +extern "C" { + pub fn vkGetDisplayModePropertiesKHR(physicalDevice: VkPhysicalDevice, + display: VkDisplayKHR, + pPropertyCount: *mut u32, + pProperties: + *mut VkDisplayModePropertiesKHR) + -> VkResult; +} +extern "C" { + pub fn vkCreateDisplayModeKHR(physicalDevice: VkPhysicalDevice, + display: VkDisplayKHR, + pCreateInfo: + *const VkDisplayModeCreateInfoKHR, + pAllocator: *const VkAllocationCallbacks, + pMode: *mut VkDisplayModeKHR) -> VkResult; +} +extern "C" { + pub fn vkGetDisplayPlaneCapabilitiesKHR(physicalDevice: VkPhysicalDevice, + mode: VkDisplayModeKHR, + planeIndex: u32, + pCapabilities: + *mut VkDisplayPlaneCapabilitiesKHR) + -> VkResult; +} +extern "C" { + pub fn vkCreateDisplayPlaneSurfaceKHR(instance: VkInstance, + pCreateInfo: + *const VkDisplaySurfaceCreateInfoKHR, + pAllocator: + *const VkAllocationCallbacks, + pSurface: *mut VkSurfaceKHR) + -> VkResult; +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDisplayPresentInfoKHR { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub srcRect: VkRect2D, + pub dstRect: VkRect2D, + pub persistent: VkBool32, +} +impl Clone for VkDisplayPresentInfoKHR { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkCreateSharedSwapchainsKHR = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkCreateSharedSwapchainsKHR(device: VkDevice, swapchainCount: u32, + pCreateInfos: + *const VkSwapchainCreateInfoKHR, + pAllocator: + *const VkAllocationCallbacks, + pSwapchains: *mut VkSwapchainKHR) + -> VkResult; +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceFeatures2KHR { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub features: VkPhysicalDeviceFeatures, +} +impl Clone for VkPhysicalDeviceFeatures2KHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct VkPhysicalDeviceProperties2KHR { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub properties: VkPhysicalDeviceProperties, +} +impl Clone for VkPhysicalDeviceProperties2KHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkFormatProperties2KHR { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub formatProperties: VkFormatProperties, +} +impl Clone for VkFormatProperties2KHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageFormatProperties2KHR { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub imageFormatProperties: VkImageFormatProperties, +} +impl Clone for VkImageFormatProperties2KHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceImageFormatInfo2KHR { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub format: VkFormat, + pub type_: VkImageType, + pub tiling: VkImageTiling, + pub usage: VkImageUsageFlags, + pub flags: VkImageCreateFlags, +} +impl Clone for VkPhysicalDeviceImageFormatInfo2KHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkQueueFamilyProperties2KHR { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub queueFamilyProperties: VkQueueFamilyProperties, +} +impl Clone for VkQueueFamilyProperties2KHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceMemoryProperties2KHR { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub memoryProperties: VkPhysicalDeviceMemoryProperties, +} +impl Clone for VkPhysicalDeviceMemoryProperties2KHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSparseImageFormatProperties2KHR { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub properties: VkSparseImageFormatProperties, +} +impl Clone for VkSparseImageFormatProperties2KHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceSparseImageFormatInfo2KHR { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub format: VkFormat, + pub type_: VkImageType, + pub samples: VkSampleCountFlagBits, + pub usage: VkImageUsageFlags, + pub tiling: VkImageTiling, +} +impl Clone for VkPhysicalDeviceSparseImageFormatInfo2KHR { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkGetPhysicalDeviceFeatures2KHR = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceProperties2KHR = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceFormatProperties2KHR = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceImageFormatProperties2KHR = + ::std::option::Option VkResult>; +pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceMemoryProperties2KHR = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = + ::std::option::Option; +extern "C" { + pub fn vkGetPhysicalDeviceFeatures2KHR(physicalDevice: VkPhysicalDevice, + pFeatures: + *mut VkPhysicalDeviceFeatures2KHR); +} +extern "C" { + pub fn vkGetPhysicalDeviceProperties2KHR(physicalDevice: VkPhysicalDevice, + pProperties: + *mut VkPhysicalDeviceProperties2KHR); +} +extern "C" { + pub fn vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice: + VkPhysicalDevice, + format: VkFormat, + pFormatProperties: + *mut VkFormatProperties2KHR); +} +extern "C" { + pub fn vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice: + VkPhysicalDevice, + pImageFormatInfo: + *const VkPhysicalDeviceImageFormatInfo2KHR, + pImageFormatProperties: + *mut VkImageFormatProperties2KHR) + -> VkResult; +} +extern "C" { + pub fn vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice: + VkPhysicalDevice, + pQueueFamilyPropertyCount: + *mut u32, + pQueueFamilyProperties: + *mut VkQueueFamilyProperties2KHR); +} +extern "C" { + pub fn vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice: + VkPhysicalDevice, + pMemoryProperties: + *mut VkPhysicalDeviceMemoryProperties2KHR); +} +extern "C" { + pub fn vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice: + VkPhysicalDevice, + pFormatInfo: + *const VkPhysicalDeviceSparseImageFormatInfo2KHR, + pPropertyCount: + *mut u32, + pProperties: + *mut VkSparseImageFormatProperties2KHR); +} +pub type VkCommandPoolTrimFlagsKHR = VkFlags; +pub type PFN_vkTrimCommandPoolKHR = + ::std::option::Option; +extern "C" { + pub fn vkTrimCommandPoolKHR(device: VkDevice, commandPool: VkCommandPool, + flags: VkCommandPoolTrimFlagsKHR); +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDevicePushDescriptorPropertiesKHR { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub maxPushDescriptors: u32, +} +impl Clone for VkPhysicalDevicePushDescriptorPropertiesKHR { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkCmdPushDescriptorSetKHR = + ::std::option::Option; +extern "C" { + pub fn vkCmdPushDescriptorSetKHR(commandBuffer: VkCommandBuffer, + pipelineBindPoint: VkPipelineBindPoint, + layout: VkPipelineLayout, set: u32, + descriptorWriteCount: u32, + pDescriptorWrites: + *const VkWriteDescriptorSet); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkDescriptorUpdateTemplateKHR_T { + _unused: [u8; 0], +} +pub type VkDescriptorUpdateTemplateKHR = *mut VkDescriptorUpdateTemplateKHR_T; +pub const VkDescriptorUpdateTemplateTypeKHR_VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR: + VkDescriptorUpdateTemplateTypeKHR = + VkDescriptorUpdateTemplateTypeKHR::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR; +pub const VkDescriptorUpdateTemplateTypeKHR_VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR: + VkDescriptorUpdateTemplateTypeKHR = + VkDescriptorUpdateTemplateTypeKHR::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDescriptorUpdateTemplateTypeKHR { + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = 2, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 2147483647, +} +pub type VkDescriptorUpdateTemplateCreateFlagsKHR = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDescriptorUpdateTemplateEntryKHR { + pub dstBinding: u32, + pub dstArrayElement: u32, + pub descriptorCount: u32, + pub descriptorType: VkDescriptorType, + pub offset: usize, + pub stride: usize, +} +impl Clone for VkDescriptorUpdateTemplateEntryKHR { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDescriptorUpdateTemplateCreateInfoKHR { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub flags: VkDescriptorUpdateTemplateCreateFlagsKHR, + pub descriptorUpdateEntryCount: u32, + pub pDescriptorUpdateEntries: *const VkDescriptorUpdateTemplateEntryKHR, + pub templateType: VkDescriptorUpdateTemplateTypeKHR, + pub descriptorSetLayout: VkDescriptorSetLayout, + pub pipelineBindPoint: VkPipelineBindPoint, + pub pipelineLayout: VkPipelineLayout, + pub set: u32, +} +impl Clone for VkDescriptorUpdateTemplateCreateInfoKHR { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkCreateDescriptorUpdateTemplateKHR = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyDescriptorUpdateTemplateKHR = + ::std::option::Option; +pub type PFN_vkUpdateDescriptorSetWithTemplateKHR = + ::std::option::Option; +pub type PFN_vkCmdPushDescriptorSetWithTemplateKHR = + ::std::option::Option; +extern "C" { + pub fn vkCreateDescriptorUpdateTemplateKHR(device: VkDevice, + pCreateInfo: + *const VkDescriptorUpdateTemplateCreateInfoKHR, + pAllocator: + *const VkAllocationCallbacks, + pDescriptorUpdateTemplate: + *mut VkDescriptorUpdateTemplateKHR) + -> VkResult; +} +extern "C" { + pub fn vkDestroyDescriptorUpdateTemplateKHR(device: VkDevice, + descriptorUpdateTemplate: + VkDescriptorUpdateTemplateKHR, + pAllocator: + *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkUpdateDescriptorSetWithTemplateKHR(device: VkDevice, + descriptorSet: + VkDescriptorSet, + descriptorUpdateTemplate: + VkDescriptorUpdateTemplateKHR, + pData: + *const ::std::os::raw::c_void); +} +extern "C" { + pub fn vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer: + VkCommandBuffer, + descriptorUpdateTemplate: + VkDescriptorUpdateTemplateKHR, + layout: VkPipelineLayout, + set: u32, + pData: + *const ::std::os::raw::c_void); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkDebugReportCallbackEXT_T { + _unused: [u8; 0], +} +pub type VkDebugReportCallbackEXT = *mut VkDebugReportCallbackEXT_T; +pub const VkDebugReportObjectTypeEXT_VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT: + VkDebugReportObjectTypeEXT = + VkDebugReportObjectTypeEXT::VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT; +pub const VkDebugReportObjectTypeEXT_VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT: + VkDebugReportObjectTypeEXT = + VkDebugReportObjectTypeEXT::VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDebugReportObjectTypeEXT { + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, + VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, + VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32, + VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = 33, + VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 2147483647, +} +pub const VkDebugReportErrorEXT_VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT: + VkDebugReportErrorEXT = + VkDebugReportErrorEXT::VK_DEBUG_REPORT_ERROR_NONE_EXT; +pub const VkDebugReportErrorEXT_VK_DEBUG_REPORT_ERROR_END_RANGE_EXT: + VkDebugReportErrorEXT = + VkDebugReportErrorEXT::VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDebugReportErrorEXT { + VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, + VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, + VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = 2, + VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = 2147483647, +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDebugReportFlagBitsEXT { + VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 1, + VK_DEBUG_REPORT_WARNING_BIT_EXT = 2, + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 4, + VK_DEBUG_REPORT_ERROR_BIT_EXT = 8, + VK_DEBUG_REPORT_DEBUG_BIT_EXT = 16, + VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 2147483647, +} +pub type VkDebugReportFlagsEXT = VkFlags; +pub type PFN_vkDebugReportCallbackEXT = + ::std::option::Option VkBool32>; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDebugReportCallbackCreateInfoEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkDebugReportFlagsEXT, + pub pfnCallback: PFN_vkDebugReportCallbackEXT, + pub pUserData: *mut ::std::os::raw::c_void, +} +impl Clone for VkDebugReportCallbackCreateInfoEXT { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkCreateDebugReportCallbackEXT = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyDebugReportCallbackEXT = + ::std::option::Option; +pub type PFN_vkDebugReportMessageEXT = + ::std::option::Option; +extern "C" { + pub fn vkCreateDebugReportCallbackEXT(instance: VkInstance, + pCreateInfo: + *const VkDebugReportCallbackCreateInfoEXT, + pAllocator: + *const VkAllocationCallbacks, + pCallback: + *mut VkDebugReportCallbackEXT) + -> VkResult; +} +extern "C" { + pub fn vkDestroyDebugReportCallbackEXT(instance: VkInstance, + callback: VkDebugReportCallbackEXT, + pAllocator: + *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkDebugReportMessageEXT(instance: VkInstance, + flags: VkDebugReportFlagsEXT, + objectType: VkDebugReportObjectTypeEXT, + object: u64, location: usize, + messageCode: i32, + pLayerPrefix: + *const ::std::os::raw::c_char, + pMessage: *const ::std::os::raw::c_char); +} +pub const VkRasterizationOrderAMD_VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD: + VkRasterizationOrderAMD = + VkRasterizationOrderAMD::VK_RASTERIZATION_ORDER_STRICT_AMD; +pub const VkRasterizationOrderAMD_VK_RASTERIZATION_ORDER_END_RANGE_AMD: + VkRasterizationOrderAMD = + VkRasterizationOrderAMD::VK_RASTERIZATION_ORDER_RELAXED_AMD; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkRasterizationOrderAMD { + VK_RASTERIZATION_ORDER_STRICT_AMD = 0, + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, + VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = 2, + VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 2147483647, +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineRasterizationStateRasterizationOrderAMD { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub rasterizationOrder: VkRasterizationOrderAMD, +} +impl Clone for VkPipelineRasterizationStateRasterizationOrderAMD { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDebugMarkerObjectNameInfoEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub objectType: VkDebugReportObjectTypeEXT, + pub object: u64, + pub pObjectName: *const ::std::os::raw::c_char, +} +impl Clone for VkDebugMarkerObjectNameInfoEXT { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDebugMarkerObjectTagInfoEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub objectType: VkDebugReportObjectTypeEXT, + pub object: u64, + pub tagName: u64, + pub tagSize: usize, + pub pTag: *const ::std::os::raw::c_void, +} +impl Clone for VkDebugMarkerObjectTagInfoEXT { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDebugMarkerMarkerInfoEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub pMarkerName: *const ::std::os::raw::c_char, + pub color: [f32; 4usize], +} +impl Clone for VkDebugMarkerMarkerInfoEXT { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkDebugMarkerSetObjectTagEXT = + ::std::option::Option VkResult>; +pub type PFN_vkDebugMarkerSetObjectNameEXT = + ::std::option::Option VkResult>; +pub type PFN_vkCmdDebugMarkerBeginEXT = + ::std::option::Option; +pub type PFN_vkCmdDebugMarkerEndEXT = + ::std::option::Option; +pub type PFN_vkCmdDebugMarkerInsertEXT = + ::std::option::Option; +extern "C" { + pub fn vkDebugMarkerSetObjectTagEXT(device: VkDevice, + pTagInfo: + *mut VkDebugMarkerObjectTagInfoEXT) + -> VkResult; +} +extern "C" { + pub fn vkDebugMarkerSetObjectNameEXT(device: VkDevice, + pNameInfo: + *mut VkDebugMarkerObjectNameInfoEXT) + -> VkResult; +} +extern "C" { + pub fn vkCmdDebugMarkerBeginEXT(commandBuffer: VkCommandBuffer, + pMarkerInfo: + *mut VkDebugMarkerMarkerInfoEXT); +} +extern "C" { + pub fn vkCmdDebugMarkerEndEXT(commandBuffer: VkCommandBuffer); +} +extern "C" { + pub fn vkCmdDebugMarkerInsertEXT(commandBuffer: VkCommandBuffer, + pMarkerInfo: + *mut VkDebugMarkerMarkerInfoEXT); +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDedicatedAllocationImageCreateInfoNV { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub dedicatedAllocation: VkBool32, +} +impl Clone for VkDedicatedAllocationImageCreateInfoNV { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDedicatedAllocationBufferCreateInfoNV { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub dedicatedAllocation: VkBool32, +} +impl Clone for VkDedicatedAllocationBufferCreateInfoNV { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDedicatedAllocationMemoryAllocateInfoNV { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub image: VkImage, + pub buffer: VkBuffer, +} +impl Clone for VkDedicatedAllocationMemoryAllocateInfoNV { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkCmdDrawIndirectCountAMD = + ::std::option::Option; +pub type PFN_vkCmdDrawIndexedIndirectCountAMD = + ::std::option::Option; +extern "C" { + pub fn vkCmdDrawIndirectCountAMD(commandBuffer: VkCommandBuffer, + buffer: VkBuffer, offset: VkDeviceSize, + countBuffer: VkBuffer, + countBufferOffset: VkDeviceSize, + maxDrawCount: u32, stride: u32); +} +extern "C" { + pub fn vkCmdDrawIndexedIndirectCountAMD(commandBuffer: VkCommandBuffer, + buffer: VkBuffer, + offset: VkDeviceSize, + countBuffer: VkBuffer, + countBufferOffset: VkDeviceSize, + maxDrawCount: u32, stride: u32); +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkRenderPassMultiviewCreateInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub subpassCount: u32, + pub pViewMasks: *const u32, + pub dependencyCount: u32, + pub pViewOffsets: *const i32, + pub correlationMaskCount: u32, + pub pCorrelationMasks: *const u32, +} +impl Clone for VkRenderPassMultiviewCreateInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceMultiviewFeaturesKHX { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub multiview: VkBool32, + pub multiviewGeometryShader: VkBool32, + pub multiviewTessellationShader: VkBool32, +} +impl Clone for VkPhysicalDeviceMultiviewFeaturesKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceMultiviewPropertiesKHX { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub maxMultiviewViewCount: u32, + pub maxMultiviewInstanceIndex: u32, +} +impl Clone for VkPhysicalDeviceMultiviewPropertiesKHX { + fn clone(&self) -> Self { *self } +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkExternalMemoryHandleTypeFlagBitsNV { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 1, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 2, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 4, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 8, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 2147483647, +} +pub type VkExternalMemoryHandleTypeFlagsNV = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkExternalMemoryFeatureFlagBitsNV { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 1, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 2, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 4, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 2147483647, +} +pub type VkExternalMemoryFeatureFlagsNV = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExternalImageFormatPropertiesNV { + pub imageFormatProperties: VkImageFormatProperties, + pub externalMemoryFeatures: VkExternalMemoryFeatureFlagsNV, + pub exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlagsNV, + pub compatibleHandleTypes: VkExternalMemoryHandleTypeFlagsNV, +} +impl Clone for VkExternalImageFormatPropertiesNV { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice: + VkPhysicalDevice, + format: + VkFormat, + type_: + VkImageType, + tiling: + VkImageTiling, + usage: + VkImageUsageFlags, + flags: + VkImageCreateFlags, + externalHandleType: + VkExternalMemoryHandleTypeFlagsNV, + pExternalImageFormatProperties: + *mut VkExternalImageFormatPropertiesNV) + -> VkResult; +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExternalMemoryImageCreateInfoNV { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub handleTypes: VkExternalMemoryHandleTypeFlagsNV, +} +impl Clone for VkExternalMemoryImageCreateInfoNV { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExportMemoryAllocateInfoNV { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub handleTypes: VkExternalMemoryHandleTypeFlagsNV, +} +impl Clone for VkExportMemoryAllocateInfoNV { + fn clone(&self) -> Self { *self } +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkPeerMemoryFeatureFlagBitsKHX { + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = 1, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = 2, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 4, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 8, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 2147483647, +} +pub type VkPeerMemoryFeatureFlagsKHX = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkMemoryAllocateFlagBitsKHX { + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 1, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX = 2147483647, +} +pub type VkMemoryAllocateFlagsKHX = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDeviceGroupPresentModeFlagBitsKHX { + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = 1, + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = 2, + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = 4, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 8, + VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX = 2147483647, +} +pub type VkDeviceGroupPresentModeFlagsKHX = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkMemoryAllocateFlagsInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkMemoryAllocateFlagsKHX, + pub deviceMask: u32, +} +impl Clone for VkMemoryAllocateFlagsInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkBindBufferMemoryInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub buffer: VkBuffer, + pub memory: VkDeviceMemory, + pub memoryOffset: VkDeviceSize, + pub deviceIndexCount: u32, + pub pDeviceIndices: *const u32, +} +impl Clone for VkBindBufferMemoryInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkBindImageMemoryInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub image: VkImage, + pub memory: VkDeviceMemory, + pub memoryOffset: VkDeviceSize, + pub deviceIndexCount: u32, + pub pDeviceIndices: *const u32, + pub SFRRectCount: u32, + pub pSFRRects: *const VkRect2D, +} +impl Clone for VkBindImageMemoryInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceGroupRenderPassBeginInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub deviceMask: u32, + pub deviceRenderAreaCount: u32, + pub pDeviceRenderAreas: *const VkRect2D, +} +impl Clone for VkDeviceGroupRenderPassBeginInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceGroupCommandBufferBeginInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub deviceMask: u32, +} +impl Clone for VkDeviceGroupCommandBufferBeginInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceGroupSubmitInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub waitSemaphoreCount: u32, + pub pWaitSemaphoreDeviceIndices: *const u32, + pub commandBufferCount: u32, + pub pCommandBufferDeviceMasks: *const u32, + pub signalSemaphoreCount: u32, + pub pSignalSemaphoreDeviceIndices: *const u32, +} +impl Clone for VkDeviceGroupSubmitInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceGroupBindSparseInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub resourceDeviceIndex: u32, + pub memoryDeviceIndex: u32, +} +impl Clone for VkDeviceGroupBindSparseInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceGroupPresentCapabilitiesKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub presentMask: [u32; 32usize], + pub modes: VkDeviceGroupPresentModeFlagsKHX, +} +impl Clone for VkDeviceGroupPresentCapabilitiesKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageSwapchainCreateInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub swapchain: VkSwapchainKHR, +} +impl Clone for VkImageSwapchainCreateInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkBindImageMemorySwapchainInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub swapchain: VkSwapchainKHR, + pub imageIndex: u32, +} +impl Clone for VkBindImageMemorySwapchainInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkAcquireNextImageInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub swapchain: VkSwapchainKHR, + pub timeout: u64, + pub semaphore: VkSemaphore, + pub fence: VkFence, + pub deviceMask: u32, +} +impl Clone for VkAcquireNextImageInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceGroupPresentInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub swapchainCount: u32, + pub pDeviceMasks: *const u32, + pub mode: VkDeviceGroupPresentModeFlagBitsKHX, +} +impl Clone for VkDeviceGroupPresentInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceGroupSwapchainCreateInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub modes: VkDeviceGroupPresentModeFlagsKHX, +} +impl Clone for VkDeviceGroupSwapchainCreateInfoKHX { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX = + ::std::option::Option; +pub type PFN_vkBindBufferMemory2KHX = + ::std::option::Option VkResult>; +pub type PFN_vkBindImageMemory2KHX = + ::std::option::Option VkResult>; +pub type PFN_vkCmdSetDeviceMaskKHX = + ::std::option::Option; +pub type PFN_vkGetDeviceGroupPresentCapabilitiesKHX = + ::std::option::Option VkResult>; +pub type PFN_vkGetDeviceGroupSurfacePresentModesKHX = + ::std::option::Option VkResult>; +pub type PFN_vkAcquireNextImage2KHX = + ::std::option::Option VkResult>; +pub type PFN_vkCmdDispatchBaseKHX = + ::std::option::Option; +pub type PFN_vkGetPhysicalDevicePresentRectanglesKHX = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkGetDeviceGroupPeerMemoryFeaturesKHX(device: VkDevice, + heapIndex: u32, + localDeviceIndex: u32, + remoteDeviceIndex: u32, + pPeerMemoryFeatures: + *mut VkPeerMemoryFeatureFlagsKHX); +} +extern "C" { + pub fn vkBindBufferMemory2KHX(device: VkDevice, bindInfoCount: u32, + pBindInfos: + *const VkBindBufferMemoryInfoKHX) + -> VkResult; +} +extern "C" { + pub fn vkBindImageMemory2KHX(device: VkDevice, bindInfoCount: u32, + pBindInfos: *const VkBindImageMemoryInfoKHX) + -> VkResult; +} +extern "C" { + pub fn vkCmdSetDeviceMaskKHX(commandBuffer: VkCommandBuffer, + deviceMask: u32); +} +extern "C" { + pub fn vkGetDeviceGroupPresentCapabilitiesKHX(device: VkDevice, + pDeviceGroupPresentCapabilities: + *mut VkDeviceGroupPresentCapabilitiesKHX) + -> VkResult; +} +extern "C" { + pub fn vkGetDeviceGroupSurfacePresentModesKHX(device: VkDevice, + surface: VkSurfaceKHR, + pModes: + *mut VkDeviceGroupPresentModeFlagsKHX) + -> VkResult; +} +extern "C" { + pub fn vkAcquireNextImage2KHX(device: VkDevice, + pAcquireInfo: + *const VkAcquireNextImageInfoKHX, + pImageIndex: *mut u32) -> VkResult; +} +extern "C" { + pub fn vkCmdDispatchBaseKHX(commandBuffer: VkCommandBuffer, + baseGroupX: u32, baseGroupY: u32, + baseGroupZ: u32, groupCountX: u32, + groupCountY: u32, groupCountZ: u32); +} +extern "C" { + pub fn vkGetPhysicalDevicePresentRectanglesKHX(physicalDevice: + VkPhysicalDevice, + surface: VkSurfaceKHR, + pRectCount: *mut u32, + pRects: *mut VkRect2D) + -> VkResult; +} +pub const VkValidationCheckEXT_VK_VALIDATION_CHECK_BEGIN_RANGE_EXT: + VkValidationCheckEXT = + VkValidationCheckEXT::VK_VALIDATION_CHECK_ALL_EXT; +pub const VkValidationCheckEXT_VK_VALIDATION_CHECK_END_RANGE_EXT: + VkValidationCheckEXT = + VkValidationCheckEXT::VK_VALIDATION_CHECK_ALL_EXT; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkValidationCheckEXT { + VK_VALIDATION_CHECK_ALL_EXT = 0, + VK_VALIDATION_CHECK_RANGE_SIZE_EXT = 1, + VK_VALIDATION_CHECK_MAX_ENUM_EXT = 2147483647, +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkValidationFlagsEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub disabledValidationCheckCount: u32, + pub pDisabledValidationChecks: *mut VkValidationCheckEXT, +} +impl Clone for VkValidationFlagsEXT { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceGroupPropertiesKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub physicalDeviceCount: u32, + pub physicalDevices: [VkPhysicalDevice; 32usize], + pub subsetAllocation: VkBool32, +} +impl Clone for VkPhysicalDeviceGroupPropertiesKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceGroupDeviceCreateInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub physicalDeviceCount: u32, + pub pPhysicalDevices: *const VkPhysicalDevice, +} +impl Clone for VkDeviceGroupDeviceCreateInfoKHX { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkEnumeratePhysicalDeviceGroupsKHX = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkEnumeratePhysicalDeviceGroupsKHX(instance: VkInstance, + pPhysicalDeviceGroupCount: + *mut u32, + pPhysicalDeviceGroupProperties: + *mut VkPhysicalDeviceGroupPropertiesKHX) + -> VkResult; +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkExternalMemoryHandleTypeFlagBitsKHX { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 1, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 2, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 4, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX = 8, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX = 16, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX = 32, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX = 64, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 2147483647, +} +pub type VkExternalMemoryHandleTypeFlagsKHX = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkExternalMemoryFeatureFlagBitsKHX { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX = 1, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX = 2, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX = 4, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 2147483647, +} +pub type VkExternalMemoryFeatureFlagsKHX = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExternalMemoryPropertiesKHX { + pub externalMemoryFeatures: VkExternalMemoryFeatureFlagsKHX, + pub exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlagsKHX, + pub compatibleHandleTypes: VkExternalMemoryHandleTypeFlagsKHX, +} +impl Clone for VkExternalMemoryPropertiesKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceExternalImageFormatInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub handleType: VkExternalMemoryHandleTypeFlagBitsKHX, +} +impl Clone for VkPhysicalDeviceExternalImageFormatInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExternalImageFormatPropertiesKHX { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub externalMemoryProperties: VkExternalMemoryPropertiesKHX, +} +impl Clone for VkExternalImageFormatPropertiesKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceExternalBufferInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkBufferCreateFlags, + pub usage: VkBufferUsageFlags, + pub handleType: VkExternalMemoryHandleTypeFlagBitsKHX, +} +impl Clone for VkPhysicalDeviceExternalBufferInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExternalBufferPropertiesKHX { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub externalMemoryProperties: VkExternalMemoryPropertiesKHX, +} +impl Clone for VkExternalBufferPropertiesKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceIDPropertiesKHX { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub deviceUUID: [u8; 16usize], + pub driverUUID: [u8; 16usize], + pub deviceLUID: [u8; 8usize], + pub deviceLUIDValid: VkBool32, +} +impl Clone for VkPhysicalDeviceIDPropertiesKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct VkPhysicalDeviceProperties2KHX { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub properties: VkPhysicalDeviceProperties, +} +impl Clone for VkPhysicalDeviceProperties2KHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImageFormatProperties2KHX { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub imageFormatProperties: VkImageFormatProperties, +} +impl Clone for VkImageFormatProperties2KHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceImageFormatInfo2KHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub format: VkFormat, + pub type_: VkImageType, + pub tiling: VkImageTiling, + pub usage: VkImageUsageFlags, + pub flags: VkImageCreateFlags, +} +impl Clone for VkPhysicalDeviceImageFormatInfo2KHX { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHX = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceProperties2KHX = + ::std::option::Option; +pub type PFN_vkGetPhysicalDeviceImageFormatProperties2KHX = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkGetPhysicalDeviceExternalBufferPropertiesKHX(physicalDevice: + VkPhysicalDevice, + pExternalBufferInfo: + *const VkPhysicalDeviceExternalBufferInfoKHX, + pExternalBufferProperties: + *mut VkExternalBufferPropertiesKHX); +} +extern "C" { + pub fn vkGetPhysicalDeviceProperties2KHX(physicalDevice: VkPhysicalDevice, + pProperties: + *mut VkPhysicalDeviceProperties2KHX); +} +extern "C" { + pub fn vkGetPhysicalDeviceImageFormatProperties2KHX(physicalDevice: + VkPhysicalDevice, + pImageFormatInfo: + *const VkPhysicalDeviceImageFormatInfo2KHX, + pImageFormatProperties: + *mut VkImageFormatProperties2KHX) + -> VkResult; +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExternalMemoryImageCreateInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub handleTypes: VkExternalMemoryHandleTypeFlagsKHX, +} +impl Clone for VkExternalMemoryImageCreateInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExternalMemoryBufferCreateInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub handleTypes: VkExternalMemoryHandleTypeFlagsKHX, +} +impl Clone for VkExternalMemoryBufferCreateInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExportMemoryAllocateInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub handleTypes: VkExternalMemoryHandleTypeFlagsKHX, +} +impl Clone for VkExportMemoryAllocateInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImportMemoryFdInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub handleType: VkExternalMemoryHandleTypeFlagBitsKHX, + pub fd: ::std::os::raw::c_int, +} +impl Clone for VkImportMemoryFdInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkMemoryFdPropertiesKHX { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub memoryTypeBits: u32, +} +impl Clone for VkMemoryFdPropertiesKHX { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkGetMemoryFdKHX = + ::std::option::Option VkResult>; +pub type PFN_vkGetMemoryFdPropertiesKHX = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkGetMemoryFdKHX(device: VkDevice, memory: VkDeviceMemory, + handleType: VkExternalMemoryHandleTypeFlagBitsKHX, + pFd: *mut ::std::os::raw::c_int) -> VkResult; +} +extern "C" { + pub fn vkGetMemoryFdPropertiesKHX(device: VkDevice, + handleType: + VkExternalMemoryHandleTypeFlagBitsKHX, + fd: ::std::os::raw::c_int, + pMemoryFdProperties: + *mut VkMemoryFdPropertiesKHX) + -> VkResult; +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkExternalSemaphoreHandleTypeFlagBitsKHX { + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 1, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 2, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 4, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX = 8, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX = 16, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 2147483647, +} +pub type VkExternalSemaphoreHandleTypeFlagsKHX = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkExternalSemaphoreFeatureFlagBitsKHX { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX = 1, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX = 2, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 2147483647, +} +pub type VkExternalSemaphoreFeatureFlagsKHX = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceExternalSemaphoreInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub handleType: VkExternalSemaphoreHandleTypeFlagBitsKHX, +} +impl Clone for VkPhysicalDeviceExternalSemaphoreInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExternalSemaphorePropertiesKHX { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub exportFromImportedHandleTypes: VkExternalSemaphoreHandleTypeFlagsKHX, + pub compatibleHandleTypes: VkExternalSemaphoreHandleTypeFlagsKHX, + pub externalSemaphoreFeatures: VkExternalSemaphoreFeatureFlagsKHX, +} +impl Clone for VkExternalSemaphorePropertiesKHX { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX = + ::std::option::Option; +extern "C" { + pub fn vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(physicalDevice: + VkPhysicalDevice, + pExternalSemaphoreInfo: + *const VkPhysicalDeviceExternalSemaphoreInfoKHX, + pExternalSemaphoreProperties: + *mut VkExternalSemaphorePropertiesKHX); +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkExportSemaphoreCreateInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub handleTypes: VkExternalSemaphoreHandleTypeFlagsKHX, +} +impl Clone for VkExportSemaphoreCreateInfoKHX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkImportSemaphoreFdInfoKHX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub semaphore: VkSemaphore, + pub handleType: VkExternalSemaphoreHandleTypeFlagBitsKHX, + pub fd: ::std::os::raw::c_int, +} +impl Clone for VkImportSemaphoreFdInfoKHX { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkImportSemaphoreFdKHX = + ::std::option::Option VkResult>; +pub type PFN_vkGetSemaphoreFdKHX = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkImportSemaphoreFdKHX(device: VkDevice, + pImportSemaphoreFdInfo: + *const VkImportSemaphoreFdInfoKHX) + -> VkResult; +} +extern "C" { + pub fn vkGetSemaphoreFdKHX(device: VkDevice, semaphore: VkSemaphore, + handleType: + VkExternalSemaphoreHandleTypeFlagBitsKHX, + pFd: *mut ::std::os::raw::c_int) -> VkResult; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkObjectTableNVX_T { + _unused: [u8; 0], +} +pub type VkObjectTableNVX = *mut VkObjectTableNVX_T; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct VkIndirectCommandsLayoutNVX_T { + _unused: [u8; 0], +} +pub type VkIndirectCommandsLayoutNVX = *mut VkIndirectCommandsLayoutNVX_T; +pub const VkIndirectCommandsTokenTypeNVX_VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX: + VkIndirectCommandsTokenTypeNVX = + VkIndirectCommandsTokenTypeNVX::VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX; +pub const VkIndirectCommandsTokenTypeNVX_VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX: + VkIndirectCommandsTokenTypeNVX = + VkIndirectCommandsTokenTypeNVX::VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkIndirectCommandsTokenTypeNVX { + VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX = 0, + VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX = 1, + VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX = 2, + VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX = 3, + VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX = 4, + VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX = 5, + VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX = 6, + VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = 8, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 2147483647, +} +pub const VkObjectEntryTypeNVX_VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX: + VkObjectEntryTypeNVX = + VkObjectEntryTypeNVX::VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX; +pub const VkObjectEntryTypeNVX_VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX: + VkObjectEntryTypeNVX = + VkObjectEntryTypeNVX::VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkObjectEntryTypeNVX { + VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = 0, + VK_OBJECT_ENTRY_PIPELINE_NVX = 1, + VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = 2, + VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = 3, + VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = 4, + VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = 5, + VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 2147483647, +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkIndirectCommandsLayoutUsageFlagBitsNVX { + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 1, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 2, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 4, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 8, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 2147483647, +} +pub type VkIndirectCommandsLayoutUsageFlagsNVX = VkFlags; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkObjectEntryUsageFlagBitsNVX { + VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 1, + VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 2, + VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 2147483647, +} +pub type VkObjectEntryUsageFlagsNVX = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceGeneratedCommandsFeaturesNVX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub computeBindingPointSupport: VkBool32, +} +impl Clone for VkDeviceGeneratedCommandsFeaturesNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceGeneratedCommandsLimitsNVX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub maxIndirectCommandsLayoutTokenCount: u32, + pub maxObjectEntryCounts: u32, + pub minSequenceCountBufferOffsetAlignment: u32, + pub minSequenceIndexBufferOffsetAlignment: u32, + pub minCommandsTokenBufferOffsetAlignment: u32, +} +impl Clone for VkDeviceGeneratedCommandsLimitsNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkIndirectCommandsTokenNVX { + pub tokenType: VkIndirectCommandsTokenTypeNVX, + pub buffer: VkBuffer, + pub offset: VkDeviceSize, +} +impl Clone for VkIndirectCommandsTokenNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkIndirectCommandsLayoutTokenNVX { + pub tokenType: VkIndirectCommandsTokenTypeNVX, + pub bindingUnit: u32, + pub dynamicCount: u32, + pub divisor: u32, +} +impl Clone for VkIndirectCommandsLayoutTokenNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkIndirectCommandsLayoutCreateInfoNVX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub pipelineBindPoint: VkPipelineBindPoint, + pub flags: VkIndirectCommandsLayoutUsageFlagsNVX, + pub tokenCount: u32, + pub pTokens: *const VkIndirectCommandsLayoutTokenNVX, +} +impl Clone for VkIndirectCommandsLayoutCreateInfoNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkCmdProcessCommandsInfoNVX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub objectTable: VkObjectTableNVX, + pub indirectCommandsLayout: VkIndirectCommandsLayoutNVX, + pub indirectCommandsTokenCount: u32, + pub pIndirectCommandsTokens: *const VkIndirectCommandsTokenNVX, + pub maxSequencesCount: u32, + pub targetCommandBuffer: VkCommandBuffer, + pub sequencesCountBuffer: VkBuffer, + pub sequencesCountOffset: VkDeviceSize, + pub sequencesIndexBuffer: VkBuffer, + pub sequencesIndexOffset: VkDeviceSize, +} +impl Clone for VkCmdProcessCommandsInfoNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkCmdReserveSpaceForCommandsInfoNVX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub objectTable: VkObjectTableNVX, + pub indirectCommandsLayout: VkIndirectCommandsLayoutNVX, + pub maxSequencesCount: u32, +} +impl Clone for VkCmdReserveSpaceForCommandsInfoNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkObjectTableCreateInfoNVX { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub objectCount: u32, + pub pObjectEntryTypes: *const VkObjectEntryTypeNVX, + pub pObjectEntryCounts: *const u32, + pub pObjectEntryUsageFlags: *const VkObjectEntryUsageFlagsNVX, + pub maxUniformBuffersPerDescriptor: u32, + pub maxStorageBuffersPerDescriptor: u32, + pub maxStorageImagesPerDescriptor: u32, + pub maxSampledImagesPerDescriptor: u32, + pub maxPipelineLayouts: u32, +} +impl Clone for VkObjectTableCreateInfoNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkObjectTableEntryNVX { + pub type_: VkObjectEntryTypeNVX, + pub flags: VkObjectEntryUsageFlagsNVX, +} +impl Clone for VkObjectTableEntryNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkObjectTablePipelineEntryNVX { + pub type_: VkObjectEntryTypeNVX, + pub flags: VkObjectEntryUsageFlagsNVX, + pub pipeline: VkPipeline, +} +impl Clone for VkObjectTablePipelineEntryNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkObjectTableDescriptorSetEntryNVX { + pub type_: VkObjectEntryTypeNVX, + pub flags: VkObjectEntryUsageFlagsNVX, + pub pipelineLayout: VkPipelineLayout, + pub descriptorSet: VkDescriptorSet, +} +impl Clone for VkObjectTableDescriptorSetEntryNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkObjectTableVertexBufferEntryNVX { + pub type_: VkObjectEntryTypeNVX, + pub flags: VkObjectEntryUsageFlagsNVX, + pub buffer: VkBuffer, +} +impl Clone for VkObjectTableVertexBufferEntryNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkObjectTableIndexBufferEntryNVX { + pub type_: VkObjectEntryTypeNVX, + pub flags: VkObjectEntryUsageFlagsNVX, + pub buffer: VkBuffer, + pub indexType: VkIndexType, +} +impl Clone for VkObjectTableIndexBufferEntryNVX { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkObjectTablePushConstantEntryNVX { + pub type_: VkObjectEntryTypeNVX, + pub flags: VkObjectEntryUsageFlagsNVX, + pub pipelineLayout: VkPipelineLayout, + pub stageFlags: VkShaderStageFlags, +} +impl Clone for VkObjectTablePushConstantEntryNVX { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkCmdProcessCommandsNVX = + ::std::option::Option; +pub type PFN_vkCmdReserveSpaceForCommandsNVX = + ::std::option::Option; +pub type PFN_vkCreateIndirectCommandsLayoutNVX = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyIndirectCommandsLayoutNVX = + ::std::option::Option; +pub type PFN_vkCreateObjectTableNVX = + ::std::option::Option VkResult>; +pub type PFN_vkDestroyObjectTableNVX = + ::std::option::Option; +pub type PFN_vkRegisterObjectsNVX = + ::std::option::Option VkResult>; +pub type PFN_vkUnregisterObjectsNVX = + ::std::option::Option VkResult>; +pub type PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = + ::std::option::Option; +extern "C" { + pub fn vkCmdProcessCommandsNVX(commandBuffer: VkCommandBuffer, + pProcessCommandsInfo: + *const VkCmdProcessCommandsInfoNVX); +} +extern "C" { + pub fn vkCmdReserveSpaceForCommandsNVX(commandBuffer: VkCommandBuffer, + pReserveSpaceInfo: + *const VkCmdReserveSpaceForCommandsInfoNVX); +} +extern "C" { + pub fn vkCreateIndirectCommandsLayoutNVX(device: VkDevice, + pCreateInfo: + *const VkIndirectCommandsLayoutCreateInfoNVX, + pAllocator: + *const VkAllocationCallbacks, + pIndirectCommandsLayout: + *mut VkIndirectCommandsLayoutNVX) + -> VkResult; +} +extern "C" { + pub fn vkDestroyIndirectCommandsLayoutNVX(device: VkDevice, + indirectCommandsLayout: + VkIndirectCommandsLayoutNVX, + pAllocator: + *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkCreateObjectTableNVX(device: VkDevice, + pCreateInfo: + *const VkObjectTableCreateInfoNVX, + pAllocator: *const VkAllocationCallbacks, + pObjectTable: *mut VkObjectTableNVX) + -> VkResult; +} +extern "C" { + pub fn vkDestroyObjectTableNVX(device: VkDevice, + objectTable: VkObjectTableNVX, + pAllocator: *const VkAllocationCallbacks); +} +extern "C" { + pub fn vkRegisterObjectsNVX(device: VkDevice, + objectTable: VkObjectTableNVX, + objectCount: u32, + ppObjectTableEntries: + *const *const VkObjectTableEntryNVX, + pObjectIndices: *const u32) -> VkResult; +} +extern "C" { + pub fn vkUnregisterObjectsNVX(device: VkDevice, + objectTable: VkObjectTableNVX, + objectCount: u32, + pObjectEntryTypes: + *const VkObjectEntryTypeNVX, + pObjectIndices: *const u32) -> VkResult; +} +extern "C" { + pub fn vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice: + VkPhysicalDevice, + pFeatures: + *mut VkDeviceGeneratedCommandsFeaturesNVX, + pLimits: + *mut VkDeviceGeneratedCommandsLimitsNVX); +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkViewportWScalingNV { + pub xcoeff: f32, + pub ycoeff: f32, +} +impl Clone for VkViewportWScalingNV { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineViewportWScalingStateCreateInfoNV { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub viewportWScalingEnable: VkBool32, + pub viewportCount: u32, + pub pViewportWScalings: *const VkViewportWScalingNV, +} +impl Clone for VkPipelineViewportWScalingStateCreateInfoNV { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkCmdSetViewportWScalingNV = + ::std::option::Option; +extern "C" { + pub fn vkCmdSetViewportWScalingNV(commandBuffer: VkCommandBuffer, + firstViewport: u32, viewportCount: u32, + pViewportWScalings: + *const VkViewportWScalingNV); +} +pub type PFN_vkReleaseDisplayEXT = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkReleaseDisplayEXT(physicalDevice: VkPhysicalDevice, + display: VkDisplayKHR) -> VkResult; +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkSurfaceCounterFlagBitsEXT { + VK_SURFACE_COUNTER_VBLANK_EXT = 1, + VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 2147483647, +} +pub type VkSurfaceCounterFlagsEXT = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSurfaceCapabilities2EXT { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub minImageCount: u32, + pub maxImageCount: u32, + pub currentExtent: VkExtent2D, + pub minImageExtent: VkExtent2D, + pub maxImageExtent: VkExtent2D, + pub maxImageArrayLayers: u32, + pub supportedTransforms: VkSurfaceTransformFlagsKHR, + pub currentTransform: VkSurfaceTransformFlagBitsKHR, + pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR, + pub supportedUsageFlags: VkImageUsageFlags, + pub supportedSurfaceCounters: VkSurfaceCounterFlagsEXT, +} +impl Clone for VkSurfaceCapabilities2EXT { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice: + VkPhysicalDevice, + surface: VkSurfaceKHR, + pSurfaceCapabilities: + *mut VkSurfaceCapabilities2EXT) + -> VkResult; +} +pub const VkDisplayPowerStateEXT_VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT: + VkDisplayPowerStateEXT = + VkDisplayPowerStateEXT::VK_DISPLAY_POWER_STATE_OFF_EXT; +pub const VkDisplayPowerStateEXT_VK_DISPLAY_POWER_STATE_END_RANGE_EXT: + VkDisplayPowerStateEXT = + VkDisplayPowerStateEXT::VK_DISPLAY_POWER_STATE_ON_EXT; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDisplayPowerStateEXT { + VK_DISPLAY_POWER_STATE_OFF_EXT = 0, + VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, + VK_DISPLAY_POWER_STATE_ON_EXT = 2, + VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = 3, + VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 2147483647, +} +pub const VkDeviceEventTypeEXT_VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT: + VkDeviceEventTypeEXT = + VkDeviceEventTypeEXT::VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT; +pub const VkDeviceEventTypeEXT_VK_DEVICE_EVENT_TYPE_END_RANGE_EXT: + VkDeviceEventTypeEXT = + VkDeviceEventTypeEXT::VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDeviceEventTypeEXT { + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, + VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = 1, + VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 2147483647, +} +pub const VkDisplayEventTypeEXT_VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT: + VkDisplayEventTypeEXT = + VkDisplayEventTypeEXT::VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT; +pub const VkDisplayEventTypeEXT_VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT: + VkDisplayEventTypeEXT = + VkDisplayEventTypeEXT::VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDisplayEventTypeEXT { + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, + VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = 1, + VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 2147483647, +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDisplayPowerInfoEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub powerState: VkDisplayPowerStateEXT, +} +impl Clone for VkDisplayPowerInfoEXT { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDeviceEventInfoEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub deviceEvent: VkDeviceEventTypeEXT, +} +impl Clone for VkDeviceEventInfoEXT { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkDisplayEventInfoEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub displayEvent: VkDisplayEventTypeEXT, +} +impl Clone for VkDisplayEventInfoEXT { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkSwapchainCounterCreateInfoEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub surfaceCounters: VkSurfaceCounterFlagsEXT, +} +impl Clone for VkSwapchainCounterCreateInfoEXT { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkDisplayPowerControlEXT = + ::std::option::Option VkResult>; +pub type PFN_vkRegisterDeviceEventEXT = + ::std::option::Option VkResult>; +pub type PFN_vkRegisterDisplayEventEXT = + ::std::option::Option VkResult>; +pub type PFN_vkGetSwapchainCounterEXT = + ::std::option::Option VkResult>; +extern "C" { + pub fn vkDisplayPowerControlEXT(device: VkDevice, display: VkDisplayKHR, + pDisplayPowerInfo: + *const VkDisplayPowerInfoEXT) + -> VkResult; +} +extern "C" { + pub fn vkRegisterDeviceEventEXT(device: VkDevice, + pDeviceEventInfo: + *const VkDeviceEventInfoEXT, + pAllocator: *const VkAllocationCallbacks, + pFence: *mut VkFence) -> VkResult; +} +extern "C" { + pub fn vkRegisterDisplayEventEXT(device: VkDevice, display: VkDisplayKHR, + pDisplayEventInfo: + *const VkDisplayEventInfoEXT, + pAllocator: *const VkAllocationCallbacks, + pFence: *mut VkFence) -> VkResult; +} +extern "C" { + pub fn vkGetSwapchainCounterEXT(device: VkDevice, + swapchain: VkSwapchainKHR, + counter: VkSurfaceCounterFlagBitsEXT, + pCounterValue: *mut u64) -> VkResult; +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + pub sType: VkStructureType, + pub pNext: *mut ::std::os::raw::c_void, + pub perViewPositionAllComponents: VkBool32, +} +impl Clone for VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + fn clone(&self) -> Self { *self } +} +pub const VkViewportCoordinateSwizzleNV_VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV: + VkViewportCoordinateSwizzleNV = + VkViewportCoordinateSwizzleNV::VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV; +pub const VkViewportCoordinateSwizzleNV_VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV: + VkViewportCoordinateSwizzleNV = + VkViewportCoordinateSwizzleNV::VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkViewportCoordinateSwizzleNV { + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, + VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = 8, + VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 2147483647, +} +pub type VkPipelineViewportSwizzleStateCreateFlagsNV = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkViewportSwizzleNV { + pub x: VkViewportCoordinateSwizzleNV, + pub y: VkViewportCoordinateSwizzleNV, + pub z: VkViewportCoordinateSwizzleNV, + pub w: VkViewportCoordinateSwizzleNV, +} +impl Clone for VkViewportSwizzleNV { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineViewportSwizzleStateCreateInfoNV { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineViewportSwizzleStateCreateFlagsNV, + pub viewportCount: u32, + pub pViewportSwizzles: *const VkViewportSwizzleNV, +} +impl Clone for VkPipelineViewportSwizzleStateCreateInfoNV { + fn clone(&self) -> Self { *self } +} +pub const VkDiscardRectangleModeEXT_VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT: + VkDiscardRectangleModeEXT = + VkDiscardRectangleModeEXT::VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT; +pub const VkDiscardRectangleModeEXT_VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT: + VkDiscardRectangleModeEXT = + VkDiscardRectangleModeEXT::VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum VkDiscardRectangleModeEXT { + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = 2, + VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 2147483647, +} +pub type VkPipelineDiscardRectangleStateCreateFlagsEXT = VkFlags; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub maxDiscardRectangles: u32, +} +impl Clone for VkPhysicalDeviceDiscardRectanglePropertiesEXT { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct VkPipelineDiscardRectangleStateCreateInfoEXT { + pub sType: VkStructureType, + pub pNext: *const ::std::os::raw::c_void, + pub flags: VkPipelineDiscardRectangleStateCreateFlagsEXT, + pub discardRectangleMode: VkDiscardRectangleModeEXT, + pub discardRectangleCount: u32, + pub pDiscardRectangles: *const VkRect2D, +} +impl Clone for VkPipelineDiscardRectangleStateCreateInfoEXT { + fn clone(&self) -> Self { *self } +} +pub type PFN_vkCmdSetDiscardRectangleEXT = + ::std::option::Option; +extern "C" { + pub fn vkCmdSetDiscardRectangleEXT(commandBuffer: VkCommandBuffer, + firstDiscardRectangle: u32, + discardRectangleCount: u32, + pDiscardRectangles: *const VkRect2D); +}