/* automatically generated by rust-bindgen */ pub type VkFlags = u32; pub type VkBool32 = u32; pub type VkDeviceSize = u64; #[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 VkCommandBuffer_T { _unused: [u8; 0], } pub type VkCommandBuffer = *mut VkCommandBuffer_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; pub const VkResult_VK_SUCCESS: VkResult = 0; pub const VkResult_VK_NOT_READY: VkResult = 1; pub const VkResult_VK_TIMEOUT: VkResult = 2; pub const VkResult_VK_EVENT_SET: VkResult = 3; pub const VkResult_VK_EVENT_RESET: VkResult = 4; pub const VkResult_VK_INCOMPLETE: VkResult = 5; pub const VkResult_VK_ERROR_OUT_OF_HOST_MEMORY: VkResult = -1; pub const VkResult_VK_ERROR_OUT_OF_DEVICE_MEMORY: VkResult = -2; pub const VkResult_VK_ERROR_INITIALIZATION_FAILED: VkResult = -3; pub const VkResult_VK_ERROR_DEVICE_LOST: VkResult = -4; pub const VkResult_VK_ERROR_MEMORY_MAP_FAILED: VkResult = -5; pub const VkResult_VK_ERROR_LAYER_NOT_PRESENT: VkResult = -6; pub const VkResult_VK_ERROR_EXTENSION_NOT_PRESENT: VkResult = -7; pub const VkResult_VK_ERROR_FEATURE_NOT_PRESENT: VkResult = -8; pub const VkResult_VK_ERROR_INCOMPATIBLE_DRIVER: VkResult = -9; pub const VkResult_VK_ERROR_TOO_MANY_OBJECTS: VkResult = -10; pub const VkResult_VK_ERROR_FORMAT_NOT_SUPPORTED: VkResult = -11; pub const VkResult_VK_ERROR_FRAGMENTED_POOL: VkResult = -12; pub const VkResult_VK_ERROR_OUT_OF_POOL_MEMORY: VkResult = -1000069000; pub const VkResult_VK_ERROR_INVALID_EXTERNAL_HANDLE: VkResult = -1000072003; pub const VkResult_VK_ERROR_SURFACE_LOST_KHR: VkResult = -1000000000; pub const VkResult_VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: VkResult = -1000000001; pub const VkResult_VK_SUBOPTIMAL_KHR: VkResult = 1000001003; pub const VkResult_VK_ERROR_OUT_OF_DATE_KHR: VkResult = -1000001004; pub const VkResult_VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: VkResult = -1000003001; pub const VkResult_VK_ERROR_VALIDATION_FAILED_EXT: VkResult = -1000011001; pub const VkResult_VK_ERROR_INVALID_SHADER_NV: VkResult = -1000012000; pub const VkResult_VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: VkResult = -1000158000; pub const VkResult_VK_ERROR_FRAGMENTATION_EXT: VkResult = -1000161000; pub const VkResult_VK_ERROR_NOT_PERMITTED_EXT: VkResult = -1000174001; pub const VkResult_VK_ERROR_OUT_OF_POOL_MEMORY_KHR: VkResult = -1000069000; pub const VkResult_VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR: VkResult = -1000072003; pub const VkResult_VK_RESULT_BEGIN_RANGE: VkResult = -12; pub const VkResult_VK_RESULT_END_RANGE: VkResult = 5; pub const VkResult_VK_RESULT_RANGE_SIZE: VkResult = 18; pub const VkResult_VK_RESULT_MAX_ENUM: VkResult = 2147483647; pub type VkResult = i32; pub const VkStructureType_VK_STRUCTURE_TYPE_APPLICATION_INFO: VkStructureType = 0; pub const VkStructureType_VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: VkStructureType = 1; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: VkStructureType = 2; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: VkStructureType = 3; pub const VkStructureType_VK_STRUCTURE_TYPE_SUBMIT_INFO: VkStructureType = 4; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: VkStructureType = 5; pub const VkStructureType_VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: VkStructureType = 6; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: VkStructureType = 7; pub const VkStructureType_VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: VkStructureType = 8; pub const VkStructureType_VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: VkStructureType = 9; pub const VkStructureType_VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: VkStructureType = 10; pub const VkStructureType_VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: VkStructureType = 11; pub const VkStructureType_VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: VkStructureType = 12; pub const VkStructureType_VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: VkStructureType = 13; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: VkStructureType = 14; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: VkStructureType = 15; pub const VkStructureType_VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: VkStructureType = 16; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: VkStructureType = 17; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: VkStructureType = 18; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: VkStructureType = 19; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: VkStructureType = 20; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: VkStructureType = 21; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: VkStructureType = 22; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: VkStructureType = 23; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: VkStructureType = 24; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: VkStructureType = 25; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: VkStructureType = 26; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: VkStructureType = 27; pub const VkStructureType_VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: VkStructureType = 28; pub const VkStructureType_VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: VkStructureType = 29; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: VkStructureType = 30; pub const VkStructureType_VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: VkStructureType = 31; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: VkStructureType = 32; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: VkStructureType = 33; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: VkStructureType = 34; pub const VkStructureType_VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: VkStructureType = 35; pub const VkStructureType_VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: VkStructureType = 36; pub const VkStructureType_VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: VkStructureType = 37; pub const VkStructureType_VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: VkStructureType = 38; pub const VkStructureType_VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: VkStructureType = 39; pub const VkStructureType_VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: VkStructureType = 40; pub const VkStructureType_VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: VkStructureType = 41; pub const VkStructureType_VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 42; pub const VkStructureType_VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: VkStructureType = 43; pub const VkStructureType_VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: VkStructureType = 44; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: VkStructureType = 45; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_BARRIER: VkStructureType = 46; pub const VkStructureType_VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: VkStructureType = 47; pub const VkStructureType_VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: VkStructureType = 48; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: VkStructureType = 1000094000; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: VkStructureType = 1000157000; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: VkStructureType = 1000157001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: VkStructureType = 1000083000; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: VkStructureType = 1000127000; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: VkStructureType = 1000127001; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: VkStructureType = 1000060000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: VkStructureType = 1000060003; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 1000060004; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: VkStructureType = 1000060005; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: VkStructureType = 1000060006; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: VkStructureType = 1000060013; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: VkStructureType = 1000060014; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: VkStructureType = 1000070000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: VkStructureType = 1000070001; pub const VkStructureType_VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146000; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146001; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146002; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: VkStructureType = 1000146003; pub const VkStructureType_VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: VkStructureType = 1000146004; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: VkStructureType = 1000059000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: VkStructureType = 1000059001; pub const VkStructureType_VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: VkStructureType = 1000059002; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = 1000059003; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: VkStructureType = 1000059004; pub const VkStructureType_VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: VkStructureType = 1000059005; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: VkStructureType = 1000059006; pub const VkStructureType_VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = 1000059007; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: VkStructureType = 1000059008; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: VkStructureType = 1000117000; pub const VkStructureType_VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: VkStructureType = 1000117001; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: VkStructureType = 1000117002; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO : VkStructureType = 1000117003 ; pub const VkStructureType_VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: VkStructureType = 1000053000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: VkStructureType = 1000053001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: VkStructureType = 1000053002; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: VkStructureType = 1000120000; pub const VkStructureType_VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: VkStructureType = 1000145000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: VkStructureType = 1000145001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: VkStructureType = 1000145002; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: VkStructureType = 1000145003; pub const VkStructureType_VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: VkStructureType = 1000156000; pub const VkStructureType_VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: VkStructureType = 1000156001; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: VkStructureType = 1000156002; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: VkStructureType = 1000156003; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: VkStructureType = 1000156004; pub const VkStructureType_VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: VkStructureType = 1000156005; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: VkStructureType = 1000085000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: VkStructureType = 1000071000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: VkStructureType = 1000071001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: VkStructureType = 1000071002; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: VkStructureType = 1000071003; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: VkStructureType = 1000071004; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: VkStructureType = 1000072000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: VkStructureType = 1000072001; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: VkStructureType = 1000072002; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: VkStructureType = 1000112000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: VkStructureType = 1000112001; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: VkStructureType = 1000113000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: VkStructureType = 1000077000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: VkStructureType = 1000076000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: VkStructureType = 1000076001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: VkStructureType = 1000168000; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: VkStructureType = 1000168001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: VkStructureType = 1000063000; pub const VkStructureType_VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000001000; pub const VkStructureType_VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: VkStructureType = 1000001001; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: VkStructureType = 1000060007; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000060008; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: VkStructureType = 1000060009; pub const VkStructureType_VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: VkStructureType = 1000060010; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: VkStructureType = 1000060011; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000060012; pub const VkStructureType_VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: VkStructureType = 1000002000; pub const VkStructureType_VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000002001; pub const VkStructureType_VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: VkStructureType = 1000003000; pub const VkStructureType_VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000004000; pub const VkStructureType_VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000005000; pub const VkStructureType_VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000006000; pub const VkStructureType_VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000008000; pub const VkStructureType_VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000009000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: VkStructureType = 1000011000; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: VkStructureType = 1000018000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: VkStructureType = 1000022000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: VkStructureType = 1000022001; pub const VkStructureType_VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: VkStructureType = 1000022002; pub const VkStructureType_VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: VkStructureType = 1000026000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: VkStructureType = 1000026001; pub const VkStructureType_VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: VkStructureType = 1000026002; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: VkStructureType = 1000028000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: VkStructureType = 1000028001; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: VkStructureType = 1000028002; pub const VkStructureType_VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: VkStructureType = 1000041000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: VkStructureType = 1000050000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: VkStructureType = 1000056000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: VkStructureType = 1000056001; pub const VkStructureType_VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: VkStructureType = 1000057000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: VkStructureType = 1000057001; pub const VkStructureType_VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: VkStructureType = 1000058000; pub const VkStructureType_VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: VkStructureType = 1000061000; pub const VkStructureType_VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN: VkStructureType = 1000062000; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: VkStructureType = 1000067000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: VkStructureType = 1000067001; pub const VkStructureType_VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000073000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000073001; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR: VkStructureType = 1000073002; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000073003; pub const VkStructureType_VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: VkStructureType = 1000074000; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: VkStructureType = 1000074001; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: VkStructureType = 1000074002; pub const VkStructureType_VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: VkStructureType = 1000075000; pub const VkStructureType_VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000078000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000078001; pub const VkStructureType_VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: VkStructureType = 1000078002; pub const VkStructureType_VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000078003; pub const VkStructureType_VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: VkStructureType = 1000079000; pub const VkStructureType_VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: VkStructureType = 1000079001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: VkStructureType = 1000080000; pub const VkStructureType_VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT : VkStructureType = 1000081000 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: VkStructureType = 1000081001; pub const VkStructureType_VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: VkStructureType = 1000081002; pub const VkStructureType_VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: VkStructureType = 1000084000; pub const VkStructureType_VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX: VkStructureType = 1000086000; pub const VkStructureType_VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX: VkStructureType = 1000086001; pub const VkStructureType_VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX: VkStructureType = 1000086002; pub const VkStructureType_VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX: VkStructureType = 1000086003; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX: VkStructureType = 1000086004; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX: VkStructureType = 1000086005; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: VkStructureType = 1000087000; pub const VkStructureType_VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT: VkStructureType = 1000090000; pub const VkStructureType_VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: VkStructureType = 1000091000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: VkStructureType = 1000091001; pub const VkStructureType_VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: VkStructureType = 1000091002; pub const VkStructureType_VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: VkStructureType = 1000091003; pub const VkStructureType_VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: VkStructureType = 1000092000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX : VkStructureType = 1000097000 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: VkStructureType = 1000098000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: VkStructureType = 1000099000; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: VkStructureType = 1000099001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT : VkStructureType = 1000101000 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT : VkStructureType = 1000101001 ; pub const VkStructureType_VK_STRUCTURE_TYPE_HDR_METADATA_EXT: VkStructureType = 1000105000; pub const VkStructureType_VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR: VkStructureType = 1000109000; pub const VkStructureType_VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR: VkStructureType = 1000109001; pub const VkStructureType_VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR: VkStructureType = 1000109002; pub const VkStructureType_VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR: VkStructureType = 1000109003; pub const VkStructureType_VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR: VkStructureType = 1000109004; pub const VkStructureType_VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR: VkStructureType = 1000109005; pub const VkStructureType_VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR: VkStructureType = 1000109006; pub const VkStructureType_VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: VkStructureType = 1000111000; pub const VkStructureType_VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000114000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000114001; pub const VkStructureType_VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000114002; pub const VkStructureType_VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: VkStructureType = 1000115000; pub const VkStructureType_VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: VkStructureType = 1000115001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: VkStructureType = 1000119000; pub const VkStructureType_VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: VkStructureType = 1000119001; pub const VkStructureType_VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: VkStructureType = 1000119002; pub const VkStructureType_VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR: VkStructureType = 1000121000; pub const VkStructureType_VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR: VkStructureType = 1000121001; pub const VkStructureType_VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR: VkStructureType = 1000121002; pub const VkStructureType_VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR: VkStructureType = 1000121003; pub const VkStructureType_VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR: VkStructureType = 1000121004; pub const VkStructureType_VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK: VkStructureType = 1000122000; pub const VkStructureType_VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK: VkStructureType = 1000123000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: VkStructureType = 1000128000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: VkStructureType = 1000128001; pub const VkStructureType_VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: VkStructureType = 1000128002; pub const VkStructureType_VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: VkStructureType = 1000128003; pub const VkStructureType_VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: VkStructureType = 1000128004; pub const VkStructureType_VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: VkStructureType = 1000129000; pub const VkStructureType_VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: VkStructureType = 1000129001; pub const VkStructureType_VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: VkStructureType = 1000129002; pub const VkStructureType_VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: VkStructureType = 1000129003; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: VkStructureType = 1000129004; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: VkStructureType = 1000129005; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: VkStructureType = 1000130000; pub const VkStructureType_VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: VkStructureType = 1000130001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: VkStructureType = 1000138000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: VkStructureType = 1000138001; pub const VkStructureType_VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: VkStructureType = 1000138002; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: VkStructureType = 1000138003; pub const VkStructureType_VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: VkStructureType = 1000143000; pub const VkStructureType_VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: VkStructureType = 1000143001; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: VkStructureType = 1000143002; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: VkStructureType = 1000143003; pub const VkStructureType_VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: VkStructureType = 1000143004; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR: VkStructureType = 1000147000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT : VkStructureType = 1000148000 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT : VkStructureType = 1000148001 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: VkStructureType = 1000148002; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: VkStructureType = 1000149000; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: VkStructureType = 1000152000; pub const VkStructureType_VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: VkStructureType = 1000158000; pub const VkStructureType_VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: VkStructureType = 1000158001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: VkStructureType = 1000158002; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: VkStructureType = 1000158003; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: VkStructureType = 1000158004; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: VkStructureType = 1000158005; pub const VkStructureType_VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT: VkStructureType = 1000160000; pub const VkStructureType_VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: VkStructureType = 1000160001; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: VkStructureType = 1000161000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: VkStructureType = 1000161001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: VkStructureType = 1000161002; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT : VkStructureType = 1000161003 ; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT : VkStructureType = 1000161004 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV : VkStructureType = 1000164000 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: VkStructureType = 1000164001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: VkStructureType = 1000164002; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV : VkStructureType = 1000164005 ; pub const VkStructureType_VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: VkStructureType = 1000165000; pub const VkStructureType_VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: VkStructureType = 1000165001; pub const VkStructureType_VK_STRUCTURE_TYPE_GEOMETRY_NV: VkStructureType = 1000165003; pub const VkStructureType_VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: VkStructureType = 1000165004; pub const VkStructureType_VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: VkStructureType = 1000165005; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: VkStructureType = 1000165006; pub const VkStructureType_VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: VkStructureType = 1000165007; pub const VkStructureType_VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: VkStructureType = 1000165008; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: VkStructureType = 1000165009; pub const VkStructureType_VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: VkStructureType = 1000165011; pub const VkStructureType_VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: VkStructureType = 1000165012; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV : VkStructureType = 1000166000 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV : VkStructureType = 1000166001 ; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: VkStructureType = 1000174000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: VkStructureType = 1000177000; pub const VkStructureType_VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: VkStructureType = 1000178000; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: VkStructureType = 1000178001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: VkStructureType = 1000178002; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: VkStructureType = 1000180000; pub const VkStructureType_VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: VkStructureType = 1000184000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: VkStructureType = 1000185000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: VkStructureType = 1000189000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT : VkStructureType = 1000190000 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: VkStructureType = 1000190001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT : VkStructureType = 1000190002 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: VkStructureType = 1000196000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV : VkStructureType = 1000201000 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: VkStructureType = 1000202000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: VkStructureType = 1000202001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV : VkStructureType = 1000203000 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: VkStructureType = 1000204000; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV : VkStructureType = 1000205000 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: VkStructureType = 1000205002; pub const VkStructureType_VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: VkStructureType = 1000206000; pub const VkStructureType_VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: VkStructureType = 1000206001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: VkStructureType = 1000211000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: VkStructureType = 1000212000; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: VkStructureType = 1000214000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT: VkStructureType = 1000011000; pub const VkStructureType_VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: VkStructureType = 1000053000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: VkStructureType = 1000053001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: VkStructureType = 1000053002; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: VkStructureType = 1000059000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: VkStructureType = 1000059001; pub const VkStructureType_VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: VkStructureType = 1000059002; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = 1000059003; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = 1000059004; pub const VkStructureType_VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR: VkStructureType = 1000059005; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: VkStructureType = 1000059006; pub const VkStructureType_VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = 1000059007; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = 1000059008; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR: VkStructureType = 1000060000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: VkStructureType = 1000060003; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: VkStructureType = 1000060004; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR: VkStructureType = 1000060005; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR: VkStructureType = 1000060006; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = 1000060013; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = 1000060014; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: VkStructureType = 1000070000; pub const VkStructureType_VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: VkStructureType = 1000070001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: VkStructureType = 1000071000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = 1000071001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: VkStructureType = 1000071002; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR: VkStructureType = 1000071003; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: VkStructureType = 1000071004; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: VkStructureType = 1000072000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: VkStructureType = 1000072001; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR: VkStructureType = 1000072002; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: VkStructureType = 1000076000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR: VkStructureType = 1000076001; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR: VkStructureType = 1000077000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: VkStructureType = 1000083000; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: VkStructureType = 1000085000; pub const VkStructureType_VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT: VkStructureType = 1000090000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: VkStructureType = 1000112000; pub const VkStructureType_VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR: VkStructureType = 1000112001; pub const VkStructureType_VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR: VkStructureType = 1000113000; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: VkStructureType = 1000117000; pub const VkStructureType_VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: VkStructureType = 1000117001; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR: VkStructureType = 1000117002; pub const VkStructureType_VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR : VkStructureType = 1000117003 ; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: VkStructureType = 1000120000; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: VkStructureType = 1000127000; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR: VkStructureType = 1000127001; pub const VkStructureType_VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = 1000146000; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = 1000146001; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = 1000146002; pub const VkStructureType_VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = 1000146003; pub const VkStructureType_VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = 1000146004; pub const VkStructureType_VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: VkStructureType = 1000156000; pub const VkStructureType_VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR: VkStructureType = 1000156001; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR: VkStructureType = 1000156002; pub const VkStructureType_VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: VkStructureType = 1000156003; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR : VkStructureType = 1000156004 ; pub const VkStructureType_VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = 1000156005; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR: VkStructureType = 1000157000; pub const VkStructureType_VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR: VkStructureType = 1000157001; pub const VkStructureType_VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: VkStructureType = 1000168000; pub const VkStructureType_VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: VkStructureType = 1000168001; pub const VkStructureType_VK_STRUCTURE_TYPE_BEGIN_RANGE: VkStructureType = 0; pub const VkStructureType_VK_STRUCTURE_TYPE_END_RANGE: VkStructureType = 48; pub const VkStructureType_VK_STRUCTURE_TYPE_RANGE_SIZE: VkStructureType = 49; pub const VkStructureType_VK_STRUCTURE_TYPE_MAX_ENUM: VkStructureType = 2147483647; pub type VkStructureType = u32; pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_COMMAND: VkSystemAllocationScope = 0; pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_OBJECT: VkSystemAllocationScope = 1; pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_CACHE: VkSystemAllocationScope = 2; pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_DEVICE: VkSystemAllocationScope = 3; pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE: VkSystemAllocationScope = 4; pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE: VkSystemAllocationScope = 0; pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE: VkSystemAllocationScope = 4; pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE: VkSystemAllocationScope = 5; pub const VkSystemAllocationScope_VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM: VkSystemAllocationScope = 2147483647; pub type VkSystemAllocationScope = u32; pub const VkInternalAllocationType_VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE: VkInternalAllocationType = 0; pub const VkInternalAllocationType_VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE: VkInternalAllocationType = 0; pub const VkInternalAllocationType_VK_INTERNAL_ALLOCATION_TYPE_END_RANGE: VkInternalAllocationType = 0; pub const VkInternalAllocationType_VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE: VkInternalAllocationType = 1; pub const VkInternalAllocationType_VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM: VkInternalAllocationType = 2147483647; pub type VkInternalAllocationType = u32; pub const VkFormat_VK_FORMAT_UNDEFINED: VkFormat = 0; pub const VkFormat_VK_FORMAT_R4G4_UNORM_PACK8: VkFormat = 1; pub const VkFormat_VK_FORMAT_R4G4B4A4_UNORM_PACK16: VkFormat = 2; pub const VkFormat_VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormat = 3; pub const VkFormat_VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormat = 4; pub const VkFormat_VK_FORMAT_B5G6R5_UNORM_PACK16: VkFormat = 5; pub const VkFormat_VK_FORMAT_R5G5B5A1_UNORM_PACK16: VkFormat = 6; pub const VkFormat_VK_FORMAT_B5G5R5A1_UNORM_PACK16: VkFormat = 7; pub const VkFormat_VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormat = 8; pub const VkFormat_VK_FORMAT_R8_UNORM: VkFormat = 9; pub const VkFormat_VK_FORMAT_R8_SNORM: VkFormat = 10; pub const VkFormat_VK_FORMAT_R8_USCALED: VkFormat = 11; pub const VkFormat_VK_FORMAT_R8_SSCALED: VkFormat = 12; pub const VkFormat_VK_FORMAT_R8_UINT: VkFormat = 13; pub const VkFormat_VK_FORMAT_R8_SINT: VkFormat = 14; pub const VkFormat_VK_FORMAT_R8_SRGB: VkFormat = 15; pub const VkFormat_VK_FORMAT_R8G8_UNORM: VkFormat = 16; pub const VkFormat_VK_FORMAT_R8G8_SNORM: VkFormat = 17; pub const VkFormat_VK_FORMAT_R8G8_USCALED: VkFormat = 18; pub const VkFormat_VK_FORMAT_R8G8_SSCALED: VkFormat = 19; pub const VkFormat_VK_FORMAT_R8G8_UINT: VkFormat = 20; pub const VkFormat_VK_FORMAT_R8G8_SINT: VkFormat = 21; pub const VkFormat_VK_FORMAT_R8G8_SRGB: VkFormat = 22; pub const VkFormat_VK_FORMAT_R8G8B8_UNORM: VkFormat = 23; pub const VkFormat_VK_FORMAT_R8G8B8_SNORM: VkFormat = 24; pub const VkFormat_VK_FORMAT_R8G8B8_USCALED: VkFormat = 25; pub const VkFormat_VK_FORMAT_R8G8B8_SSCALED: VkFormat = 26; pub const VkFormat_VK_FORMAT_R8G8B8_UINT: VkFormat = 27; pub const VkFormat_VK_FORMAT_R8G8B8_SINT: VkFormat = 28; pub const VkFormat_VK_FORMAT_R8G8B8_SRGB: VkFormat = 29; pub const VkFormat_VK_FORMAT_B8G8R8_UNORM: VkFormat = 30; pub const VkFormat_VK_FORMAT_B8G8R8_SNORM: VkFormat = 31; pub const VkFormat_VK_FORMAT_B8G8R8_USCALED: VkFormat = 32; pub const VkFormat_VK_FORMAT_B8G8R8_SSCALED: VkFormat = 33; pub const VkFormat_VK_FORMAT_B8G8R8_UINT: VkFormat = 34; pub const VkFormat_VK_FORMAT_B8G8R8_SINT: VkFormat = 35; pub const VkFormat_VK_FORMAT_B8G8R8_SRGB: VkFormat = 36; pub const VkFormat_VK_FORMAT_R8G8B8A8_UNORM: VkFormat = 37; pub const VkFormat_VK_FORMAT_R8G8B8A8_SNORM: VkFormat = 38; pub const VkFormat_VK_FORMAT_R8G8B8A8_USCALED: VkFormat = 39; pub const VkFormat_VK_FORMAT_R8G8B8A8_SSCALED: VkFormat = 40; pub const VkFormat_VK_FORMAT_R8G8B8A8_UINT: VkFormat = 41; pub const VkFormat_VK_FORMAT_R8G8B8A8_SINT: VkFormat = 42; pub const VkFormat_VK_FORMAT_R8G8B8A8_SRGB: VkFormat = 43; pub const VkFormat_VK_FORMAT_B8G8R8A8_UNORM: VkFormat = 44; pub const VkFormat_VK_FORMAT_B8G8R8A8_SNORM: VkFormat = 45; pub const VkFormat_VK_FORMAT_B8G8R8A8_USCALED: VkFormat = 46; pub const VkFormat_VK_FORMAT_B8G8R8A8_SSCALED: VkFormat = 47; pub const VkFormat_VK_FORMAT_B8G8R8A8_UINT: VkFormat = 48; pub const VkFormat_VK_FORMAT_B8G8R8A8_SINT: VkFormat = 49; pub const VkFormat_VK_FORMAT_B8G8R8A8_SRGB: VkFormat = 50; pub const VkFormat_VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormat = 51; pub const VkFormat_VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormat = 52; pub const VkFormat_VK_FORMAT_A8B8G8R8_USCALED_PACK32: VkFormat = 53; pub const VkFormat_VK_FORMAT_A8B8G8R8_SSCALED_PACK32: VkFormat = 54; pub const VkFormat_VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormat = 55; pub const VkFormat_VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormat = 56; pub const VkFormat_VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormat = 57; pub const VkFormat_VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormat = 58; pub const VkFormat_VK_FORMAT_A2R10G10B10_SNORM_PACK32: VkFormat = 59; pub const VkFormat_VK_FORMAT_A2R10G10B10_USCALED_PACK32: VkFormat = 60; pub const VkFormat_VK_FORMAT_A2R10G10B10_SSCALED_PACK32: VkFormat = 61; pub const VkFormat_VK_FORMAT_A2R10G10B10_UINT_PACK32: VkFormat = 62; pub const VkFormat_VK_FORMAT_A2R10G10B10_SINT_PACK32: VkFormat = 63; pub const VkFormat_VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormat = 64; pub const VkFormat_VK_FORMAT_A2B10G10R10_SNORM_PACK32: VkFormat = 65; pub const VkFormat_VK_FORMAT_A2B10G10R10_USCALED_PACK32: VkFormat = 66; pub const VkFormat_VK_FORMAT_A2B10G10R10_SSCALED_PACK32: VkFormat = 67; pub const VkFormat_VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormat = 68; pub const VkFormat_VK_FORMAT_A2B10G10R10_SINT_PACK32: VkFormat = 69; pub const VkFormat_VK_FORMAT_R16_UNORM: VkFormat = 70; pub const VkFormat_VK_FORMAT_R16_SNORM: VkFormat = 71; pub const VkFormat_VK_FORMAT_R16_USCALED: VkFormat = 72; pub const VkFormat_VK_FORMAT_R16_SSCALED: VkFormat = 73; pub const VkFormat_VK_FORMAT_R16_UINT: VkFormat = 74; pub const VkFormat_VK_FORMAT_R16_SINT: VkFormat = 75; pub const VkFormat_VK_FORMAT_R16_SFLOAT: VkFormat = 76; pub const VkFormat_VK_FORMAT_R16G16_UNORM: VkFormat = 77; pub const VkFormat_VK_FORMAT_R16G16_SNORM: VkFormat = 78; pub const VkFormat_VK_FORMAT_R16G16_USCALED: VkFormat = 79; pub const VkFormat_VK_FORMAT_R16G16_SSCALED: VkFormat = 80; pub const VkFormat_VK_FORMAT_R16G16_UINT: VkFormat = 81; pub const VkFormat_VK_FORMAT_R16G16_SINT: VkFormat = 82; pub const VkFormat_VK_FORMAT_R16G16_SFLOAT: VkFormat = 83; pub const VkFormat_VK_FORMAT_R16G16B16_UNORM: VkFormat = 84; pub const VkFormat_VK_FORMAT_R16G16B16_SNORM: VkFormat = 85; pub const VkFormat_VK_FORMAT_R16G16B16_USCALED: VkFormat = 86; pub const VkFormat_VK_FORMAT_R16G16B16_SSCALED: VkFormat = 87; pub const VkFormat_VK_FORMAT_R16G16B16_UINT: VkFormat = 88; pub const VkFormat_VK_FORMAT_R16G16B16_SINT: VkFormat = 89; pub const VkFormat_VK_FORMAT_R16G16B16_SFLOAT: VkFormat = 90; pub const VkFormat_VK_FORMAT_R16G16B16A16_UNORM: VkFormat = 91; pub const VkFormat_VK_FORMAT_R16G16B16A16_SNORM: VkFormat = 92; pub const VkFormat_VK_FORMAT_R16G16B16A16_USCALED: VkFormat = 93; pub const VkFormat_VK_FORMAT_R16G16B16A16_SSCALED: VkFormat = 94; pub const VkFormat_VK_FORMAT_R16G16B16A16_UINT: VkFormat = 95; pub const VkFormat_VK_FORMAT_R16G16B16A16_SINT: VkFormat = 96; pub const VkFormat_VK_FORMAT_R16G16B16A16_SFLOAT: VkFormat = 97; pub const VkFormat_VK_FORMAT_R32_UINT: VkFormat = 98; pub const VkFormat_VK_FORMAT_R32_SINT: VkFormat = 99; pub const VkFormat_VK_FORMAT_R32_SFLOAT: VkFormat = 100; pub const VkFormat_VK_FORMAT_R32G32_UINT: VkFormat = 101; pub const VkFormat_VK_FORMAT_R32G32_SINT: VkFormat = 102; pub const VkFormat_VK_FORMAT_R32G32_SFLOAT: VkFormat = 103; pub const VkFormat_VK_FORMAT_R32G32B32_UINT: VkFormat = 104; pub const VkFormat_VK_FORMAT_R32G32B32_SINT: VkFormat = 105; pub const VkFormat_VK_FORMAT_R32G32B32_SFLOAT: VkFormat = 106; pub const VkFormat_VK_FORMAT_R32G32B32A32_UINT: VkFormat = 107; pub const VkFormat_VK_FORMAT_R32G32B32A32_SINT: VkFormat = 108; pub const VkFormat_VK_FORMAT_R32G32B32A32_SFLOAT: VkFormat = 109; pub const VkFormat_VK_FORMAT_R64_UINT: VkFormat = 110; pub const VkFormat_VK_FORMAT_R64_SINT: VkFormat = 111; pub const VkFormat_VK_FORMAT_R64_SFLOAT: VkFormat = 112; pub const VkFormat_VK_FORMAT_R64G64_UINT: VkFormat = 113; pub const VkFormat_VK_FORMAT_R64G64_SINT: VkFormat = 114; pub const VkFormat_VK_FORMAT_R64G64_SFLOAT: VkFormat = 115; pub const VkFormat_VK_FORMAT_R64G64B64_UINT: VkFormat = 116; pub const VkFormat_VK_FORMAT_R64G64B64_SINT: VkFormat = 117; pub const VkFormat_VK_FORMAT_R64G64B64_SFLOAT: VkFormat = 118; pub const VkFormat_VK_FORMAT_R64G64B64A64_UINT: VkFormat = 119; pub const VkFormat_VK_FORMAT_R64G64B64A64_SINT: VkFormat = 120; pub const VkFormat_VK_FORMAT_R64G64B64A64_SFLOAT: VkFormat = 121; pub const VkFormat_VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormat = 122; pub const VkFormat_VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormat = 123; pub const VkFormat_VK_FORMAT_D16_UNORM: VkFormat = 124; pub const VkFormat_VK_FORMAT_X8_D24_UNORM_PACK32: VkFormat = 125; pub const VkFormat_VK_FORMAT_D32_SFLOAT: VkFormat = 126; pub const VkFormat_VK_FORMAT_S8_UINT: VkFormat = 127; pub const VkFormat_VK_FORMAT_D16_UNORM_S8_UINT: VkFormat = 128; pub const VkFormat_VK_FORMAT_D24_UNORM_S8_UINT: VkFormat = 129; pub const VkFormat_VK_FORMAT_D32_SFLOAT_S8_UINT: VkFormat = 130; pub const VkFormat_VK_FORMAT_BC1_RGB_UNORM_BLOCK: VkFormat = 131; pub const VkFormat_VK_FORMAT_BC1_RGB_SRGB_BLOCK: VkFormat = 132; pub const VkFormat_VK_FORMAT_BC1_RGBA_UNORM_BLOCK: VkFormat = 133; pub const VkFormat_VK_FORMAT_BC1_RGBA_SRGB_BLOCK: VkFormat = 134; pub const VkFormat_VK_FORMAT_BC2_UNORM_BLOCK: VkFormat = 135; pub const VkFormat_VK_FORMAT_BC2_SRGB_BLOCK: VkFormat = 136; pub const VkFormat_VK_FORMAT_BC3_UNORM_BLOCK: VkFormat = 137; pub const VkFormat_VK_FORMAT_BC3_SRGB_BLOCK: VkFormat = 138; pub const VkFormat_VK_FORMAT_BC4_UNORM_BLOCK: VkFormat = 139; pub const VkFormat_VK_FORMAT_BC4_SNORM_BLOCK: VkFormat = 140; pub const VkFormat_VK_FORMAT_BC5_UNORM_BLOCK: VkFormat = 141; pub const VkFormat_VK_FORMAT_BC5_SNORM_BLOCK: VkFormat = 142; pub const VkFormat_VK_FORMAT_BC6H_UFLOAT_BLOCK: VkFormat = 143; pub const VkFormat_VK_FORMAT_BC6H_SFLOAT_BLOCK: VkFormat = 144; pub const VkFormat_VK_FORMAT_BC7_UNORM_BLOCK: VkFormat = 145; pub const VkFormat_VK_FORMAT_BC7_SRGB_BLOCK: VkFormat = 146; pub const VkFormat_VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: VkFormat = 147; pub const VkFormat_VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: VkFormat = 148; pub const VkFormat_VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: VkFormat = 149; pub const VkFormat_VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: VkFormat = 150; pub const VkFormat_VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: VkFormat = 151; pub const VkFormat_VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: VkFormat = 152; pub const VkFormat_VK_FORMAT_EAC_R11_UNORM_BLOCK: VkFormat = 153; pub const VkFormat_VK_FORMAT_EAC_R11_SNORM_BLOCK: VkFormat = 154; pub const VkFormat_VK_FORMAT_EAC_R11G11_UNORM_BLOCK: VkFormat = 155; pub const VkFormat_VK_FORMAT_EAC_R11G11_SNORM_BLOCK: VkFormat = 156; pub const VkFormat_VK_FORMAT_ASTC_4x4_UNORM_BLOCK: VkFormat = 157; pub const VkFormat_VK_FORMAT_ASTC_4x4_SRGB_BLOCK: VkFormat = 158; pub const VkFormat_VK_FORMAT_ASTC_5x4_UNORM_BLOCK: VkFormat = 159; pub const VkFormat_VK_FORMAT_ASTC_5x4_SRGB_BLOCK: VkFormat = 160; pub const VkFormat_VK_FORMAT_ASTC_5x5_UNORM_BLOCK: VkFormat = 161; pub const VkFormat_VK_FORMAT_ASTC_5x5_SRGB_BLOCK: VkFormat = 162; pub const VkFormat_VK_FORMAT_ASTC_6x5_UNORM_BLOCK: VkFormat = 163; pub const VkFormat_VK_FORMAT_ASTC_6x5_SRGB_BLOCK: VkFormat = 164; pub const VkFormat_VK_FORMAT_ASTC_6x6_UNORM_BLOCK: VkFormat = 165; pub const VkFormat_VK_FORMAT_ASTC_6x6_SRGB_BLOCK: VkFormat = 166; pub const VkFormat_VK_FORMAT_ASTC_8x5_UNORM_BLOCK: VkFormat = 167; pub const VkFormat_VK_FORMAT_ASTC_8x5_SRGB_BLOCK: VkFormat = 168; pub const VkFormat_VK_FORMAT_ASTC_8x6_UNORM_BLOCK: VkFormat = 169; pub const VkFormat_VK_FORMAT_ASTC_8x6_SRGB_BLOCK: VkFormat = 170; pub const VkFormat_VK_FORMAT_ASTC_8x8_UNORM_BLOCK: VkFormat = 171; pub const VkFormat_VK_FORMAT_ASTC_8x8_SRGB_BLOCK: VkFormat = 172; pub const VkFormat_VK_FORMAT_ASTC_10x5_UNORM_BLOCK: VkFormat = 173; pub const VkFormat_VK_FORMAT_ASTC_10x5_SRGB_BLOCK: VkFormat = 174; pub const VkFormat_VK_FORMAT_ASTC_10x6_UNORM_BLOCK: VkFormat = 175; pub const VkFormat_VK_FORMAT_ASTC_10x6_SRGB_BLOCK: VkFormat = 176; pub const VkFormat_VK_FORMAT_ASTC_10x8_UNORM_BLOCK: VkFormat = 177; pub const VkFormat_VK_FORMAT_ASTC_10x8_SRGB_BLOCK: VkFormat = 178; pub const VkFormat_VK_FORMAT_ASTC_10x10_UNORM_BLOCK: VkFormat = 179; pub const VkFormat_VK_FORMAT_ASTC_10x10_SRGB_BLOCK: VkFormat = 180; pub const VkFormat_VK_FORMAT_ASTC_12x10_UNORM_BLOCK: VkFormat = 181; pub const VkFormat_VK_FORMAT_ASTC_12x10_SRGB_BLOCK: VkFormat = 182; pub const VkFormat_VK_FORMAT_ASTC_12x12_UNORM_BLOCK: VkFormat = 183; pub const VkFormat_VK_FORMAT_ASTC_12x12_SRGB_BLOCK: VkFormat = 184; pub const VkFormat_VK_FORMAT_G8B8G8R8_422_UNORM: VkFormat = 1000156000; pub const VkFormat_VK_FORMAT_B8G8R8G8_422_UNORM: VkFormat = 1000156001; pub const VkFormat_VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: VkFormat = 1000156002; pub const VkFormat_VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: VkFormat = 1000156003; pub const VkFormat_VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: VkFormat = 1000156004; pub const VkFormat_VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: VkFormat = 1000156005; pub const VkFormat_VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: VkFormat = 1000156006; pub const VkFormat_VK_FORMAT_R10X6_UNORM_PACK16: VkFormat = 1000156007; pub const VkFormat_VK_FORMAT_R10X6G10X6_UNORM_2PACK16: VkFormat = 1000156008; pub const VkFormat_VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: VkFormat = 1000156009; pub const VkFormat_VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: VkFormat = 1000156010; pub const VkFormat_VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: VkFormat = 1000156011; pub const VkFormat_VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: VkFormat = 1000156012; pub const VkFormat_VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: VkFormat = 1000156013; pub const VkFormat_VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: VkFormat = 1000156014; pub const VkFormat_VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: VkFormat = 1000156015; pub const VkFormat_VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: VkFormat = 1000156016; pub const VkFormat_VK_FORMAT_R12X4_UNORM_PACK16: VkFormat = 1000156017; pub const VkFormat_VK_FORMAT_R12X4G12X4_UNORM_2PACK16: VkFormat = 1000156018; pub const VkFormat_VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: VkFormat = 1000156019; pub const VkFormat_VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: VkFormat = 1000156020; pub const VkFormat_VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: VkFormat = 1000156021; pub const VkFormat_VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: VkFormat = 1000156022; pub const VkFormat_VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: VkFormat = 1000156023; pub const VkFormat_VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: VkFormat = 1000156024; pub const VkFormat_VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: VkFormat = 1000156025; pub const VkFormat_VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: VkFormat = 1000156026; pub const VkFormat_VK_FORMAT_G16B16G16R16_422_UNORM: VkFormat = 1000156027; pub const VkFormat_VK_FORMAT_B16G16R16G16_422_UNORM: VkFormat = 1000156028; pub const VkFormat_VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: VkFormat = 1000156029; pub const VkFormat_VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: VkFormat = 1000156030; pub const VkFormat_VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: VkFormat = 1000156031; pub const VkFormat_VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: VkFormat = 1000156032; pub const VkFormat_VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: VkFormat = 1000156033; pub const VkFormat_VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: VkFormat = 1000054000; pub const VkFormat_VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: VkFormat = 1000054001; pub const VkFormat_VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: VkFormat = 1000054002; pub const VkFormat_VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: VkFormat = 1000054003; pub const VkFormat_VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: VkFormat = 1000054004; pub const VkFormat_VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: VkFormat = 1000054005; pub const VkFormat_VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: VkFormat = 1000054006; pub const VkFormat_VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: VkFormat = 1000054007; pub const VkFormat_VK_FORMAT_G8B8G8R8_422_UNORM_KHR: VkFormat = 1000156000; pub const VkFormat_VK_FORMAT_B8G8R8G8_422_UNORM_KHR: VkFormat = 1000156001; pub const VkFormat_VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: VkFormat = 1000156002; pub const VkFormat_VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: VkFormat = 1000156003; pub const VkFormat_VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: VkFormat = 1000156004; pub const VkFormat_VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: VkFormat = 1000156005; pub const VkFormat_VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: VkFormat = 1000156006; pub const VkFormat_VK_FORMAT_R10X6_UNORM_PACK16_KHR: VkFormat = 1000156007; pub const VkFormat_VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: VkFormat = 1000156008; pub const VkFormat_VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: VkFormat = 1000156009; pub const VkFormat_VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: VkFormat = 1000156010; pub const VkFormat_VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: VkFormat = 1000156011; pub const VkFormat_VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = 1000156012; pub const VkFormat_VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = 1000156013; pub const VkFormat_VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = 1000156014; pub const VkFormat_VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = 1000156015; pub const VkFormat_VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = 1000156016; pub const VkFormat_VK_FORMAT_R12X4_UNORM_PACK16_KHR: VkFormat = 1000156017; pub const VkFormat_VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: VkFormat = 1000156018; pub const VkFormat_VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: VkFormat = 1000156019; pub const VkFormat_VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: VkFormat = 1000156020; pub const VkFormat_VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: VkFormat = 1000156021; pub const VkFormat_VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = 1000156022; pub const VkFormat_VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = 1000156023; pub const VkFormat_VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = 1000156024; pub const VkFormat_VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = 1000156025; pub const VkFormat_VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = 1000156026; pub const VkFormat_VK_FORMAT_G16B16G16R16_422_UNORM_KHR: VkFormat = 1000156027; pub const VkFormat_VK_FORMAT_B16G16R16G16_422_UNORM_KHR: VkFormat = 1000156028; pub const VkFormat_VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: VkFormat = 1000156029; pub const VkFormat_VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: VkFormat = 1000156030; pub const VkFormat_VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: VkFormat = 1000156031; pub const VkFormat_VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: VkFormat = 1000156032; pub const VkFormat_VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: VkFormat = 1000156033; pub const VkFormat_VK_FORMAT_BEGIN_RANGE: VkFormat = 0; pub const VkFormat_VK_FORMAT_END_RANGE: VkFormat = 184; pub const VkFormat_VK_FORMAT_RANGE_SIZE: VkFormat = 185; pub const VkFormat_VK_FORMAT_MAX_ENUM: VkFormat = 2147483647; pub type VkFormat = u32; pub const VkImageType_VK_IMAGE_TYPE_1D: VkImageType = 0; pub const VkImageType_VK_IMAGE_TYPE_2D: VkImageType = 1; pub const VkImageType_VK_IMAGE_TYPE_3D: VkImageType = 2; pub const VkImageType_VK_IMAGE_TYPE_BEGIN_RANGE: VkImageType = 0; pub const VkImageType_VK_IMAGE_TYPE_END_RANGE: VkImageType = 2; pub const VkImageType_VK_IMAGE_TYPE_RANGE_SIZE: VkImageType = 3; pub const VkImageType_VK_IMAGE_TYPE_MAX_ENUM: VkImageType = 2147483647; pub type VkImageType = u32; pub const VkImageTiling_VK_IMAGE_TILING_OPTIMAL: VkImageTiling = 0; pub const VkImageTiling_VK_IMAGE_TILING_LINEAR: VkImageTiling = 1; pub const VkImageTiling_VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT: VkImageTiling = 1000158000; pub const VkImageTiling_VK_IMAGE_TILING_BEGIN_RANGE: VkImageTiling = 0; pub const VkImageTiling_VK_IMAGE_TILING_END_RANGE: VkImageTiling = 1; pub const VkImageTiling_VK_IMAGE_TILING_RANGE_SIZE: VkImageTiling = 2; pub const VkImageTiling_VK_IMAGE_TILING_MAX_ENUM: VkImageTiling = 2147483647; pub type VkImageTiling = u32; pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_OTHER: VkPhysicalDeviceType = 0; pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: VkPhysicalDeviceType = 1; pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: VkPhysicalDeviceType = 2; pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: VkPhysicalDeviceType = 3; pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_CPU: VkPhysicalDeviceType = 4; pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE: VkPhysicalDeviceType = 0; pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_END_RANGE: VkPhysicalDeviceType = 4; pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE: VkPhysicalDeviceType = 5; pub const VkPhysicalDeviceType_VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM: VkPhysicalDeviceType = 2147483647; pub type VkPhysicalDeviceType = u32; pub const VkSharingMode_VK_SHARING_MODE_EXCLUSIVE: VkSharingMode = 0; pub const VkSharingMode_VK_SHARING_MODE_CONCURRENT: VkSharingMode = 1; pub const VkSharingMode_VK_SHARING_MODE_BEGIN_RANGE: VkSharingMode = 0; pub const VkSharingMode_VK_SHARING_MODE_END_RANGE: VkSharingMode = 1; pub const VkSharingMode_VK_SHARING_MODE_RANGE_SIZE: VkSharingMode = 2; pub const VkSharingMode_VK_SHARING_MODE_MAX_ENUM: VkSharingMode = 2147483647; pub type VkSharingMode = u32; pub const VkImageLayout_VK_IMAGE_LAYOUT_UNDEFINED: VkImageLayout = 0; pub const VkImageLayout_VK_IMAGE_LAYOUT_GENERAL: VkImageLayout = 1; pub const VkImageLayout_VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: VkImageLayout = 2; pub const VkImageLayout_VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 3; pub const VkImageLayout_VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 4; pub const VkImageLayout_VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: VkImageLayout = 5; pub const VkImageLayout_VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: VkImageLayout = 6; pub const VkImageLayout_VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: VkImageLayout = 7; pub const VkImageLayout_VK_IMAGE_LAYOUT_PREINITIALIZED: VkImageLayout = 8; pub const VkImageLayout_VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 1000117000; pub const VkImageLayout_VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 1000117001; pub const VkImageLayout_VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: VkImageLayout = 1000001002; pub const VkImageLayout_VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR: VkImageLayout = 1000111000; pub const VkImageLayout_VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV: VkImageLayout = 1000164003; pub const VkImageLayout_VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = 1000117000; pub const VkImageLayout_VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout = 1000117001; pub const VkImageLayout_VK_IMAGE_LAYOUT_BEGIN_RANGE: VkImageLayout = 0; pub const VkImageLayout_VK_IMAGE_LAYOUT_END_RANGE: VkImageLayout = 8; pub const VkImageLayout_VK_IMAGE_LAYOUT_RANGE_SIZE: VkImageLayout = 9; pub const VkImageLayout_VK_IMAGE_LAYOUT_MAX_ENUM: VkImageLayout = 2147483647; pub type VkImageLayout = u32; pub type VkImageUsageFlags = VkFlags; pub type VkImageCreateFlags = VkFlags; pub const VkSampleCountFlagBits_VK_SAMPLE_COUNT_1_BIT: VkSampleCountFlagBits = 1; pub const VkSampleCountFlagBits_VK_SAMPLE_COUNT_2_BIT: VkSampleCountFlagBits = 2; pub const VkSampleCountFlagBits_VK_SAMPLE_COUNT_4_BIT: VkSampleCountFlagBits = 4; pub const VkSampleCountFlagBits_VK_SAMPLE_COUNT_8_BIT: VkSampleCountFlagBits = 8; pub const VkSampleCountFlagBits_VK_SAMPLE_COUNT_16_BIT: VkSampleCountFlagBits = 16; pub const VkSampleCountFlagBits_VK_SAMPLE_COUNT_32_BIT: VkSampleCountFlagBits = 32; pub const VkSampleCountFlagBits_VK_SAMPLE_COUNT_64_BIT: VkSampleCountFlagBits = 64; pub const VkSampleCountFlagBits_VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM: VkSampleCountFlagBits = 2147483647; pub type VkSampleCountFlagBits = u32; pub type VkSampleCountFlags = VkFlags; pub type VkMemoryPropertyFlags = VkFlags; pub type VkMemoryHeapFlags = VkFlags; pub type VkMemoryMapFlags = VkFlags; pub type VkBufferCreateFlags = VkFlags; pub type VkBufferUsageFlags = VkFlags; pub type PFN_vkAllocationFunction = ::std::option::Option< unsafe extern "C" fn( pUserData: *mut ::std::os::raw::c_void, size: usize, alignment: usize, allocationScope: VkSystemAllocationScope, ) -> *mut ::std::os::raw::c_void, >; pub type PFN_vkReallocationFunction = ::std::option::Option< unsafe extern "C" fn( pUserData: *mut ::std::os::raw::c_void, pOriginal: *mut ::std::os::raw::c_void, size: usize, alignment: usize, allocationScope: VkSystemAllocationScope, ) -> *mut ::std::os::raw::c_void, >; pub type PFN_vkFreeFunction = ::std::option::Option< unsafe extern "C" fn( pUserData: *mut ::std::os::raw::c_void, pMemory: *mut ::std::os::raw::c_void, ), >; pub type PFN_vkInternalAllocationNotification = ::std::option::Option< unsafe extern "C" fn( pUserData: *mut ::std::os::raw::c_void, size: usize, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope, ), >; pub type PFN_vkInternalFreeNotification = ::std::option::Option< unsafe extern "C" fn( pUserData: *mut ::std::os::raw::c_void, size: usize, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope, ), >; #[repr(C)] #[derive(Debug, Copy, Clone)] 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, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkExtent3D { pub width: u32, pub height: u32, pub depth: u32, } #[repr(C)] #[derive(Debug, Copy, Clone)] 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, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkPhysicalDeviceSparseProperties { pub residencyStandard2DBlockShape: VkBool32, pub residencyStandard2DMultisampleBlockShape: VkBool32, pub residencyStandard3DBlockShape: VkBool32, pub residencyAlignedMipSize: VkBool32, pub residencyNonResidentStrict: VkBool32, } #[repr(C)] #[derive(Copy, Clone)] 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, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkMemoryType { pub propertyFlags: VkMemoryPropertyFlags, pub heapIndex: u32, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkMemoryHeap { pub size: VkDeviceSize, pub flags: VkMemoryHeapFlags, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkPhysicalDeviceMemoryProperties { pub memoryTypeCount: u32, pub memoryTypes: [VkMemoryType; 32usize], pub memoryHeapCount: u32, pub memoryHeaps: [VkMemoryHeap; 16usize], } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkMemoryAllocateInfo { pub sType: VkStructureType, pub pNext: *const ::std::os::raw::c_void, pub allocationSize: VkDeviceSize, pub memoryTypeIndex: u32, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkMappedMemoryRange { pub sType: VkStructureType, pub pNext: *const ::std::os::raw::c_void, pub memory: VkDeviceMemory, pub offset: VkDeviceSize, pub size: VkDeviceSize, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkMemoryRequirements { pub size: VkDeviceSize, pub alignment: VkDeviceSize, pub memoryTypeBits: u32, } #[repr(C)] #[derive(Debug, Copy, Clone)] 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, } #[repr(C)] #[derive(Debug, Copy, Clone)] 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, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkBufferCopy { pub srcOffset: VkDeviceSize, pub dstOffset: VkDeviceSize, pub size: VkDeviceSize, } pub type PFN_vkGetPhysicalDeviceProperties = ::std::option::Option< unsafe extern "C" fn( physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties, ), >; pub type PFN_vkGetPhysicalDeviceMemoryProperties = ::std::option::Option< unsafe extern "C" fn( physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties, ), >; pub type PFN_vkAllocateMemory = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory, ) -> VkResult, >; pub type PFN_vkFreeMemory = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks, ), >; pub type PFN_vkMapMemory = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut ::std::os::raw::c_void, ) -> VkResult, >; pub type PFN_vkUnmapMemory = ::std::option::Option; pub type PFN_vkFlushMappedMemoryRanges = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange, ) -> VkResult, >; pub type PFN_vkInvalidateMappedMemoryRanges = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange, ) -> VkResult, >; pub type PFN_vkBindBufferMemory = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize, ) -> VkResult, >; pub type PFN_vkBindImageMemory = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize, ) -> VkResult, >; pub type PFN_vkGetBufferMemoryRequirements = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements, ), >; pub type PFN_vkGetImageMemoryRequirements = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements, ), >; pub type PFN_vkCreateBuffer = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer, ) -> VkResult, >; pub type PFN_vkDestroyBuffer = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks, ), >; pub type PFN_vkCreateImage = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage, ) -> VkResult, >; pub type PFN_vkDestroyImage = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks, ), >; pub type PFN_vkCmdCopyBuffer = ::std::option::Option< unsafe extern "C" fn( commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferCopy, ), >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkBindBufferMemoryInfo { pub sType: VkStructureType, pub pNext: *const ::std::os::raw::c_void, pub buffer: VkBuffer, pub memory: VkDeviceMemory, pub memoryOffset: VkDeviceSize, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkBindImageMemoryInfo { pub sType: VkStructureType, pub pNext: *const ::std::os::raw::c_void, pub image: VkImage, pub memory: VkDeviceMemory, pub memoryOffset: VkDeviceSize, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkBufferMemoryRequirementsInfo2 { pub sType: VkStructureType, pub pNext: *const ::std::os::raw::c_void, pub buffer: VkBuffer, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkImageMemoryRequirementsInfo2 { pub sType: VkStructureType, pub pNext: *const ::std::os::raw::c_void, pub image: VkImage, } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VkMemoryRequirements2 { pub sType: VkStructureType, pub pNext: *mut ::std::os::raw::c_void, pub memoryRequirements: VkMemoryRequirements, } pub type PFN_vkGetImageMemoryRequirements2KHR = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2, ), >; pub type PFN_vkGetBufferMemoryRequirements2KHR = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2, ), >; pub type PFN_vkBindBufferMemory2KHR = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo, ) -> VkResult, >; pub type PFN_vkBindImageMemory2KHR = ::std::option::Option< unsafe extern "C" fn( device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo, ) -> VkResult, >; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaAllocator_T { _unused: [u8; 0], } pub type VmaAllocator = *mut VmaAllocator_T; #[doc = " Callback function called after successful vkAllocateMemory."] pub type PFN_vmaAllocateDeviceMemoryFunction = ::std::option::Option< unsafe extern "C" fn( allocator: VmaAllocator, memoryType: u32, memory: VkDeviceMemory, size: VkDeviceSize, ), >; #[doc = " Callback function called before vkFreeMemory."] pub type PFN_vmaFreeDeviceMemoryFunction = ::std::option::Option< unsafe extern "C" fn( allocator: VmaAllocator, memoryType: u32, memory: VkDeviceMemory, size: VkDeviceSize, ), >; #[doc = " \\brief Set of callbacks that the library will call for `vkAllocateMemory` and `vkFreeMemory`."] #[doc = ""] #[doc = "Provided for informative purpose, e.g. to gather statistics about number of"] #[doc = "allocations or total amount of memory allocated in Vulkan."] #[doc = ""] #[doc = "Used in VmaAllocatorCreateInfo::pDeviceMemoryCallbacks."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaDeviceMemoryCallbacks { #[doc = " Optional, can be null."] pub pfnAllocate: PFN_vmaAllocateDeviceMemoryFunction, #[doc = " Optional, can be null."] pub pfnFree: PFN_vmaFreeDeviceMemoryFunction, } pub type VmaAllocatorCreateFlags = VkFlags; #[doc = " \\brief Pointers to some Vulkan functions - a subset used by the library."] #[doc = ""] #[doc = "Used in VmaAllocatorCreateInfo::pVulkanFunctions."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaVulkanFunctions { pub vkGetPhysicalDeviceProperties: PFN_vkGetPhysicalDeviceProperties, pub vkGetPhysicalDeviceMemoryProperties: PFN_vkGetPhysicalDeviceMemoryProperties, pub vkAllocateMemory: PFN_vkAllocateMemory, pub vkFreeMemory: PFN_vkFreeMemory, pub vkMapMemory: PFN_vkMapMemory, pub vkUnmapMemory: PFN_vkUnmapMemory, pub vkFlushMappedMemoryRanges: PFN_vkFlushMappedMemoryRanges, pub vkInvalidateMappedMemoryRanges: PFN_vkInvalidateMappedMemoryRanges, pub vkBindBufferMemory: PFN_vkBindBufferMemory, pub vkBindImageMemory: PFN_vkBindImageMemory, pub vkGetBufferMemoryRequirements: PFN_vkGetBufferMemoryRequirements, pub vkGetImageMemoryRequirements: PFN_vkGetImageMemoryRequirements, pub vkCreateBuffer: PFN_vkCreateBuffer, pub vkDestroyBuffer: PFN_vkDestroyBuffer, pub vkCreateImage: PFN_vkCreateImage, pub vkDestroyImage: PFN_vkDestroyImage, pub vkCmdCopyBuffer: PFN_vkCmdCopyBuffer, pub vkGetBufferMemoryRequirements2KHR: PFN_vkGetBufferMemoryRequirements2KHR, pub vkGetImageMemoryRequirements2KHR: PFN_vkGetImageMemoryRequirements2KHR, pub vkBindBufferMemory2KHR: PFN_vkBindBufferMemory2KHR, pub vkBindImageMemory2KHR: PFN_vkBindImageMemory2KHR, } pub type VmaRecordFlags = VkFlags; #[doc = " Parameters for recording calls to VMA functions. To be used in VmaAllocatorCreateInfo::pRecordSettings."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaRecordSettings { #[doc = " Flags for recording. Use #VmaRecordFlagBits enum."] pub flags: VmaRecordFlags, #[doc = " \\brief Path to the file that should be written by the recording."] #[doc = ""] #[doc = "Suggested extension: \"csv\"."] #[doc = "If the file already exists, it will be overwritten."] #[doc = "It will be opened for the whole time #VmaAllocator object is alive."] #[doc = "If opening this file fails, creation of the whole allocator object fails."] pub pFilePath: *const ::std::os::raw::c_char, } #[doc = " Description of a Allocator to be created."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaAllocatorCreateInfo { #[doc = " Flags for created allocator. Use #VmaAllocatorCreateFlagBits enum."] pub flags: VmaAllocatorCreateFlags, #[doc = " Vulkan physical device."] #[doc = "** It must be valid throughout whole lifetime of created allocator. */"] pub physicalDevice: VkPhysicalDevice, #[doc = " Vulkan device."] #[doc = "** It must be valid throughout whole lifetime of created allocator. */"] pub device: VkDevice, #[doc = " Preferred size of a single `VkDeviceMemory` block to be allocated from large heaps > 1 GiB. Optional."] #[doc = "** Set to 0 to use default, which is currently 256 MiB. */"] pub preferredLargeHeapBlockSize: VkDeviceSize, #[doc = " Custom CPU memory allocation callbacks. Optional."] #[doc = "** Optional, can be null. When specified, will also be used for all CPU-side memory allocations. */"] pub pAllocationCallbacks: *const VkAllocationCallbacks, #[doc = " Informative callbacks for `vkAllocateMemory`, `vkFreeMemory`. Optional."] #[doc = "** Optional, can be null. */"] pub pDeviceMemoryCallbacks: *const VmaDeviceMemoryCallbacks, #[doc = " \\brief Maximum number of additional frames that are in use at the same time as current frame."] #[doc = ""] #[doc = "This value is used only when you make allocations with"] #[doc = "VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag. Such allocation cannot become"] #[doc = "lost if allocation.lastUseFrameIndex >= allocator.currentFrameIndex - frameInUseCount."] #[doc = ""] #[doc = "For example, if you double-buffer your command buffers, so resources used for"] #[doc = "rendering in previous frame may still be in use by the GPU at the moment you"] #[doc = "allocate resources needed for the current frame, set this value to 1."] #[doc = ""] #[doc = "If you want to allow any allocations other than used in the current frame to"] #[doc = "become lost, set this value to 0."] pub frameInUseCount: u32, #[doc = " \\brief Either null or a pointer to an array of limits on maximum number of bytes that can be allocated out of particular Vulkan memory heap."] #[doc = ""] #[doc = "If not NULL, it must be a pointer to an array of"] #[doc = "`VkPhysicalDeviceMemoryProperties::memoryHeapCount` elements, defining limit on"] #[doc = "maximum number of bytes that can be allocated out of particular Vulkan memory"] #[doc = "heap."] #[doc = ""] #[doc = "Any of the elements may be equal to `VK_WHOLE_SIZE`, which means no limit on that"] #[doc = "heap. This is also the default in case of `pHeapSizeLimit` = NULL."] #[doc = ""] #[doc = "If there is a limit defined for a heap:"] #[doc = ""] #[doc = "- If user tries to allocate more memory from that heap using this allocator,"] #[doc = "the allocation fails with `VK_ERROR_OUT_OF_DEVICE_MEMORY`."] #[doc = "- If the limit is smaller than heap size reported in `VkMemoryHeap::size`, the"] #[doc = "value of this limit will be reported instead when using vmaGetMemoryProperties()."] #[doc = ""] #[doc = "Warning! Using this feature may not be equivalent to installing a GPU with"] #[doc = "smaller amount of memory, because graphics driver doesn't necessary fail new"] #[doc = "allocations with `VK_ERROR_OUT_OF_DEVICE_MEMORY` result when memory capacity is"] #[doc = "exceeded. It may return success and just silently migrate some device memory"] #[doc = "blocks to system RAM. This driver behavior can also be controlled using"] #[doc = "VK_AMD_memory_overallocation_behavior extension."] pub pHeapSizeLimit: *const VkDeviceSize, #[doc = " \\brief Pointers to Vulkan functions. Can be null if you leave define `VMA_STATIC_VULKAN_FUNCTIONS 1`."] #[doc = ""] #[doc = "If you leave define `VMA_STATIC_VULKAN_FUNCTIONS 1` in configuration section,"] #[doc = "you can pass null as this member, because the library will fetch pointers to"] #[doc = "Vulkan functions internally in a static way, like:"] #[doc = ""] #[doc = "vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;"] #[doc = ""] #[doc = "Fill this member if you want to provide your own pointers to Vulkan functions,"] #[doc = "e.g. fetched using `vkGetInstanceProcAddr()` and `vkGetDeviceProcAddr()`."] pub pVulkanFunctions: *const VmaVulkanFunctions, #[doc = " \\brief Parameters for recording of VMA calls. Can be null."] #[doc = ""] #[doc = "If not null, it enables recording of calls to VMA functions to a file."] #[doc = "If support for recording is not enabled using `VMA_RECORDING_ENABLED` macro,"] #[doc = "creation of the allocator object fails with `VK_ERROR_FEATURE_NOT_PRESENT`."] pub pRecordSettings: *const VmaRecordSettings, } extern "C" { #[doc = " Creates Allocator object."] pub fn vmaCreateAllocator( pCreateInfo: *const VmaAllocatorCreateInfo, pAllocator: *mut VmaAllocator, ) -> VkResult; } extern "C" { #[doc = " Destroys allocator object."] pub fn vmaDestroyAllocator(allocator: VmaAllocator); } extern "C" { #[doc = "PhysicalDeviceProperties are fetched from physicalDevice by the allocator."] #[doc = "You can access it here, without fetching it again on your own."] pub fn vmaGetPhysicalDeviceProperties( allocator: VmaAllocator, ppPhysicalDeviceProperties: *mut *const VkPhysicalDeviceProperties, ); } extern "C" { #[doc = "PhysicalDeviceMemoryProperties are fetched from physicalDevice by the allocator."] #[doc = "You can access it here, without fetching it again on your own."] pub fn vmaGetMemoryProperties( allocator: VmaAllocator, ppPhysicalDeviceMemoryProperties: *mut *const VkPhysicalDeviceMemoryProperties, ); } extern "C" { #[doc = "\\brief Given Memory Type Index, returns Property Flags of this memory type."] #[doc = ""] #[doc = "This is just a convenience function. Same information can be obtained using"] #[doc = "vmaGetMemoryProperties()."] pub fn vmaGetMemoryTypeProperties( allocator: VmaAllocator, memoryTypeIndex: u32, pFlags: *mut VkMemoryPropertyFlags, ); } extern "C" { #[doc = " \\brief Sets index of the current frame."] #[doc = ""] #[doc = "This function must be used if you make allocations with"] #[doc = "#VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT and"] #[doc = "#VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flags to inform the allocator"] #[doc = "when a new frame begins. Allocations queried using vmaGetAllocationInfo() cannot"] #[doc = "become lost in the current frame."] pub fn vmaSetCurrentFrameIndex(allocator: VmaAllocator, frameIndex: u32); } #[doc = " \\brief Calculated statistics of memory usage in entire allocator."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaStatInfo { #[doc = " Number of `VkDeviceMemory` Vulkan memory blocks allocated."] pub blockCount: u32, #[doc = " Number of #VmaAllocation allocation objects allocated."] pub allocationCount: u32, #[doc = " Number of free ranges of memory between allocations."] pub unusedRangeCount: u32, #[doc = " Total number of bytes occupied by all allocations."] pub usedBytes: VkDeviceSize, #[doc = " Total number of bytes occupied by unused ranges."] pub unusedBytes: VkDeviceSize, pub allocationSizeMin: VkDeviceSize, pub allocationSizeAvg: VkDeviceSize, pub allocationSizeMax: VkDeviceSize, pub unusedRangeSizeMin: VkDeviceSize, pub unusedRangeSizeAvg: VkDeviceSize, pub unusedRangeSizeMax: VkDeviceSize, } #[doc = " General statistics from current state of Allocator."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaStats { pub memoryType: [VmaStatInfo; 32usize], pub memoryHeap: [VmaStatInfo; 16usize], pub total: VmaStatInfo, } extern "C" { #[doc = " Retrieves statistics from current state of the Allocator."] pub fn vmaCalculateStats(allocator: VmaAllocator, pStats: *mut VmaStats); } extern "C" { #[doc = " Builds and returns statistics as string in JSON format."] #[doc = "** @param[out] ppStatsString Must be freed using vmaFreeStatsString() function."] #[doc = "*/"] pub fn vmaBuildStatsString( allocator: VmaAllocator, ppStatsString: *mut *mut ::std::os::raw::c_char, detailedMap: VkBool32, ); } extern "C" { pub fn vmaFreeStatsString(allocator: VmaAllocator, pStatsString: *mut ::std::os::raw::c_char); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaPool_T { _unused: [u8; 0], } pub type VmaPool = *mut VmaPool_T; #[doc = " No intended memory usage specified."] #[doc = "Use other members of VmaAllocationCreateInfo to specify your requirements."] pub const VmaMemoryUsage_VMA_MEMORY_USAGE_UNKNOWN: VmaMemoryUsage = 0; #[doc = " Memory will be used on device only, so fast access from the device is preferred."] #[doc = "It usually means device-local GPU (video) memory."] #[doc = "No need to be mappable on host."] #[doc = "It is roughly equivalent of `D3D12_HEAP_TYPE_DEFAULT`."] #[doc = ""] #[doc = "Usage:"] #[doc = ""] #[doc = "- Resources written and read by device, e.g. images used as attachments."] #[doc = "- Resources transferred from host once (immutable) or infrequently and read by"] #[doc = "device multiple times, e.g. textures to be sampled, vertex buffers, uniform"] #[doc = "(constant) buffers, and majority of other types of resources used on GPU."] #[doc = ""] #[doc = "Allocation may still end up in `HOST_VISIBLE` memory on some implementations."] #[doc = "In such case, you are free to map it."] #[doc = "You can use #VMA_ALLOCATION_CREATE_MAPPED_BIT with this usage type."] pub const VmaMemoryUsage_VMA_MEMORY_USAGE_GPU_ONLY: VmaMemoryUsage = 1; #[doc = " Memory will be mappable on host."] #[doc = "It usually means CPU (system) memory."] #[doc = "Guarantees to be `HOST_VISIBLE` and `HOST_COHERENT`."] #[doc = "CPU access is typically uncached. Writes may be write-combined."] #[doc = "Resources created in this pool may still be accessible to the device, but access to them can be slow."] #[doc = "It is roughly equivalent of `D3D12_HEAP_TYPE_UPLOAD`."] #[doc = ""] #[doc = "Usage: Staging copy of resources used as transfer source."] pub const VmaMemoryUsage_VMA_MEMORY_USAGE_CPU_ONLY: VmaMemoryUsage = 2; #[doc = "Memory that is both mappable on host (guarantees to be `HOST_VISIBLE`) and preferably fast to access by GPU."] #[doc = "CPU access is typically uncached. Writes may be write-combined."] #[doc = ""] #[doc = "Usage: Resources written frequently by host (dynamic), read by device. E.g. textures, vertex buffers, uniform buffers updated every frame or every draw call."] pub const VmaMemoryUsage_VMA_MEMORY_USAGE_CPU_TO_GPU: VmaMemoryUsage = 3; #[doc = " Memory mappable on host (guarantees to be `HOST_VISIBLE`) and cached."] #[doc = "It is roughly equivalent of `D3D12_HEAP_TYPE_READBACK`."] #[doc = ""] #[doc = "Usage:"] #[doc = ""] #[doc = "- Resources written by device, read by host - results of some computations, e.g. screen capture, average scene luminance for HDR tone mapping."] #[doc = "- Any resources read or accessed randomly on host, e.g. CPU-side copy of vertex buffer used as source of transfer, but also used for collision detection."] pub const VmaMemoryUsage_VMA_MEMORY_USAGE_GPU_TO_CPU: VmaMemoryUsage = 4; #[doc = " Memory mappable on host (guarantees to be `HOST_VISIBLE`) and cached."] #[doc = "It is roughly equivalent of `D3D12_HEAP_TYPE_READBACK`."] #[doc = ""] #[doc = "Usage:"] #[doc = ""] #[doc = "- Resources written by device, read by host - results of some computations, e.g. screen capture, average scene luminance for HDR tone mapping."] #[doc = "- Any resources read or accessed randomly on host, e.g. CPU-side copy of vertex buffer used as source of transfer, but also used for collision detection."] pub const VmaMemoryUsage_VMA_MEMORY_USAGE_MAX_ENUM: VmaMemoryUsage = 2147483647; #[doc = " \\struct VmaPool"] #[doc = "\\brief Represents custom memory pool"] #[doc = ""] #[doc = "Fill structure VmaPoolCreateInfo and call function vmaCreatePool() to create it."] #[doc = "Call function vmaDestroyPool() to destroy it."] #[doc = ""] #[doc = "For more information see [Custom memory pools](@ref choosing_memory_type_custom_memory_pools)."] pub type VmaMemoryUsage = u32; pub type VmaAllocationCreateFlags = VkFlags; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaAllocationCreateInfo { #[doc = " Use #VmaAllocationCreateFlagBits enum."] pub flags: VmaAllocationCreateFlags, #[doc = " \\brief Intended usage of memory."] #[doc = ""] #[doc = "You can leave #VMA_MEMORY_USAGE_UNKNOWN if you specify memory requirements in other way. \\n"] #[doc = "If `pool` is not null, this member is ignored."] pub usage: VmaMemoryUsage, #[doc = " \\brief Flags that must be set in a Memory Type chosen for an allocation."] #[doc = ""] #[doc = "Leave 0 if you specify memory requirements in other way. \\n"] #[doc = "If `pool` is not null, this member is ignored."] pub requiredFlags: VkMemoryPropertyFlags, #[doc = " \\brief Flags that preferably should be set in a memory type chosen for an allocation."] #[doc = ""] #[doc = "Set to 0 if no additional flags are prefered. \\n"] #[doc = "If `pool` is not null, this member is ignored."] pub preferredFlags: VkMemoryPropertyFlags, #[doc = " \\brief Bitmask containing one bit set for every memory type acceptable for this allocation."] #[doc = ""] #[doc = "Value 0 is equivalent to `UINT32_MAX` - it means any memory type is accepted if"] #[doc = "it meets other requirements specified by this structure, with no further"] #[doc = "restrictions on memory type index. \\n"] #[doc = "If `pool` is not null, this member is ignored."] pub memoryTypeBits: u32, #[doc = " \\brief Pool that this allocation should be created in."] #[doc = ""] #[doc = "Leave `VK_NULL_HANDLE` to allocate from default pool. If not null, members:"] #[doc = "`usage`, `requiredFlags`, `preferredFlags`, `memoryTypeBits` are ignored."] pub pool: VmaPool, #[doc = " \\brief Custom general-purpose pointer that will be stored in #VmaAllocation, can be read as VmaAllocationInfo::pUserData and changed using vmaSetAllocationUserData()."] #[doc = ""] #[doc = "If #VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT is used, it must be either"] #[doc = "null or pointer to a null-terminated string. The string will be then copied to"] #[doc = "internal buffer, so it doesn't need to be valid after allocation call."] pub pUserData: *mut ::std::os::raw::c_void, } extern "C" { #[doc = "\\brief Helps to find memoryTypeIndex, given memoryTypeBits and VmaAllocationCreateInfo."] #[doc = ""] #[doc = "This algorithm tries to find a memory type that:"] #[doc = ""] #[doc = "- Is allowed by memoryTypeBits."] #[doc = "- Contains all the flags from pAllocationCreateInfo->requiredFlags."] #[doc = "- Matches intended usage."] #[doc = "- Has as many flags from pAllocationCreateInfo->preferredFlags as possible."] #[doc = ""] #[doc = "\\return Returns VK_ERROR_FEATURE_NOT_PRESENT if not found. Receiving such result"] #[doc = "from this function or any other allocating function probably means that your"] #[doc = "device doesn't support any memory type with requested features for the specific"] #[doc = "type of resource you want to use it for. Please check parameters of your"] #[doc = "resource, like image layout (OPTIMAL versus LINEAR) or mip level count."] pub fn vmaFindMemoryTypeIndex( allocator: VmaAllocator, memoryTypeBits: u32, pAllocationCreateInfo: *const VmaAllocationCreateInfo, pMemoryTypeIndex: *mut u32, ) -> VkResult; } extern "C" { #[doc = "\\brief Helps to find memoryTypeIndex, given VkBufferCreateInfo and VmaAllocationCreateInfo."] #[doc = ""] #[doc = "It can be useful e.g. to determine value to be used as VmaPoolCreateInfo::memoryTypeIndex."] #[doc = "It internally creates a temporary, dummy buffer that never has memory bound."] #[doc = "It is just a convenience function, equivalent to calling:"] #[doc = ""] #[doc = "- `vkCreateBuffer`"] #[doc = "- `vkGetBufferMemoryRequirements`"] #[doc = "- `vmaFindMemoryTypeIndex`"] #[doc = "- `vkDestroyBuffer`"] pub fn vmaFindMemoryTypeIndexForBufferInfo( allocator: VmaAllocator, pBufferCreateInfo: *const VkBufferCreateInfo, pAllocationCreateInfo: *const VmaAllocationCreateInfo, pMemoryTypeIndex: *mut u32, ) -> VkResult; } extern "C" { #[doc = "\\brief Helps to find memoryTypeIndex, given VkImageCreateInfo and VmaAllocationCreateInfo."] #[doc = ""] #[doc = "It can be useful e.g. to determine value to be used as VmaPoolCreateInfo::memoryTypeIndex."] #[doc = "It internally creates a temporary, dummy image that never has memory bound."] #[doc = "It is just a convenience function, equivalent to calling:"] #[doc = ""] #[doc = "- `vkCreateImage`"] #[doc = "- `vkGetImageMemoryRequirements`"] #[doc = "- `vmaFindMemoryTypeIndex`"] #[doc = "- `vkDestroyImage`"] pub fn vmaFindMemoryTypeIndexForImageInfo( allocator: VmaAllocator, pImageCreateInfo: *const VkImageCreateInfo, pAllocationCreateInfo: *const VmaAllocationCreateInfo, pMemoryTypeIndex: *mut u32, ) -> VkResult; } pub type VmaPoolCreateFlags = VkFlags; #[doc = " \\brief Describes parameter of created #VmaPool."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaPoolCreateInfo { #[doc = " \\brief Vulkan memory type index to allocate this pool from."] pub memoryTypeIndex: u32, #[doc = " \\brief Use combination of #VmaPoolCreateFlagBits."] pub flags: VmaPoolCreateFlags, #[doc = " \\brief Size of a single `VkDeviceMemory` block to be allocated as part of this pool, in bytes. Optional."] #[doc = ""] #[doc = "Specify nonzero to set explicit, constant size of memory blocks used by this"] #[doc = "pool."] #[doc = ""] #[doc = "Leave 0 to use default and let the library manage block sizes automatically."] #[doc = "Sizes of particular blocks may vary."] pub blockSize: VkDeviceSize, #[doc = " \\brief Minimum number of blocks to be always allocated in this pool, even if they stay empty."] #[doc = ""] #[doc = "Set to 0 to have no preallocated blocks and allow the pool be completely empty."] pub minBlockCount: usize, #[doc = " \\brief Maximum number of blocks that can be allocated in this pool. Optional."] #[doc = ""] #[doc = "Set to 0 to use default, which is `SIZE_MAX`, which means no limit."] #[doc = ""] #[doc = "Set to same value as VmaPoolCreateInfo::minBlockCount to have fixed amount of memory allocated"] #[doc = "throughout whole lifetime of this pool."] pub maxBlockCount: usize, #[doc = " \\brief Maximum number of additional frames that are in use at the same time as current frame."] #[doc = ""] #[doc = "This value is used only when you make allocations with"] #[doc = "#VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag. Such allocation cannot become"] #[doc = "lost if allocation.lastUseFrameIndex >= allocator.currentFrameIndex - frameInUseCount."] #[doc = ""] #[doc = "For example, if you double-buffer your command buffers, so resources used for"] #[doc = "rendering in previous frame may still be in use by the GPU at the moment you"] #[doc = "allocate resources needed for the current frame, set this value to 1."] #[doc = ""] #[doc = "If you want to allow any allocations other than used in the current frame to"] #[doc = "become lost, set this value to 0."] pub frameInUseCount: u32, } #[doc = " \\brief Describes parameter of existing #VmaPool."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaPoolStats { #[doc = " \\brief Total amount of `VkDeviceMemory` allocated from Vulkan for this pool, in bytes."] pub size: VkDeviceSize, #[doc = " \\brief Total number of bytes in the pool not used by any #VmaAllocation."] pub unusedSize: VkDeviceSize, #[doc = " \\brief Number of #VmaAllocation objects created from this pool that were not destroyed or lost."] pub allocationCount: usize, #[doc = " \\brief Number of continuous memory ranges in the pool not used by any #VmaAllocation."] pub unusedRangeCount: usize, #[doc = " \\brief Size of the largest continuous free memory region available for new allocation."] #[doc = ""] #[doc = "Making a new allocation of that size is not guaranteed to succeed because of"] #[doc = "possible additional margin required to respect alignment and buffer/image"] #[doc = "granularity."] pub unusedRangeSizeMax: VkDeviceSize, #[doc = " \\brief Number of `VkDeviceMemory` blocks allocated for this pool."] pub blockCount: usize, } extern "C" { #[doc = " \\brief Allocates Vulkan device memory and creates #VmaPool object."] #[doc = ""] #[doc = "@param allocator Allocator object."] #[doc = "@param pCreateInfo Parameters of pool to create."] #[doc = "@param[out] pPool Handle to created pool."] pub fn vmaCreatePool( allocator: VmaAllocator, pCreateInfo: *const VmaPoolCreateInfo, pPool: *mut VmaPool, ) -> VkResult; } extern "C" { #[doc = " \\brief Destroys #VmaPool object and frees Vulkan device memory."] pub fn vmaDestroyPool(allocator: VmaAllocator, pool: VmaPool); } extern "C" { #[doc = " \\brief Retrieves statistics of existing #VmaPool object."] #[doc = ""] #[doc = "@param allocator Allocator object."] #[doc = "@param pool Pool object."] #[doc = "@param[out] pPoolStats Statistics of specified pool."] pub fn vmaGetPoolStats(allocator: VmaAllocator, pool: VmaPool, pPoolStats: *mut VmaPoolStats); } extern "C" { #[doc = " \\brief Marks all allocations in given pool as lost if they are not used in current frame or VmaPoolCreateInfo::frameInUseCount back from now."] #[doc = ""] #[doc = "@param allocator Allocator object."] #[doc = "@param pool Pool."] #[doc = "@param[out] pLostAllocationCount Number of allocations marked as lost. Optional - pass null if you don't need this information."] pub fn vmaMakePoolAllocationsLost( allocator: VmaAllocator, pool: VmaPool, pLostAllocationCount: *mut usize, ); } extern "C" { #[doc = " \\brief Checks magic number in margins around all allocations in given memory pool in search for corruptions."] #[doc = ""] #[doc = "Corruption detection is enabled only when `VMA_DEBUG_DETECT_CORRUPTION` macro is defined to nonzero,"] #[doc = "`VMA_DEBUG_MARGIN` is defined to nonzero and the pool is created in memory type that is"] #[doc = "`HOST_VISIBLE` and `HOST_COHERENT`. For more information, see [Corruption detection](@ref debugging_memory_usage_corruption_detection)."] #[doc = ""] #[doc = "Possible return values:"] #[doc = ""] #[doc = "- `VK_ERROR_FEATURE_NOT_PRESENT` - corruption detection is not enabled for specified pool."] #[doc = "- `VK_SUCCESS` - corruption detection has been performed and succeeded."] #[doc = "- `VK_ERROR_VALIDATION_FAILED_EXT` - corruption detection has been performed and found memory corruptions around one of the allocations."] #[doc = "`VMA_ASSERT` is also fired in that case."] #[doc = "- Other value: Error returned by Vulkan, e.g. memory mapping failure."] pub fn vmaCheckPoolCorruption(allocator: VmaAllocator, pool: VmaPool) -> VkResult; } extern "C" { #[doc = " TODO"] pub fn vmaGetPoolName( allocator: VmaAllocator, pool: VmaPool, ppName: *mut *const ::std::os::raw::c_char, ); } extern "C" { pub fn vmaSetPoolName( allocator: VmaAllocator, pool: VmaPool, pName: *const ::std::os::raw::c_char, ); } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaAllocation_T { _unused: [u8; 0], } pub type VmaAllocation = *mut VmaAllocation_T; #[doc = " \\brief Parameters of #VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo()."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaAllocationInfo { #[doc = " \\brief Memory type index that this allocation was allocated from."] #[doc = ""] #[doc = "It never changes."] pub memoryType: u32, #[doc = " \\brief Handle to Vulkan memory object."] #[doc = ""] #[doc = "Same memory object can be shared by multiple allocations."] #[doc = ""] #[doc = "It can change after call to vmaDefragment() if this allocation is passed to the function, or if allocation is lost."] #[doc = ""] #[doc = "If the allocation is lost, it is equal to `VK_NULL_HANDLE`."] pub deviceMemory: VkDeviceMemory, #[doc = " \\brief Offset into deviceMemory object to the beginning of this allocation, in bytes. (deviceMemory, offset) pair is unique to this allocation."] #[doc = ""] #[doc = "It can change after call to vmaDefragment() if this allocation is passed to the function, or if allocation is lost."] pub offset: VkDeviceSize, #[doc = " \\brief Size of this allocation, in bytes."] #[doc = ""] #[doc = "It never changes, unless allocation is lost."] pub size: VkDeviceSize, #[doc = " \\brief Pointer to the beginning of this allocation as mapped data."] #[doc = ""] #[doc = "If the allocation hasn't been mapped using vmaMapMemory() and hasn't been"] #[doc = "created with #VMA_ALLOCATION_CREATE_MAPPED_BIT flag, this value null."] #[doc = ""] #[doc = "It can change after call to vmaMapMemory(), vmaUnmapMemory()."] #[doc = "It can also change after call to vmaDefragment() if this allocation is passed to the function."] pub pMappedData: *mut ::std::os::raw::c_void, #[doc = " \\brief Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vmaSetAllocationUserData()."] #[doc = ""] #[doc = "It can change after call to vmaSetAllocationUserData() for this allocation."] pub pUserData: *mut ::std::os::raw::c_void, } extern "C" { #[doc = " \\brief General purpose memory allocation."] #[doc = ""] #[doc = "@param[out] pAllocation Handle to allocated memory."] #[doc = "@param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo()."] #[doc = ""] #[doc = "You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages()."] #[doc = ""] #[doc = "It is recommended to use vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage(),"] #[doc = "vmaCreateBuffer(), vmaCreateImage() instead whenever possible."] pub fn vmaAllocateMemory( allocator: VmaAllocator, pVkMemoryRequirements: *const VkMemoryRequirements, pCreateInfo: *const VmaAllocationCreateInfo, pAllocation: *mut VmaAllocation, pAllocationInfo: *mut VmaAllocationInfo, ) -> VkResult; } extern "C" { #[doc = " \\brief General purpose memory allocation for multiple allocation objects at once."] #[doc = ""] #[doc = "@param allocator Allocator object."] #[doc = "@param pVkMemoryRequirements Memory requirements for each allocation."] #[doc = "@param pCreateInfo Creation parameters for each alloction."] #[doc = "@param allocationCount Number of allocations to make."] #[doc = "@param[out] pAllocations Pointer to array that will be filled with handles to created allocations."] #[doc = "@param[out] pAllocationInfo Optional. Pointer to array that will be filled with parameters of created allocations."] #[doc = ""] #[doc = "You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages()."] #[doc = ""] #[doc = "Word \"pages\" is just a suggestion to use this function to allocate pieces of memory needed for sparse binding."] #[doc = "It is just a general purpose allocation function able to make multiple allocations at once."] #[doc = "It may be internally optimized to be more efficient than calling vmaAllocateMemory() `allocationCount` times."] #[doc = ""] #[doc = "All allocations are made using same parameters. All of them are created out of the same memory pool and type."] #[doc = "If any allocation fails, all allocations already made within this function call are also freed, so that when"] #[doc = "returned result is not `VK_SUCCESS`, `pAllocation` array is always entirely filled with `VK_NULL_HANDLE`."] pub fn vmaAllocateMemoryPages( allocator: VmaAllocator, pVkMemoryRequirements: *const VkMemoryRequirements, pCreateInfo: *const VmaAllocationCreateInfo, allocationCount: usize, pAllocations: *mut VmaAllocation, pAllocationInfo: *mut VmaAllocationInfo, ) -> VkResult; } extern "C" { #[doc = "@param[out] pAllocation Handle to allocated memory."] #[doc = "@param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo()."] #[doc = ""] #[doc = "You should free the memory using vmaFreeMemory()."] pub fn vmaAllocateMemoryForBuffer( allocator: VmaAllocator, buffer: VkBuffer, pCreateInfo: *const VmaAllocationCreateInfo, pAllocation: *mut VmaAllocation, pAllocationInfo: *mut VmaAllocationInfo, ) -> VkResult; } extern "C" { #[doc = " Function similar to vmaAllocateMemoryForBuffer()."] pub fn vmaAllocateMemoryForImage( allocator: VmaAllocator, image: VkImage, pCreateInfo: *const VmaAllocationCreateInfo, pAllocation: *mut VmaAllocation, pAllocationInfo: *mut VmaAllocationInfo, ) -> VkResult; } extern "C" { #[doc = " \\brief Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(), or vmaAllocateMemoryForImage()."] #[doc = ""] #[doc = "Passing `VK_NULL_HANDLE` as `allocation` is valid. Such function call is just skipped."] pub fn vmaFreeMemory(allocator: VmaAllocator, allocation: VmaAllocation); } extern "C" { #[doc = " \\brief Frees memory and destroys multiple allocations."] #[doc = ""] #[doc = "Word \"pages\" is just a suggestion to use this function to free pieces of memory used for sparse binding."] #[doc = "It is just a general purpose function to free memory and destroy allocations made using e.g. vmaAllocateMemory(),"] #[doc = "vmaAllocateMemoryPages() and other functions."] #[doc = "It may be internally optimized to be more efficient than calling vmaFreeMemory() `allocationCount` times."] #[doc = ""] #[doc = "Allocations in `pAllocations` array can come from any memory pools and types."] #[doc = "Passing `VK_NULL_HANDLE` as elements of `pAllocations` array is valid. Such entries are just skipped."] pub fn vmaFreeMemoryPages( allocator: VmaAllocator, allocationCount: usize, pAllocations: *mut VmaAllocation, ); } extern "C" { #[doc = " \\brief Deprecated."] #[doc = ""] #[doc = "In version 2.2.0 it used to try to change allocation's size without moving or reallocating it."] #[doc = "In current version it returns `VK_SUCCESS` only if `newSize` equals current allocation's size."] #[doc = "Otherwise returns `VK_ERROR_OUT_OF_POOL_MEMORY`, indicating that allocation's size could not be changed."] pub fn vmaResizeAllocation( allocator: VmaAllocator, allocation: VmaAllocation, newSize: VkDeviceSize, ) -> VkResult; } extern "C" { #[doc = " \\brief Returns current information about specified allocation and atomically marks it as used in current frame."] #[doc = ""] #[doc = "Current paramters of given allocation are returned in `pAllocationInfo`."] #[doc = ""] #[doc = "This function also atomically \"touches\" allocation - marks it as used in current frame,"] #[doc = "just like vmaTouchAllocation()."] #[doc = "If the allocation is in lost state, `pAllocationInfo->deviceMemory == VK_NULL_HANDLE`."] #[doc = ""] #[doc = "Although this function uses atomics and doesn't lock any mutex, so it should be quite efficient,"] #[doc = "you can avoid calling it too often."] #[doc = ""] #[doc = "- You can retrieve same VmaAllocationInfo structure while creating your resource, from function"] #[doc = "vmaCreateBuffer(), vmaCreateImage(). You can remember it if you are sure parameters don't change"] #[doc = "(e.g. due to defragmentation or allocation becoming lost)."] #[doc = "- If you just want to check if allocation is not lost, vmaTouchAllocation() will work faster."] pub fn vmaGetAllocationInfo( allocator: VmaAllocator, allocation: VmaAllocation, pAllocationInfo: *mut VmaAllocationInfo, ); } extern "C" { #[doc = " \\brief Returns `VK_TRUE` if allocation is not lost and atomically marks it as used in current frame."] #[doc = ""] #[doc = "If the allocation has been created with #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag,"] #[doc = "this function returns `VK_TRUE` if it's not in lost state, so it can still be used."] #[doc = "It then also atomically \"touches\" the allocation - marks it as used in current frame,"] #[doc = "so that you can be sure it won't become lost in current frame or next `frameInUseCount` frames."] #[doc = ""] #[doc = "If the allocation is in lost state, the function returns `VK_FALSE`."] #[doc = "Memory of such allocation, as well as buffer or image bound to it, should not be used."] #[doc = "Lost allocation and the buffer/image still need to be destroyed."] #[doc = ""] #[doc = "If the allocation has been created without #VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag,"] #[doc = "this function always returns `VK_TRUE`."] pub fn vmaTouchAllocation(allocator: VmaAllocator, allocation: VmaAllocation) -> VkBool32; } extern "C" { #[doc = " \\brief Sets pUserData in given allocation to new value."] #[doc = ""] #[doc = "If the allocation was created with VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT,"] #[doc = "pUserData must be either null, or pointer to a null-terminated string. The function"] #[doc = "makes local copy of the string and sets it as allocation's `pUserData`. String"] #[doc = "passed as pUserData doesn't need to be valid for whole lifetime of the allocation -"] #[doc = "you can free it after this call. String previously pointed by allocation's"] #[doc = "pUserData is freed from memory."] #[doc = ""] #[doc = "If the flag was not used, the value of pointer `pUserData` is just copied to"] #[doc = "allocation's `pUserData`. It is opaque, so you can use it however you want - e.g."] #[doc = "as a pointer, ordinal number or some handle to you own data."] pub fn vmaSetAllocationUserData( allocator: VmaAllocator, allocation: VmaAllocation, pUserData: *mut ::std::os::raw::c_void, ); } extern "C" { #[doc = " \\brief Creates new allocation that is in lost state from the beginning."] #[doc = ""] #[doc = "It can be useful if you need a dummy, non-null allocation."] #[doc = ""] #[doc = "You still need to destroy created object using vmaFreeMemory()."] #[doc = ""] #[doc = "Returned allocation is not tied to any specific memory pool or memory type and"] #[doc = "not bound to any image or buffer. It has size = 0. It cannot be turned into"] #[doc = "a real, non-empty allocation."] pub fn vmaCreateLostAllocation(allocator: VmaAllocator, pAllocation: *mut VmaAllocation); } extern "C" { #[doc = " \\brief Maps memory represented by given allocation and returns pointer to it."] #[doc = ""] #[doc = "Maps memory represented by given allocation to make it accessible to CPU code."] #[doc = "When succeeded, `*ppData` contains pointer to first byte of this memory."] #[doc = "If the allocation is part of bigger `VkDeviceMemory` block, the pointer is"] #[doc = "correctly offseted to the beginning of region assigned to this particular"] #[doc = "allocation."] #[doc = ""] #[doc = "Mapping is internally reference-counted and synchronized, so despite raw Vulkan"] #[doc = "function `vkMapMemory()` cannot be used to map same block of `VkDeviceMemory`"] #[doc = "multiple times simultaneously, it is safe to call this function on allocations"] #[doc = "assigned to the same memory block. Actual Vulkan memory will be mapped on first"] #[doc = "mapping and unmapped on last unmapping."] #[doc = ""] #[doc = "If the function succeeded, you must call vmaUnmapMemory() to unmap the"] #[doc = "allocation when mapping is no longer needed or before freeing the allocation, at"] #[doc = "the latest."] #[doc = ""] #[doc = "It also safe to call this function multiple times on the same allocation. You"] #[doc = "must call vmaUnmapMemory() same number of times as you called vmaMapMemory()."] #[doc = ""] #[doc = "It is also safe to call this function on allocation created with"] #[doc = "#VMA_ALLOCATION_CREATE_MAPPED_BIT flag. Its memory stays mapped all the time."] #[doc = "You must still call vmaUnmapMemory() same number of times as you called"] #[doc = "vmaMapMemory(). You must not call vmaUnmapMemory() additional time to free the"] #[doc = "\"0-th\" mapping made automatically due to #VMA_ALLOCATION_CREATE_MAPPED_BIT flag."] #[doc = ""] #[doc = "This function fails when used on allocation made in memory type that is not"] #[doc = "`HOST_VISIBLE`."] #[doc = ""] #[doc = "This function always fails when called for allocation that was created with"] #[doc = "#VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag. Such allocations cannot be"] #[doc = "mapped."] pub fn vmaMapMemory( allocator: VmaAllocator, allocation: VmaAllocation, ppData: *mut *mut ::std::os::raw::c_void, ) -> VkResult; } extern "C" { #[doc = " \\brief Unmaps memory represented by given allocation, mapped previously using vmaMapMemory()."] #[doc = ""] #[doc = "For details, see description of vmaMapMemory()."] pub fn vmaUnmapMemory(allocator: VmaAllocator, allocation: VmaAllocation); } extern "C" { #[doc = " \\brief Flushes memory of given allocation."] #[doc = ""] #[doc = "Calls `vkFlushMappedMemoryRanges()` for memory associated with given range of given allocation."] #[doc = ""] #[doc = "- `offset` must be relative to the beginning of allocation."] #[doc = "- `size` can be `VK_WHOLE_SIZE`. It means all memory from `offset` the the end of given allocation."] #[doc = "- `offset` and `size` don't have to be aligned."] #[doc = "They are internally rounded down/up to multiply of `nonCoherentAtomSize`."] #[doc = "- If `size` is 0, this call is ignored."] #[doc = "- If memory type that the `allocation` belongs to is not `HOST_VISIBLE` or it is `HOST_COHERENT`,"] #[doc = "this call is ignored."] #[doc = ""] #[doc = "Warning! `offset` and `size` are relative to the contents of given `allocation`."] #[doc = "If you mean whole allocation, you can pass 0 and `VK_WHOLE_SIZE`, respectively."] #[doc = "Do not pass allocation's offset as `offset`!!!"] pub fn vmaFlushAllocation( allocator: VmaAllocator, allocation: VmaAllocation, offset: VkDeviceSize, size: VkDeviceSize, ); } extern "C" { #[doc = " \\brief Invalidates memory of given allocation."] #[doc = ""] #[doc = "Calls `vkInvalidateMappedMemoryRanges()` for memory associated with given range of given allocation."] #[doc = ""] #[doc = "- `offset` must be relative to the beginning of allocation."] #[doc = "- `size` can be `VK_WHOLE_SIZE`. It means all memory from `offset` the the end of given allocation."] #[doc = "- `offset` and `size` don't have to be aligned."] #[doc = "They are internally rounded down/up to multiply of `nonCoherentAtomSize`."] #[doc = "- If `size` is 0, this call is ignored."] #[doc = "- If memory type that the `allocation` belongs to is not `HOST_VISIBLE` or it is `HOST_COHERENT`,"] #[doc = "this call is ignored."] #[doc = ""] #[doc = "Warning! `offset` and `size` are relative to the contents of given `allocation`."] #[doc = "If you mean whole allocation, you can pass 0 and `VK_WHOLE_SIZE`, respectively."] #[doc = "Do not pass allocation's offset as `offset`!!!"] pub fn vmaInvalidateAllocation( allocator: VmaAllocator, allocation: VmaAllocation, offset: VkDeviceSize, size: VkDeviceSize, ); } extern "C" { #[doc = " \\brief Checks magic number in margins around all allocations in given memory types (in both default and custom pools) in search for corruptions."] #[doc = ""] #[doc = "@param memoryTypeBits Bit mask, where each bit set means that a memory type with that index should be checked."] #[doc = ""] #[doc = "Corruption detection is enabled only when `VMA_DEBUG_DETECT_CORRUPTION` macro is defined to nonzero,"] #[doc = "`VMA_DEBUG_MARGIN` is defined to nonzero and only for memory types that are"] #[doc = "`HOST_VISIBLE` and `HOST_COHERENT`. For more information, see [Corruption detection](@ref debugging_memory_usage_corruption_detection)."] #[doc = ""] #[doc = "Possible return values:"] #[doc = ""] #[doc = "- `VK_ERROR_FEATURE_NOT_PRESENT` - corruption detection is not enabled for any of specified memory types."] #[doc = "- `VK_SUCCESS` - corruption detection has been performed and succeeded."] #[doc = "- `VK_ERROR_VALIDATION_FAILED_EXT` - corruption detection has been performed and found memory corruptions around one of the allocations."] #[doc = "`VMA_ASSERT` is also fired in that case."] #[doc = "- Other value: Error returned by Vulkan, e.g. memory mapping failure."] pub fn vmaCheckCorruption(allocator: VmaAllocator, memoryTypeBits: u32) -> VkResult; } #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaDefragmentationContext_T { _unused: [u8; 0], } pub type VmaDefragmentationContext = *mut VmaDefragmentationContext_T; pub type VmaDefragmentationFlags = VkFlags; #[doc = " \\brief Parameters for defragmentation."] #[doc = ""] #[doc = "To be used with function vmaDefragmentationBegin()."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaDefragmentationInfo2 { #[doc = " \\brief Reserved for future use. Should be 0."] pub flags: VmaDefragmentationFlags, #[doc = " \\brief Number of allocations in `pAllocations` array."] pub allocationCount: u32, #[doc = " \\brief Pointer to array of allocations that can be defragmented."] #[doc = ""] #[doc = "The array should have `allocationCount` elements."] #[doc = "The array should not contain nulls."] #[doc = "Elements in the array should be unique - same allocation cannot occur twice."] #[doc = "It is safe to pass allocations that are in the lost state - they are ignored."] #[doc = "All allocations not present in this array are considered non-moveable during this defragmentation."] pub pAllocations: *mut VmaAllocation, #[doc = " \\brief Optional, output. Pointer to array that will be filled with information whether the allocation at certain index has been changed during defragmentation."] #[doc = ""] #[doc = "The array should have `allocationCount` elements."] #[doc = "You can pass null if you are not interested in this information."] pub pAllocationsChanged: *mut VkBool32, #[doc = " \\brief Numer of pools in `pPools` array."] pub poolCount: u32, #[doc = " \\brief Either null or pointer to array of pools to be defragmented."] #[doc = ""] #[doc = "All the allocations in the specified pools can be moved during defragmentation"] #[doc = "and there is no way to check if they were really moved as in `pAllocationsChanged`,"] #[doc = "so you must query all the allocations in all these pools for new `VkDeviceMemory`"] #[doc = "and offset using vmaGetAllocationInfo() if you might need to recreate buffers"] #[doc = "and images bound to them."] #[doc = ""] #[doc = "The array should have `poolCount` elements."] #[doc = "The array should not contain nulls."] #[doc = "Elements in the array should be unique - same pool cannot occur twice."] #[doc = ""] #[doc = "Using this array is equivalent to specifying all allocations from the pools in `pAllocations`."] #[doc = "It might be more efficient."] pub pPools: *mut VmaPool, #[doc = " \\brief Maximum total numbers of bytes that can be copied while moving allocations to different places using transfers on CPU side, like `memcpy()`, `memmove()`."] #[doc = ""] #[doc = "`VK_WHOLE_SIZE` means no limit."] pub maxCpuBytesToMove: VkDeviceSize, #[doc = " \\brief Maximum number of allocations that can be moved to a different place using transfers on CPU side, like `memcpy()`, `memmove()`."] #[doc = ""] #[doc = "`UINT32_MAX` means no limit."] pub maxCpuAllocationsToMove: u32, #[doc = " \\brief Maximum total numbers of bytes that can be copied while moving allocations to different places using transfers on GPU side, posted to `commandBuffer`."] #[doc = ""] #[doc = "`VK_WHOLE_SIZE` means no limit."] pub maxGpuBytesToMove: VkDeviceSize, #[doc = " \\brief Maximum number of allocations that can be moved to a different place using transfers on GPU side, posted to `commandBuffer`."] #[doc = ""] #[doc = "`UINT32_MAX` means no limit."] pub maxGpuAllocationsToMove: u32, #[doc = " \\brief Optional. Command buffer where GPU copy commands will be posted."] #[doc = ""] #[doc = "If not null, it must be a valid command buffer handle that supports Transfer queue type."] #[doc = "It must be in the recording state and outside of a render pass instance."] #[doc = "You need to submit it and make sure it finished execution before calling vmaDefragmentationEnd()."] #[doc = ""] #[doc = "Passing null means that only CPU defragmentation will be performed."] pub commandBuffer: VkCommandBuffer, } #[doc = " \\brief Deprecated. Optional configuration parameters to be passed to function vmaDefragment()."] #[doc = ""] #[doc = "\\deprecated This is a part of the old interface. It is recommended to use structure #VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaDefragmentationInfo { #[doc = " \\brief Maximum total numbers of bytes that can be copied while moving allocations to different places."] #[doc = ""] #[doc = "Default is `VK_WHOLE_SIZE`, which means no limit."] pub maxBytesToMove: VkDeviceSize, #[doc = " \\brief Maximum number of allocations that can be moved to different place."] #[doc = ""] #[doc = "Default is `UINT32_MAX`, which means no limit."] pub maxAllocationsToMove: u32, } #[doc = " \\brief Statistics returned by function vmaDefragment()."] #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct VmaDefragmentationStats { #[doc = " Total number of bytes that have been copied while moving allocations to different places."] pub bytesMoved: VkDeviceSize, #[doc = " Total number of bytes that have been released to the system by freeing empty `VkDeviceMemory` objects."] pub bytesFreed: VkDeviceSize, #[doc = " Number of allocations that have been moved to different places."] pub allocationsMoved: u32, #[doc = " Number of empty `VkDeviceMemory` objects that have been released to the system."] pub deviceMemoryBlocksFreed: u32, } extern "C" { #[doc = " \\brief Begins defragmentation process."] #[doc = ""] #[doc = "@param allocator Allocator object."] #[doc = "@param pInfo Structure filled with parameters of defragmentation."] #[doc = "@param[out] pStats Optional. Statistics of defragmentation. You can pass null if you are not interested in this information."] #[doc = "@param[out] pContext Context object that must be passed to vmaDefragmentationEnd() to finish defragmentation."] #[doc = "@return `VK_SUCCESS` and `*pContext == null` if defragmentation finished within this function call. `VK_NOT_READY` and `*pContext != null` if defragmentation has been started and you need to call vmaDefragmentationEnd() to finish it. Negative value in case of error."] #[doc = ""] #[doc = "Use this function instead of old, deprecated vmaDefragment()."] #[doc = ""] #[doc = "Warning! Between the call to vmaDefragmentationBegin() and vmaDefragmentationEnd():"] #[doc = ""] #[doc = "- You should not use any of allocations passed as `pInfo->pAllocations` or"] #[doc = "any allocations that belong to pools passed as `pInfo->pPools`,"] #[doc = "including calling vmaGetAllocationInfo(), vmaTouchAllocation(), or access"] #[doc = "their data."] #[doc = "- Some mutexes protecting internal data structures may be locked, so trying to"] #[doc = "make or free any allocations, bind buffers or images, map memory, or launch"] #[doc = "another simultaneous defragmentation in between may cause stall (when done on"] #[doc = "another thread) or deadlock (when done on the same thread), unless you are"] #[doc = "100% sure that defragmented allocations are in different pools."] #[doc = "- Information returned via `pStats` and `pInfo->pAllocationsChanged` are undefined."] #[doc = "They become valid after call to vmaDefragmentationEnd()."] #[doc = "- If `pInfo->commandBuffer` is not null, you must submit that command buffer"] #[doc = "and make sure it finished execution before calling vmaDefragmentationEnd()."] #[doc = ""] #[doc = "For more information and important limitations regarding defragmentation, see documentation chapter:"] #[doc = "[Defragmentation](@ref defragmentation)."] pub fn vmaDefragmentationBegin( allocator: VmaAllocator, pInfo: *const VmaDefragmentationInfo2, pStats: *mut VmaDefragmentationStats, pContext: *mut VmaDefragmentationContext, ) -> VkResult; } extern "C" { #[doc = " \\brief Ends defragmentation process."] #[doc = ""] #[doc = "Use this function to finish defragmentation started by vmaDefragmentationBegin()."] #[doc = "It is safe to pass `context == null`. The function then does nothing."] pub fn vmaDefragmentationEnd( allocator: VmaAllocator, context: VmaDefragmentationContext, ) -> VkResult; } extern "C" { #[doc = " \\brief Deprecated. Compacts memory by moving allocations."] #[doc = ""] #[doc = "@param pAllocations Array of allocations that can be moved during this compation."] #[doc = "@param allocationCount Number of elements in pAllocations and pAllocationsChanged arrays."] #[doc = "@param[out] pAllocationsChanged Array of boolean values that will indicate whether matching allocation in pAllocations array has been moved. This parameter is optional. Pass null if you don't need this information."] #[doc = "@param pDefragmentationInfo Configuration parameters. Optional - pass null to use default values."] #[doc = "@param[out] pDefragmentationStats Statistics returned by the function. Optional - pass null if you don't need this information."] #[doc = "@return `VK_SUCCESS` if completed, negative error code in case of error."] #[doc = ""] #[doc = "\\deprecated This is a part of the old interface. It is recommended to use structure #VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead."] #[doc = ""] #[doc = "This function works by moving allocations to different places (different"] #[doc = "`VkDeviceMemory` objects and/or different offsets) in order to optimize memory"] #[doc = "usage. Only allocations that are in `pAllocations` array can be moved. All other"] #[doc = "allocations are considered nonmovable in this call. Basic rules:"] #[doc = ""] #[doc = "- Only allocations made in memory types that have"] #[doc = "`VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT` and `VK_MEMORY_PROPERTY_HOST_COHERENT_BIT`"] #[doc = "flags can be compacted. You may pass other allocations but it makes no sense -"] #[doc = "these will never be moved."] #[doc = "- Custom pools created with #VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT or"] #[doc = "#VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT flag are not defragmented. Allocations"] #[doc = "passed to this function that come from such pools are ignored."] #[doc = "- Allocations created with #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT or"] #[doc = "created as dedicated allocations for any other reason are also ignored."] #[doc = "- Both allocations made with or without #VMA_ALLOCATION_CREATE_MAPPED_BIT"] #[doc = "flag can be compacted. If not persistently mapped, memory will be mapped"] #[doc = "temporarily inside this function if needed."] #[doc = "- You must not pass same #VmaAllocation object multiple times in `pAllocations` array."] #[doc = ""] #[doc = "The function also frees empty `VkDeviceMemory` blocks."] #[doc = ""] #[doc = "Warning: This function may be time-consuming, so you shouldn't call it too often"] #[doc = "(like after every resource creation/destruction)."] #[doc = "You can call it on special occasions (like when reloading a game level or"] #[doc = "when you just destroyed a lot of objects). Calling it every frame may be OK, but"] #[doc = "you should measure that on your platform."] #[doc = ""] #[doc = "For more information, see [Defragmentation](@ref defragmentation) chapter."] pub fn vmaDefragment( allocator: VmaAllocator, pAllocations: *mut VmaAllocation, allocationCount: usize, pAllocationsChanged: *mut VkBool32, pDefragmentationInfo: *const VmaDefragmentationInfo, pDefragmentationStats: *mut VmaDefragmentationStats, ) -> VkResult; } extern "C" { #[doc = " \\brief Binds buffer to allocation."] #[doc = ""] #[doc = "Binds specified buffer to region of memory represented by specified allocation."] #[doc = "Gets `VkDeviceMemory` handle and offset from the allocation."] #[doc = "If you want to create a buffer, allocate memory for it and bind them together separately,"] #[doc = "you should use this function for binding instead of standard `vkBindBufferMemory()`,"] #[doc = "because it ensures proper synchronization so that when a `VkDeviceMemory` object is used by multiple"] #[doc = "allocations, calls to `vkBind*Memory()` or `vkMapMemory()` won't happen from multiple threads simultaneously"] #[doc = "(which is illegal in Vulkan)."] #[doc = ""] #[doc = "It is recommended to use function vmaCreateBuffer() instead of this one."] pub fn vmaBindBufferMemory( allocator: VmaAllocator, allocation: VmaAllocation, buffer: VkBuffer, ) -> VkResult; } extern "C" { #[doc = " \\brief Binds buffer to allocation with additional parameters."] #[doc = ""] #[doc = "@param allocationLocalOffset Additional offset to be added while binding, relative to the beginnig of the `allocation`. Normally it should be 0."] #[doc = "@param pNext A chain of structures to be attached to `VkBindBufferMemoryInfoKHR` structure used internally. Normally it should be null."] #[doc = ""] #[doc = "This function is similar to vmaBindBufferMemory(), but it provides additional parameters."] #[doc = ""] #[doc = "If `pNext` is not null, #VmaAllocator object must have been created with #VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag."] #[doc = "Otherwise the call fails."] pub fn vmaBindBufferMemory2( allocator: VmaAllocator, allocation: VmaAllocation, allocationLocalOffset: VkDeviceSize, buffer: VkBuffer, pNext: *const ::std::os::raw::c_void, ) -> VkResult; } extern "C" { #[doc = " \\brief Binds image to allocation."] #[doc = ""] #[doc = "Binds specified image to region of memory represented by specified allocation."] #[doc = "Gets `VkDeviceMemory` handle and offset from the allocation."] #[doc = "If you want to create an image, allocate memory for it and bind them together separately,"] #[doc = "you should use this function for binding instead of standard `vkBindImageMemory()`,"] #[doc = "because it ensures proper synchronization so that when a `VkDeviceMemory` object is used by multiple"] #[doc = "allocations, calls to `vkBind*Memory()` or `vkMapMemory()` won't happen from multiple threads simultaneously"] #[doc = "(which is illegal in Vulkan)."] #[doc = ""] #[doc = "It is recommended to use function vmaCreateImage() instead of this one."] pub fn vmaBindImageMemory( allocator: VmaAllocator, allocation: VmaAllocation, image: VkImage, ) -> VkResult; } extern "C" { #[doc = " \\brief Binds image to allocation with additional parameters."] #[doc = ""] #[doc = "@param allocationLocalOffset Additional offset to be added while binding, relative to the beginnig of the `allocation`. Normally it should be 0."] #[doc = "@param pNext A chain of structures to be attached to `VkBindImageMemoryInfoKHR` structure used internally. Normally it should be null."] #[doc = ""] #[doc = "This function is similar to vmaBindImageMemory(), but it provides additional parameters."] #[doc = ""] #[doc = "If `pNext` is not null, #VmaAllocator object must have been created with #VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT flag."] #[doc = "Otherwise the call fails."] pub fn vmaBindImageMemory2( allocator: VmaAllocator, allocation: VmaAllocation, allocationLocalOffset: VkDeviceSize, image: VkImage, pNext: *const ::std::os::raw::c_void, ) -> VkResult; } extern "C" { #[doc = "@param[out] pBuffer Buffer that was created."] #[doc = "@param[out] pAllocation Allocation that was created."] #[doc = "@param[out] pAllocationInfo Optional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo()."] #[doc = ""] #[doc = "This function automatically:"] #[doc = ""] #[doc = "-# Creates buffer."] #[doc = "-# Allocates appropriate memory for it."] #[doc = "-# Binds the buffer with the memory."] #[doc = ""] #[doc = "If any of these operations fail, buffer and allocation are not created,"] #[doc = "returned value is negative error code, *pBuffer and *pAllocation are null."] #[doc = ""] #[doc = "If the function succeeded, you must destroy both buffer and allocation when you"] #[doc = "no longer need them using either convenience function vmaDestroyBuffer() or"] #[doc = "separately, using `vkDestroyBuffer()` and vmaFreeMemory()."] #[doc = ""] #[doc = "If VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT flag was used,"] #[doc = "VK_KHR_dedicated_allocation extension is used internally to query driver whether"] #[doc = "it requires or prefers the new buffer to have dedicated allocation. If yes,"] #[doc = "and if dedicated allocation is possible (VmaAllocationCreateInfo::pool is null"] #[doc = "and VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT is not used), it creates dedicated"] #[doc = "allocation for this buffer, just like when using"] #[doc = "VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT."] pub fn vmaCreateBuffer( allocator: VmaAllocator, pBufferCreateInfo: *const VkBufferCreateInfo, pAllocationCreateInfo: *const VmaAllocationCreateInfo, pBuffer: *mut VkBuffer, pAllocation: *mut VmaAllocation, pAllocationInfo: *mut VmaAllocationInfo, ) -> VkResult; } extern "C" { #[doc = " \\brief Destroys Vulkan buffer and frees allocated memory."] #[doc = ""] #[doc = "This is just a convenience function equivalent to:"] #[doc = ""] #[doc = "\\code"] #[doc = "vkDestroyBuffer(device, buffer, allocationCallbacks);"] #[doc = "vmaFreeMemory(allocator, allocation);"] #[doc = "\\endcode"] #[doc = ""] #[doc = "It it safe to pass null as buffer and/or allocation."] pub fn vmaDestroyBuffer(allocator: VmaAllocator, buffer: VkBuffer, allocation: VmaAllocation); } extern "C" { #[doc = " Function similar to vmaCreateBuffer()."] pub fn vmaCreateImage( allocator: VmaAllocator, pImageCreateInfo: *const VkImageCreateInfo, pAllocationCreateInfo: *const VmaAllocationCreateInfo, pImage: *mut VkImage, pAllocation: *mut VmaAllocation, pAllocationInfo: *mut VmaAllocationInfo, ) -> VkResult; } extern "C" { #[doc = " \\brief Destroys Vulkan image and frees allocated memory."] #[doc = ""] #[doc = "This is just a convenience function equivalent to:"] #[doc = ""] #[doc = "\\code"] #[doc = "vkDestroyImage(device, image, allocationCallbacks);"] #[doc = "vmaFreeMemory(allocator, allocation);"] #[doc = "\\endcode"] #[doc = ""] #[doc = "It it safe to pass null as image and/or allocation."] pub fn vmaDestroyImage(allocator: VmaAllocator, image: VkImage, allocation: VmaAllocation); }