pub type VkFlags = u32;
pub type VkBool32 = u32;
pub type VkDeviceSize = u64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VkInstance_T {
_unused: [u8; 0],
}
pub type VkInstance = *mut VkInstance_T;
#[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<unsafe extern "C" fn(device: VkDevice, memory: VkDeviceMemory)>;
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,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VkPhysicalDeviceMemoryProperties2 {
pub sType: VkStructureType,
pub pNext: *mut ::std::os::raw::c_void,
pub memoryProperties: VkPhysicalDeviceMemoryProperties,
}
pub type PFN_vkGetPhysicalDeviceMemoryProperties2KHR = ::std::option::Option<
unsafe extern "C" fn(
physicalDevice: VkPhysicalDevice,
pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2,
),
>;
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 vkGetPhysicalDeviceMemoryProperties2KHR: PFN_vkGetPhysicalDeviceMemoryProperties2KHR,
}
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,
#[doc = " \\brief Optional handle to Vulkan instance object."]
#[doc = ""]
#[doc = "Optional, can be null. Must be set if #VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT flas is used"]
#[doc = "or if `vulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0)`."]
pub instance: VkInstance,
#[doc = " \\brief Optional. The highest version of Vulkan that the application is designed to use."]
#[doc = ""]
#[doc = "It must be a value in the format as created by macro `VK_MAKE_VERSION` or a constant like: `VK_API_VERSION_1_1`, `VK_API_VERSION_1_0`."]
#[doc = "The patch version number specified is ignored. Only the major and minor versions are considered."]
#[doc = "It must be less or equal (preferably equal) to value as passed to `vkCreateInstance` as `VkApplicationInfo::apiVersion`."]
#[doc = "Only versions 1.0 and 1.1 are supported by the current implementation."]
#[doc = "Leaving it initialized to zero is equivalent to `VK_API_VERSION_1_0`."]
pub vulkanApiVersion: u32,
}
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);
}
#[doc = " \\brief Information about existing #VmaAllocator object."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VmaAllocatorInfo {
#[doc = " \\brief Handle to Vulkan instance object."]
#[doc = ""]
#[doc = "This is the same value as has been passed through VmaAllocatorCreateInfo::instance."]
pub instance: VkInstance,
#[doc = " \\brief Handle to Vulkan physical device object."]
#[doc = ""]
#[doc = "This is the same value as has been passed through VmaAllocatorCreateInfo::physicalDevice."]
pub physicalDevice: VkPhysicalDevice,
#[doc = " \\brief Handle to Vulkan device object."]
#[doc = ""]
#[doc = "This is the same value as has been passed through VmaAllocatorCreateInfo::device."]
pub device: VkDevice,
}
extern "C" {
#[doc = " \\brief Returns information about existing #VmaAllocator object - handle to Vulkan device etc."]
#[doc = ""]
#[doc = "It might be useful if you want to keep just the #VmaAllocator handle and fetch other required handles to"]
#[doc = "`VkPhysicalDevice`, `VkDevice` etc. every time using this function."]
pub fn vmaGetAllocatorInfo(allocator: VmaAllocator, pAllocatorInfo: *mut VmaAllocatorInfo);
}
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 = " \\brief Retrieves statistics from current state of the Allocator."]
#[doc = ""]
#[doc = "This function is called \"calculate\" not \"get\" because it has to traverse all"]
#[doc = "internal data structures, so it may be quite slow. For faster but more brief statistics"]
#[doc = "suitable to be called every frame or every allocation, use vmaGetBudget()."]
#[doc = ""]
#[doc = "Note that when using allocator from multiple threads, returned information may immediately"]
#[doc = "become outdated."]
pub fn vmaCalculateStats(allocator: VmaAllocator, pStats: *mut VmaStats);
}
#[doc = " \\brief Statistics of current memory usage and available budget, in bytes, for specific memory heap."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VmaBudget {
#[doc = " \\brief Sum size of all `VkDeviceMemory` blocks allocated from particular heap, in bytes."]
pub blockBytes: VkDeviceSize,
#[doc = " \\brief Sum size of all allocations created in particular heap, in bytes."]
#[doc = ""]
#[doc = "Usually less or equal than `blockBytes`."]
#[doc = "Difference `blockBytes - allocationBytes` is the amount of memory allocated but unused -"]
#[doc = "available for new allocations or wasted due to fragmentation."]
#[doc = ""]
#[doc = "It might be greater than `blockBytes` if there are some allocations in lost state, as they account"]
#[doc = "to this value as well."]
pub allocationBytes: VkDeviceSize,
#[doc = " \\brief Estimated current memory usage of the program, in bytes."]
#[doc = ""]
#[doc = "Fetched from system using `VK_EXT_memory_budget` extension if enabled."]
#[doc = ""]
#[doc = "It might be different than `blockBytes` (usually higher) due to additional implicit objects"]
#[doc = "also occupying the memory, like swapchain, pipelines, descriptor heaps, command buffers, or"]
#[doc = "`VkDeviceMemory` blocks allocated outside of this library, if any."]
pub usage: VkDeviceSize,
#[doc = " \\brief Estimated amount of memory available to the program, in bytes."]
#[doc = ""]
#[doc = "Fetched from system using `VK_EXT_memory_budget` extension if enabled."]
#[doc = ""]
#[doc = "It might be different (most probably smaller) than `VkMemoryHeap::size[heapIndex]` due to factors"]
#[doc = "external to the program, like other programs also consuming system resources."]
#[doc = "Difference `budget - usage` is the amount of additional memory that can probably"]
#[doc = "be allocated without problems. Exceeding the budget may result in various problems."]
pub budget: VkDeviceSize,
}
extern "C" {
#[doc = " \\brief Retrieves information about current memory budget for all memory heaps."]
#[doc = ""]
#[doc = "\\param[out] pBudget Must point to array with number of elements at least equal to number of memory heaps in physical device used."]
#[doc = ""]
#[doc = "This function is called \"get\" not \"calculate\" because it is very fast, suitable to be called"]
#[doc = "every frame or every allocation. For more detailed statistics use vmaCalculateStats()."]
#[doc = ""]
#[doc = "Note that when using allocator from multiple threads, returned information may immediately"]
#[doc = "become outdated."]
pub fn vmaGetBudget(allocator: VmaAllocator, pBudget: *mut VmaBudget);
}
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 = " CPU memory - memory that is preferably not `DEVICE_LOCAL`, but also not guaranteed to be `HOST_VISIBLE`."]
#[doc = ""]
#[doc = "Usage: Staging copy of resources moved from GPU memory to CPU memory as part"]
#[doc = "of custom paging/residency mechanism, to be moved back to GPU memory when needed."]
pub const VmaMemoryUsage_VMA_MEMORY_USAGE_CPU_COPY: VmaMemoryUsage = 5;
#[doc = " Lazily allocated GPU memory having `VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT`."]
#[doc = "Exists mostly on mobile platforms. Using it on desktop PC or other GPUs with no such memory type present will fail the allocation."]
#[doc = ""]
#[doc = "Usage: Memory for transient attachment images (color attachments, depth attachments etc.), created with `VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT`."]
#[doc = ""]
#[doc = "Allocations with this usage are always created as dedicated - it implies #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT."]
pub const VmaMemoryUsage_VMA_MEMORY_USAGE_GPU_LAZILY_ALLOCATED: VmaMemoryUsage = 6;
#[doc = " Lazily allocated GPU memory having `VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT`."]
#[doc = "Exists mostly on mobile platforms. Using it on desktop PC or other GPUs with no such memory type present will fail the allocation."]
#[doc = ""]
#[doc = "Usage: Memory for transient attachment images (color attachments, depth attachments etc.), created with `VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT`."]
#[doc = ""]
#[doc = "Allocations with this usage are always created as dedicated - it implies #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT."]
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 = " \\brief Retrieves name of a custom pool."]
#[doc = ""]
#[doc = "After the call `ppName` is either null or points to an internally-owned null-terminated string"]
#[doc = "containing name of the pool that was previously set. The pointer becomes invalid when the pool is"]
#[doc = "destroyed or its name is changed using vmaSetPoolName()."]
pub fn vmaGetPoolName(
allocator: VmaAllocator,
pool: VmaPool,
ppName: *mut *const ::std::os::raw::c_char,
);
}
extern "C" {
#[doc = " \\brief Sets name of a custom pool."]
#[doc = ""]
#[doc = "`pName` can be either null or pointer to a null-terminated string with new name for the pool."]
#[doc = "Function makes internal copy of the string, so it can be changed or freed immediately after this call."]
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 = "\\deprecated"]
#[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."]
#[doc = ""]
#[doc = "This function doesn't automatically flush or invalidate caches."]
#[doc = "If the allocation is made from a memory types that is not `HOST_COHERENT`,"]
#[doc = "you also need to use vmaInvalidateAllocation() / vmaFlushAllocation(), as required by Vulkan specification."]
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()."]
#[doc = ""]
#[doc = "This function doesn't automatically flush or invalidate caches."]
#[doc = "If the allocation is made from a memory types that is not `HOST_COHERENT`,"]
#[doc = "you also need to use vmaInvalidateAllocation() / vmaFlushAllocation(), as required by Vulkan specification."]
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 = "It needs to be called after writing to a mapped memory for memory types that are not `HOST_COHERENT`."]
#[doc = "Unmap operation doesn't do that automatically."]
#[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 = "It needs to be called before reading from a mapped memory for memory types that are not `HOST_COHERENT`."]
#[doc = "Map operation doesn't do that automatically."]
#[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,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VmaDefragmentationPassMoveInfo {
pub allocation: VmaAllocation,
pub memory: VkDeviceMemory,
pub offset: VkDeviceSize,
}
#[doc = " \\brief Parameters for incremental defragmentation steps."]
#[doc = ""]
#[doc = "To be used with function vmaBeginDefragmentationPass()."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VmaDefragmentationPassInfo {
pub moveCount: u32,
pub pMoves: *mut VmaDefragmentationPassMoveInfo,
}
#[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" {
pub fn vmaBeginDefragmentationPass(
allocator: VmaAllocator,
context: VmaDefragmentationContext,
pInfo: *mut VmaDefragmentationPassInfo,
) -> VkResult;
}
extern "C" {
pub fn vmaEndDefragmentationPass(
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 = "or with VmaAllocatorCreateInfo::vulkanApiVersion `== VK_API_VERSION_1_1`. 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 = "or with VmaAllocatorCreateInfo::vulkanApiVersion `== VK_API_VERSION_1_1`. 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);
}