vulkan/api/vulkan.api - platform/frameworks/native - Gitiles

 // Copyright (c) 2015 The Khronos Group Inc.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a
 // copy of this software and/or associated documentation files (the
 // "Materials"), to deal in the Materials without restriction, including
 // without limitation the rights to use, copy, modify, merge, publish,
 // distribute, sublicense, and/or sell copies of the Materials, and to
 // permit persons to whom the Materials are furnished to do so, subject to
 // the following conditions:
 //
 // The above copyright notice and this permission notice shall be included
 // in all copies or substantial portions of the Materials.
 //
 // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

 import platform "platform.api"

 ///////////////
 // Constants //
 ///////////////

 // API version (major.minor.patch)
 define VERSION_MAJOR 1
 define VERSION_MINOR 1
 define VERSION_PATCH 86

 // API limits
 define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
 define VK_UUID_SIZE                     16
 define VK_MAX_EXTENSION_NAME_SIZE       256
 define VK_MAX_DESCRIPTION_SIZE          256
 define VK_MAX_MEMORY_TYPES              32
 define VK_MAX_MEMORY_HEAPS              16    /// The maximum number of unique memory heaps, each of which supporting 1 or more memory types.
 @vulkan1_1
 define VK_MAX_DEVICE_GROUP_SIZE         32
 @vulkan1_1
 define VK_LUID_SIZE                     8
 @vulkan1_1
 define VK_QUEUE_FAMILY_EXTERNAL         -2
 @extension("VK_EXT_queue_family_foreign")
 define VK_QUEUE_FAMILY_FOREIGN_EXT      -3
 @extension("VK_MAX_DRIVER_NAME_SIZE_KHR") // 197
 define VK_MAX_DRIVER_NAME_SIZE_KHR      256
 @extension("VK_MAX_DRIVER_NAME_SIZE_KHR") // 197
 define VK_MAX_DRIVER_INFO_SIZE_KHR      256

 // API keywords
 define VK_TRUE        1
 define VK_FALSE       0

 // API keyword, but needs special handling by some templates
 define NULL_HANDLE 0

 // 1
 @extension("VK_KHR_surface") define VK_KHR_SURFACE_SPEC_VERSION                 25
 @extension("VK_KHR_surface") define VK_KHR_SURFACE_EXTENSION_NAME               "VK_KHR_surface"

 // 2
 @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_SPEC_VERSION             70
 @extension("VK_KHR_swapchain") define VK_KHR_SWAPCHAIN_EXTENSION_NAME           "VK_KHR_swapchain"

 // 3
 @extension("VK_KHR_display") define VK_KHR_DISPLAY_SPEC_VERSION                 21
 @extension("VK_KHR_display") define VK_KHR_DISPLAY_EXTENSION_NAME               "VK_KHR_display"

 // 4
 @extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION     9
 @extension("VK_KHR_display_swapchain") define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_display_swapchain"

 // 5
 @extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_SPEC_VERSION       6
 @extension("VK_KHR_xlib_surface") define VK_KHR_XLIB_SURFACE_NAME               "VK_KHR_xlib_surface"

 // 6
 @extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_SPEC_VERSION         6
 @extension("VK_KHR_xcb_surface") define VK_KHR_XCB_SURFACE_NAME                 "VK_KHR_xcb_surface"

 // 7
 @extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
 @extension("VK_KHR_wayland_surface") define VK_KHR_WAYLAND_SURFACE_NAME         "VK_KHR_wayland_surface"

 // 8
 @extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_SPEC_VERSION         4
 @extension("VK_KHR_mir_surface") define VK_KHR_MIR_SURFACE_NAME                 "VK_KHR_mir_surface"

 // 9
 @extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
 @extension("VK_KHR_android_surface") define VK_KHR_ANDROID_SURFACE_NAME         "VK_KHR_android_surface"

 // 10
 @extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_SPEC_VERSION     6
 @extension("VK_KHR_win32_surface") define VK_KHR_WIN32_SURFACE_NAME             "VK_KHR_win32_surface"

 // 11
 @extension("VK_ANDROID_native_buffer") define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION     7
 @extension("VK_ANDROID_native_buffer") define VK_ANDROID_NATIVE_BUFFER_NAME             "VK_ANDROID_native_buffer"

 // 12
 @extension("VK_EXT_debug_report") define VK_EXT_DEBUG_REPORT_SPEC_VERSION       9
 @extension("VK_EXT_debug_report") define VK_EXT_DEBUG_REPORT_NAME               "VK_EXT_debug_report"

 // 13
 @extension("VK_NV_glsl_shader") define VK_NV_GLSL_SHADER_SPEC_VERSION           1
 @extension("VK_NV_glsl_shader") define VK_NV_GLSL_SHADER_NAME                   "VK_NV_glsl_shader"

 // 14
 @extension("VK_EXT_depth_range_unrestricted") define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION   1
 @extension("VK_EXT_depth_range_unrestricted") define VK_EXT_DEPTH_RANGE_UNRESTRICTED_NAME           "VK_EXT_depth_range_unrestricted"

 // 15
 @extension("VK_KHR_sampler_mirror_clamp_to_edge") define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION   1
 @extension("VK_KHR_sampler_mirror_clamp_to_edge") define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_NAME           "VK_KHR_sampler_mirror_clamp_to_edge"

 // 16
 @extension("VK_IMG_filter_cubic") define VK_IMG_FILTER_CUBIC_SPEC_VERSION       1
 @extension("VK_IMG_filter_cubic") define VK_IMG_FILTER_CUBIC_NAME               "VK_IMG_filter_cubic"

 // 19
 @extension("VK_AMD_rasterization_order") define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION   1
 @extension("VK_AMD_rasterization_order") define VK_AMD_RASTERIZATION_ORDER_NAME           "VK_AMD_rasterization_order"

 // 21
 @extension("VK_AMD_shader_trinary_minmax") define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
 @extension("VK_AMD_shader_trinary_minmax") define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"

 // 22
 @extension("VK_AMD_shader_explicit_vertex_parameter") define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
 @extension("VK_AMD_shader_explicit_vertex_parameter") define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"

 // 23
 @extension("VK_EXT_debug_marker") define VK_EXT_DEBUG_MARKER_SPEC_VERSION       4
 @extension("VK_EXT_debug_marker") define VK_EXT_DEBUG_MARKER_NAME               "VK_EXT_debug_marker"

 // 26
 @extension("VK_AMD_gcn_shader") define VK_AMD_GCN_SHADER_SPEC_VERSION 1
 @extension("VK_AMD_gcn_shader") define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader"

 // 27
 @extension("VK_NV_dedicated_allocation") define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
 @extension("VK_NV_dedicated_allocation") define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"

 // 28
 @extension("VK_IMG_format_pvrtc") define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1
 @extension("VK_IMG_format_pvrtc") define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"

 // 34
 @extension("VK_AMD_draw_indirect_count") define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
 @extension("VK_AMD_draw_indirect_count") define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"

 // 36
 @extension("VK_AMD_negative_viewport_height") define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
 @extension("VK_AMD_negative_viewport_height") define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"

 // 37
 @extension("VK_AMD_gpu_shader_half_float") define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1
 @extension("VK_AMD_gpu_shader_half_float") define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"

 // 38
 @extension("VK_AMD_shader_ballot") define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
 @extension("VK_AMD_shader_ballot") define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"

 // 42
 @extension("VK_AMD_texture_gather_bias_lod") define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
 @extension("VK_AMD_texture_gather_bias_lod") define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"

 // 43
 @extension("VK_AMD_shader_info") define VK_AMD_SHADER_INFO_SPEC_VERSION 1
 @extension("VK_AMD_shader_info") define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"

 // 47
 @extension("VK_AMD_shader_image_load_store_lod") define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1
 @extension("VK_AMD_shader_image_load_store_lod") define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"

 // 51
 @extension("VK_NV_corner_sampled_image") define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2
 @extension("VK_NV_corner_sampled_image") define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image"

 // 54
 @extension("VK_KHR_multiview") define VK_KHR_MULTIVIEW_SPEC_VERSION 1
 @extension("VK_KHR_multiview") define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview"

 // 56
 @extension("VK_NV_external_memory_capabilities") define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
 @extension("VK_NV_external_memory_capabilities") define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"

 // 57
 @extension("VK_NV_external_memory") define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
 @extension("VK_NV_external_memory") define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"

 // 58
 @extension("VK_NV_external_memory_win32") define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
 @extension("VK_NV_external_memory_win32") define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"

 // 59
 @extension("VK_NV_win32_keyed_mutex") define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
 @extension("VK_NV_win32_keyed_mutex") define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"

 // 60
 @extension("VK_KHR_get_physical_device_properties2") define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
 @extension("VK_KHR_get_physical_device_properties2") define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"

 // 61
 @extension("VK_KHR_device_group") define VK_KHR_DEVICE_GROUP_SPEC_VERSION 3
 @extension("VK_KHR_device_group") define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"

 // 62
 @extension("VK_EXT_validation_flags") define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
 @extension("VK_EXT_validation_flags") define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"

 // 63
 @extension("VK_NN_vi_surface") define VK_NN_VI_SURFACE_SPEC_VERSION 1
 @extension("VK_NN_vi_surface") define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface"

 // 64
 @extension("VK_KHR_shader_draw_parameters") define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
 @extension("VK_KHR_shader_draw_parameters") define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"

 // 65
 @extension("VK_EXT_shader_subgroup_ballot") define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
 @extension("VK_EXT_shader_subgroup_ballot") define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"

 // 66
 @extension("VK_EXT_shader_subgroup_vote") define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
 @extension("VK_EXT_shader_subgroup_vote") define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"

 // 68
 @extension("VK_EXT_astc_decode_mode") define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1
 @extension("VK_EXT_astc_decode_mode") define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"

 // 70
 @extension("VK_KHR_maintenance1") define VK_KHR_MAINTENANCE1_SPEC_VERSION 2
 @extension("VK_KHR_maintenance1") define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"

 // 71
 @extension("VK_KHR_device_group_creation") define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1
 @extension("VK_KHR_device_group_creation") define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation"

 // 72
 @extension("VK_KHR_external_memory_capabilities") define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
 @extension("VK_KHR_external_memory_capabilities") define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"

 // 73
 @extension("VK_KHR_external_memory") define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
 @extension("VK_KHR_external_memory") define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"

 // 74
 @extension("VK_KHR_external_memory_win32") define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
 @extension("VK_KHR_external_memory_win32") define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"

 // 75
 @extension("VK_KHR_external_memory_fd") define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
 @extension("VK_KHR_external_memory_fd") define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"

 // 76
 @extension("VK_KHR_win32_keyed_mutex") define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
 @extension("VK_KHR_win32_keyed_mutex") define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"

 // 77
 @extension("VK_KHR_external_semaphore_capabilities") define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
 @extension("VK_KHR_external_semaphore_capabilities") define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"

 // 78
 @extension("VK_KHR_external_semaphore") define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
 @extension("VK_KHR_external_semaphore") define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"

 // 79
 @extension("VK_KHR_external_semaphore_win32") define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
 @extension("VK_KHR_external_semaphore_win32") define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"

 // 80
 @extension("VK_KHR_external_semaphore_fd") define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
 @extension("VK_KHR_external_semaphore_fd") define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"

 // 81
 @extension("VK_KHR_push_descriptor") define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2
 @extension("VK_KHR_push_descriptor") define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"

 // 82
 @extension("VK_EXT_conditional_rendering") define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 1
 @extension("VK_EXT_conditional_rendering") define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"

 // 84
 @extension("VK_KHR_16bit_storage") define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
 @extension("VK_KHR_16bit_storage") define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"

 // 85
 @extension("VK_KHR_incremental_present") define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
 @extension("VK_KHR_incremental_present") define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"

 // 86
 @extension("VK_KHR_descriptor_update_template") define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
 @extension("VK_KHR_descriptor_update_template") define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"

 // 87
 @extension("VK_NVX_device_generated_commands") define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
 @extension("VK_NVX_device_generated_commands") define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"

 // 88
 @extension("VK_NV_clip_space_w_scaling") define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
 @extension("VK_NV_clip_space_w_scaling") define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"

 // 89
 @extension("VK_EXT_direct_mode_display") define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
 @extension("VK_EXT_direct_mode_display") define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"

 // 90
 @extension("VK_EXT_acquire_xlib_display") define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
 @extension("VK_EXT_acquire_xlib_display") define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"

 // 91
 @extension("VK_EXT_display_surface_counter") define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
 @extension("VK_EXT_display_surface_counter") define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"

 // 92
 @extension("VK_EXT_display_control") define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
 @extension("VK_EXT_display_control") define VK_EXT_DISPLAY_CONTROL_COUNTER_EXTENSION_NAME "VK_EXT_display_control"

 // 93
 @extension("VK_GOOGLE_display_timing") define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
 @extension("VK_GOOGLE_display_timing") define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"

 // 95
 @extension("VK_NV_sample_mask_override_coverage") define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
 @extension("VK_NV_sample_mask_override_coverage") define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"

 // 96
 @extension("VK_NV_geometry_shader_passthrough") define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
 @extension("VK_NV_geometry_shader_passthrough") define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"

 // 97
 @extension("VK_NV_viewport_array2") define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
 @extension("VK_NV_viewport_array2") define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"

 // 98
 @extension("VK_NVX_multiview_per_view_attributes") define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
 @extension("VK_NVX_multiview_per_view_attributes") define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"

 // 99
 @extension("VK_NV_viewport_swizzle") define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
 @extension("VK_NV_viewport_swizzle") define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"

 // 100
 @extension("VK_EXT_discard_rectangles") define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
 @extension("VK_EXT_discard_rectangles") define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"

 // 102
 @extension("VK_EXT_conservative_rasterization") define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1
 @extension("VK_EXT_conservative_rasterization") define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"

 // 105
 @extension("VK_EXT_swapchain_colorspace") define VK_EXT_SWAPCHAIN_COLORSPACE_SPEC_VERSION 3
 @extension("VK_EXT_swapchain_colorspace") define VK_EXT_SWAPCHAIN_COLORSPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"

 // 106
 @extension("VK_EXT_hdr_metadata") define VK_EXT_HDR_METADATA_SPEC_VERSION 1
 @extension("VK_EXT_hdr_metadata") define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"

 // 110
 @extension("VK_KHR_create_renderpass2") define VK_KHR_CREATE_RENDERPASS2_SPEC_VERSION 1
 @extension("VK_KHR_create_renderpass2") define VK_KHR_CREATE_RENDERPASS2_EXTENSION_NAME "VK_KHR_create_renderpass2"

 // 112
 @extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
 @extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"

 // 113
 @extension("VK_KHR_external_fence_capabilities") define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
 @extension("VK_KHR_external_fence_capabilities") define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"

 // 114
 @extension("VK_KHR_external_fence") define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
 @extension("VK_KHR_external_fence") define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"

 // 115
 @extension("VK_KHR_external_fence_win32") define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
 @extension("VK_KHR_external_fence_win32") define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"

 // 116
 @extension("VK_KHR_external_fence_fd") define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
 @extension("VK_KHR_external_fence_fd") define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"

 // 118
 @extension("VK_KHR_maintenance2") define VK_KHR_MAINTENANCE2_SPEC_VERSION 1
 @extension("VK_KHR_maintenance2") define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"

 // 120
 @extension("VK_KHR_get_surface_capabilities2") define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
 @extension("VK_KHR_get_surface_capabilities2") define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"

 // 121
 @extension("VK_KHR_variable_pointers") define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
 @extension("VK_KHR_variable_pointers") define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"

 // 122
 @extension("VK_KHR_get_display_properties2") define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1
 @extension("VK_KHR_get_display_properties2") define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2"

 // 123
 @extension("VK_MVK_ios_surface") define VK_MVK_IOS_SURFACE_SPEC_VERSION 1
 @extension("VK_MVK_ios_surface") define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"

 // 124
 @extension("VK_MVK_macos_surface") define VK_MVK_MACOS_SURFACE_SPEC_VERSION 1
 @extension("VK_MVK_macos_surface") define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"

 // 126
 @extension("VK_EXT_external_memory_dma_buf") define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1
 @extension("VK_EXT_external_memory_dma_buf") define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"

 // 127
 @extension("VK_EXT_queue_family_foreign") define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1
 @extension("VK_EXT_queue_family_foreign") define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"

 // 128
 @extension("VK_KHR_dedicated_allocation") define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
 @extension("VK_KHR_dedicated_allocation") define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"

 // 128
 @extension("VK_EXT_debug_utils") define VK_EXT_DEBUG_UTILS_SPEC_VERSION 1
 @extension("VK_EXT_debug_utils") define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils"

 // 130
 @extension("VK_ANDROID_external_memory_android_hardware_buffer") define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3
 @extension("VK_ANDROID_external_memory_android_hardware_buffer") define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"

 // 131
 @extension("VK_EXT_sampler_filter_minmax") define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1
 @extension("VK_EXT_sampler_filter_minmax") define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"

 // 132
 @extension("VK_KHR_storage_buffer_storage_class") define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
 @extension("VK_KHR_storage_buffer_storage_class") define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"

 // 133
 @extension("VK_AMD_gpu_shader_int16") define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1
 @extension("VK_AMD_gpu_shader_int16") define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"

 // 137
 @extension("VK_AMD_mixed_attachment_samples") define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
 @extension("VK_AMD_mixed_attachment_samples") define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"

 // 138
 @extension("VK_AMD_shader_fragment_mask") define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1
 @extension("VK_AMD_shader_fragment_mask") define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"

 // 139
 @extension("VK_EXT_inline_uniform_block") define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1
 @extension("VK_EXT_inline_uniform_block") define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block"

 // 141
 @extension("VK_EXT_shader_stencil_export") define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
 @extension("VK_EXT_shader_stencil_export") define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"

 // 144
 @extension("VK_EXT_sample_locations") define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1
 @extension("VK_EXT_sample_locations") define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"

 // 145
 @extension("VK_KHR_relaxed_block_layout") define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
 @extension("VK_KHR_relaxed_block_layout") define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"

 // 147
 @extension("VK_KHR_get_memory_requirements2") define VK_KHR_GET_MEMORY_REQUIREMENTS2_SPEC_VERSION 1
 @extension("VK_KHR_get_memory_requirements2") define VK_KHR_GET_MEMORY_REQUIREMENTS2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"

 // 148
 @extension("VK_KHR_image_format_list") define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
 @extension("VK_KHR_image_format_list") define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"

 // 149
 @extension("VK_EXT_blend_operation_advanced") define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
 @extension("VK_EXT_blend_operation_advanced") define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"

 // 150
 @extension("VK_NV_fragment_coverage_to_color") define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
 @extension("VK_NV_fragment_coverage_to_color") define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"

 // 153
 @extension("VK_NV_framebuffer_mixed_samples") define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
 @extension("VK_NV_framebuffer_mixed_samples") define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"

 // 154
 @extension("VK_NV_fill_rectangle") define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
 @extension("VK_NV_fill_rectangle") define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"

 // 156
 @extension("VK_EXT_post_depth_coverage") define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
 @extension("VK_EXT_post_depth_coverage") define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"

 // 157
 @extension("VK_KHR_sampler_ycbcr_conversion") define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1
 @extension("VK_KHR_sampler_ycbcr_conversion") define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"

 // 158
 @extension("VK_KHR_bind_memory2") define VK_KHR_BIND_MEMORY2_SPEC_VERSION 1
 @extension("VK_KHR_bind_memory2") define VK_KHR_BIND_MEMORY2_EXTENSION_NAME "VK_KHR_bind_memory2"

 // 161
 @extension("VK_EXT_validation_cache") define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
 @extension("VK_EXT_validation_cache") define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"

 // 162
 @extension("VK_EXT_descriptor_indexing") define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2
 @extension("VK_EXT_descriptor_indexing") define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing"

 // 163
 @extension("VK_EXT_shader_viewport_index_layer") define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
 @extension("VK_EXT_shader_viewport_index_layer") define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"

 // 165
 @extension("VK_NV_shading_rate_image") define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3
 @extension("VK_NV_shading_rate_image") define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"

 // 166
 @extension("VK_NVX_raytracing") define VK_NVX_RAYTRACING_SPEC_VERSION 1
 @extension("VK_NVX_raytracing") define VK_NVX_RAYTRACING_EXTENSION_NAME "VK_NVX_raytracing"

 // 167
 @extension("VK_NV_representative_fragment_test") define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 1
 @extension("VK_NV_representative_fragment_test") define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"

 // 169
 @extension("VK_KHR_maintenance3") define VK_KHR_MAINTENANCE3_SPEC_VERSION 1
 @extension("VK_KHR_maintenance3") define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3"

 // 170
 @extension("VK_KHR_draw_indirect_count") define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
 @extension("VK_KHR_draw_indirect_count") define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count"

 // 175
 @extension("VK_EXT_global_priority") define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 1
 @extension("VK_EXT_global_priority") define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"

 // 178
 @extension("VK_KHR_8bit_storage") define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1
 @extension("VK_KHR_8bit_storage") define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"

 // 179
 @extension("VK_EXT_external_memory_host") define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
 @extension("VK_EXT_external_memory_host") define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"

 // 180
 @extension("VK_AMD_buffer_marker") define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1
 @extension("VK_AMD_buffer_marker") define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker"

 // 181
 @extension("VK_KHR_shader_atomic_int64") define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1
 @extension("VK_KHR_shader_atomic_int64") define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"

 // 186
 @extension("VK_AMD_shader_core_properties") define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1
 @extension("VK_AMD_shader_core_properties") define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"

 // 191
 @extension("VK_EXT_vertex_attribute_divisor") define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 2
 @extension("VK_EXT_vertex_attribute_divisor") define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"

 // 197
 @extension("VK_KHR_driver_properties") define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1
 @extension("VK_KHR_driver_properties") define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties"

 // 199
 @extension("VK_NV_shader_subgroup_partitioned") define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1
 @extension("VK_NV_shader_subgroup_partitioned") define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"

 // 202
 @extension("VK_NV_compute_shader_derivatives") define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1
 @extension("VK_NV_compute_shader_derivatives") define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"

 // 203
 @extension("VK_NV_mesh_shader") define VK_NV_MESH_SHADER_SPEC_VERSION 1
 @extension("VK_NV_mesh_shader") define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader"

 // 204
 @extension("VK_NV_fragment_shader_barycentric") define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1
 @extension("VK_NV_fragment_shader_barycentric") define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric"

 // 205
 @extension("VK_NV_shader_image_footprint") define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 1
 @extension("VK_NV_shader_image_footprint") define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"

 // 206
 @extension("VK_NV_scissor_exclusive") define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1
 @extension("VK_NV_scissor_exclusive") define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"

 // 207
 @extension("VK_NV_device_diagnostic_checkpoints") define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2
 @extension("VK_NV_device_diagnostic_checkpoints") define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints"

 // 212
 @extension("VK_KHR_vulkan_memory_model") define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 2
 @extension("VK_KHR_vulkan_memory_model") define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model"

 /////////////
 //  Types  //
 /////////////

 type u32 VkBool32
 type u32 VkFlags
 type u64 VkDeviceSize
 type u32 VkSampleMask

 /// Dispatchable handle types.
 @dispatchHandle type u64 VkInstance
 @dispatchHandle type u64 VkPhysicalDevice
 @dispatchHandle type u64 VkDevice
 @dispatchHandle type u64 VkQueue
 @dispatchHandle type u64 VkCommandBuffer

 /// Non dispatchable handle types.
 @nonDispatchHandle type u64 VkDeviceMemory
 @nonDispatchHandle type u64 VkCommandPool
 @nonDispatchHandle type u64 VkBuffer
 @nonDispatchHandle type u64 VkBufferView
 @nonDispatchHandle type u64 VkImage
 @nonDispatchHandle type u64 VkImageView
 @nonDispatchHandle type u64 VkShaderModule
 @nonDispatchHandle type u64 VkPipeline
 @nonDispatchHandle type u64 VkPipelineLayout
 @nonDispatchHandle type u64 VkSampler
 @nonDispatchHandle type u64 VkDescriptorSet
 @nonDispatchHandle type u64 VkDescriptorSetLayout
 @nonDispatchHandle type u64 VkDescriptorPool
 @nonDispatchHandle type u64 VkFence
 @nonDispatchHandle type u64 VkSemaphore
 @nonDispatchHandle type u64 VkEvent
 @nonDispatchHandle type u64 VkQueryPool
 @nonDispatchHandle type u64 VkFramebuffer
 @nonDispatchHandle type u64 VkRenderPass
 @nonDispatchHandle type u64 VkPipelineCache

 @vulkan1_1
 @nonDispatchHandle type u64 VkSamplerYcbcrConversion
 @nonDispatchHandle type u64 VkDescriptorUpdateTemplate

 // 1
 @extension("VK_KHR_surface")    @nonDispatchHandle type u64 VkSurfaceKHR

 // 2
 @extension("VK_KHR_swapchain")  @nonDispatchHandle type u64 VkSwapchainKHR

 // 3
 @extension("VK_KHR_display")    @nonDispatchHandle type u64 VkDisplayKHR
 @extension("VK_KHR_display")    @nonDispatchHandle type u64 VkDisplayModeKHR

 // 12
 @extension("VK_EXT_debug_report") @nonDispatchHandle type u64 VkDebugReportCallbackEXT

 // 86
 @extension("VK_KHR_descriptor_update_template") @nonDispatchHandle type u64 VkDescriptorUpdateTemplateKHR

 // 87
 @extension("VK_NVX_device_generated_commands") @nonDispatchHandle type u64 VkObjectTableNVX
 @extension("VK_NVX_device_generated_commands") @nonDispatchHandle type u64 VkIndirectCommandsLayoutNVX

 // 129
 @extension("VK_EXT_debug_utils") @nonDispatchHandle type u64 VkDebugUtilsMessengerEXT

 // 157
 @extension("VK_KHR_sampler_ycbcr_conversion") @nonDispatchHandle type u64 VkSamplerYcbcrConversionKHR

 // 161
 @extension("VK_EXT_validation_cache") @nonDispatchHandle type u64 VkValidationCacheEXT

 // 166
 @extension("VK_NVX_raytracing") @nonDispatchHandle type u64 VkAccelerationStructureNVX

 /////////////
 //  Enums  //
 /////////////

 enum VkImageLayout {
     VK_IMAGE_LAYOUT_UNDEFINED                               = 0x00000000,   /// Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
     VK_IMAGE_LAYOUT_GENERAL                                 = 0x00000001,   /// General layout when image can be used for any kind of access
     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                = 0x00000002,   /// Optimal layout when image is only used for color attachment read/write
     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL        = 0x00000003,   /// Optimal layout when image is only used for depth/stencil attachment read/write
     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL         = 0x00000004,   /// Optimal layout when image is used for read only depth/stencil attachment and shader access
     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL                = 0x00000005,   /// Optimal layout when image is used for read only shader access
     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL                    = 0x00000006,   /// Optimal layout when image is used only as source of transfer operations
     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL                    = 0x00000007,   /// Optimal layout when image is used only as destination of transfer operations
     VK_IMAGE_LAYOUT_PREINITIALIZED                          = 0x00000008,   /// Initial layout used when the data is populated by the CPU

     //@vulkan1_1
     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,

     //@extension("VK_KHR_swapchain") // 2
     VK_IMAGE_LAYOUT_PRESENT_SRC_KHR                         = 1000001002,

     //@extension("VK_KHR_shared_presentable_image") // 112
     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR                      = 1000111000,

     //@extension("VK_KHR_maintenance2") // 118
     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR  = 1000117000,
     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR  = 1000117001,

     //@extension("VK_NV_shading_rate_image") // 165
     VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV                 = 1000164003,
 }

 enum VkAttachmentLoadOp {
     VK_ATTACHMENT_LOAD_OP_LOAD                              = 0x00000000,
     VK_ATTACHMENT_LOAD_OP_CLEAR                             = 0x00000001,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE                         = 0x00000002,
 }

 enum VkAttachmentStoreOp {
     VK_ATTACHMENT_STORE_OP_STORE                            = 0x00000000,
     VK_ATTACHMENT_STORE_OP_DONT_CARE                        = 0x00000001,
 }

 enum VkImageType {
     VK_IMAGE_TYPE_1D                                        = 0x00000000,
     VK_IMAGE_TYPE_2D                                        = 0x00000001,
     VK_IMAGE_TYPE_3D                                        = 0x00000002,
 }

 enum VkImageTiling {
     VK_IMAGE_TILING_OPTIMAL                                 = 0x00000000,
     VK_IMAGE_TILING_LINEAR                                  = 0x00000001,
 }

 enum VkImageViewType {
     VK_IMAGE_VIEW_TYPE_1D                                   = 0x00000000,
     VK_IMAGE_VIEW_TYPE_2D                                   = 0x00000001,
     VK_IMAGE_VIEW_TYPE_3D                                   = 0x00000002,
     VK_IMAGE_VIEW_TYPE_CUBE                                 = 0x00000003,
     VK_IMAGE_VIEW_TYPE_1D_ARRAY                             = 0x00000004,
     VK_IMAGE_VIEW_TYPE_2D_ARRAY                             = 0x00000005,
     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY                           = 0x00000006,
 }

 enum VkCommandBufferLevel {
     VK_COMMAND_BUFFER_LEVEL_PRIMARY                         = 0x00000000,
     VK_COMMAND_BUFFER_LEVEL_SECONDARY                       = 0x00000001,
 }

 enum VkComponentSwizzle {
     VK_COMPONENT_SWIZZLE_IDENTITY                           = 0x00000000,
     VK_COMPONENT_SWIZZLE_ZERO                               = 0x00000001,
     VK_COMPONENT_SWIZZLE_ONE                                = 0x00000002,
     VK_COMPONENT_SWIZZLE_R                                  = 0x00000003,
     VK_COMPONENT_SWIZZLE_G                                  = 0x00000004,
     VK_COMPONENT_SWIZZLE_B                                  = 0x00000005,
     VK_COMPONENT_SWIZZLE_A                                  = 0x00000006,
 }

 enum VkDescriptorType {
     VK_DESCRIPTOR_TYPE_SAMPLER                              = 0x00000000,
     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER               = 0x00000001,
     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE                        = 0x00000002,
     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE                        = 0x00000003,
     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER                 = 0x00000004,
     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER                 = 0x00000005,
     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER                       = 0x00000006,
     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER                       = 0x00000007,
     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC               = 0x00000008,
     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC               = 0x00000009,
     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT                     = 0x0000000a,

     //@extension("VK_EXT_inline_uniform_block") // 139
     VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT             = 1000138000,

     //@extension("VK_NVX_raytracing") // 166
     VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NVX           = 1000165000,
 }

 enum VkQueryType {
     VK_QUERY_TYPE_OCCLUSION                                 = 0x00000000,
     VK_QUERY_TYPE_PIPELINE_STATISTICS                       = 0x00000001, /// Optional
     VK_QUERY_TYPE_TIMESTAMP                                 = 0x00000002,

     //@extension("VK_NVX_raytracing") // 166
     VK_QUERY_TYPE_COMPACTED_SIZE_NVX                        = 1000165000,
 }

 enum VkBorderColor {
     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK                 = 0x00000000,
     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK                   = 0x00000001,
     VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK                      = 0x00000002,
     VK_BORDER_COLOR_INT_OPAQUE_BLACK                        = 0x00000003,
     VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE                      = 0x00000004,
     VK_BORDER_COLOR_INT_OPAQUE_WHITE                        = 0x00000005,
 }

 enum VkPipelineBindPoint {
     VK_PIPELINE_BIND_POINT_GRAPHICS                         = 0x00000000,
     VK_PIPELINE_BIND_POINT_COMPUTE                          = 0x00000001,

     //@extension("VK_NVX_raytracing") // 166
     VK_PIPELINE_BIND_POINT_RAYTRACING_NVX                   = 1000165000,
 }

 enum VkPrimitiveTopology {
     VK_PRIMITIVE_TOPOLOGY_POINT_LIST                        = 0x00000000,
     VK_PRIMITIVE_TOPOLOGY_LINE_LIST                         = 0x00000001,
     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP                        = 0x00000002,
     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST                     = 0x00000003,
     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP                    = 0x00000004,
     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN                      = 0x00000005,
     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY          = 0x00000006,
     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY         = 0x00000007,
     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY      = 0x00000008,
     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY     = 0x00000009,
     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST                        = 0x0000000a,
 }

 enum VkSharingMode {
     VK_SHARING_MODE_EXCLUSIVE                               = 0x00000000,
     VK_SHARING_MODE_CONCURRENT                              = 0x00000001,
 }

 enum VkIndexType {
     VK_INDEX_TYPE_UINT16                                    = 0x00000000,
     VK_INDEX_TYPE_UINT32                                    = 0x00000001,
 }

 enum VkFilter {
     VK_FILTER_NEAREST                                       = 0x00000000,
     VK_FILTER_LINEAR                                        = 0x00000001,

     //@extension("VK_IMG_filter_cubic") // 16
     VK_FILTER_CUBIC_IMG                                     = 1000015000,
 }

 enum VkSamplerMipmapMode {
     VK_SAMPLER_MIPMAP_MODE_NEAREST                          = 0x00000001,   /// Choose nearest mip level
     VK_SAMPLER_MIPMAP_MODE_LINEAR                           = 0x00000002,   /// Linear filter between mip levels
 }

 enum VkSamplerAddressMode {
     VK_SAMPLER_ADDRESS_MODE_REPEAT                          = 0x00000000,
     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT                 = 0x00000001,
     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE                   = 0x00000002,
     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER                 = 0x00000003,
     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE            = 0x00000004,
 }

 enum VkCompareOp {
     VK_COMPARE_OP_NEVER                                     = 0x00000000,
     VK_COMPARE_OP_LESS                                      = 0x00000001,
     VK_COMPARE_OP_EQUAL                                     = 0x00000002,
     VK_COMPARE_OP_LESS_OR_EQUAL                             = 0x00000003,
     VK_COMPARE_OP_GREATER                                   = 0x00000004,
     VK_COMPARE_OP_NOT_EQUAL                                 = 0x00000005,
     VK_COMPARE_OP_GREATER_OR_EQUAL                          = 0x00000006,
     VK_COMPARE_OP_ALWAYS                                    = 0x00000007,
 }

 enum VkPolygonMode {
     VK_POLYGON_MODE_FILL                                    = 0x00000000,
     VK_POLYGON_MODE_LINE                                    = 0x00000001,
     VK_POLYGON_MODE_POINT                                   = 0x00000002,

     //@extension("VK_NV_fill_rectangle") // 154
     VK_POLYGON_MODE_FILL_RECTANGLE_NV                       = 1000153000,
 }

 enum VkFrontFace {
     VK_FRONT_FACE_COUNTER_CLOCKWISE                         = 0x00000000,
     VK_FRONT_FACE_CLOCKWISE                                 = 0x00000001,
 }

 enum VkBlendFactor {
     VK_BLEND_FACTOR_ZERO                                    = 0x00000000,
     VK_BLEND_FACTOR_ONE                                     = 0x00000001,
     VK_BLEND_FACTOR_SRC_COLOR                               = 0x00000002,
     VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR                     = 0x00000003,
     VK_BLEND_FACTOR_DST_COLOR                               = 0x00000004,
     VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR                     = 0x00000005,
     VK_BLEND_FACTOR_SRC_ALPHA                               = 0x00000006,
     VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA                     = 0x00000007,
     VK_BLEND_FACTOR_DST_ALPHA                               = 0x00000008,
     VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA                     = 0x00000009,
     VK_BLEND_FACTOR_CONSTANT_COLOR                          = 0x0000000a,
     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR                = 0x0000000b,
     VK_BLEND_FACTOR_CONSTANT_ALPHA                          = 0x0000000c,
     VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA                = 0x0000000d,
     VK_BLEND_FACTOR_SRC_ALPHA_SATURATE                      = 0x0000000e,
     VK_BLEND_FACTOR_SRC1_COLOR                              = 0x0000000f,
     VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR                    = 0x00000010,
     VK_BLEND_FACTOR_SRC1_ALPHA                              = 0x00000011,
     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA                    = 0x00000012,
 }

 enum VkBlendOp {
     VK_BLEND_OP_ADD                                         = 0x00000000,
     VK_BLEND_OP_SUBTRACT                                    = 0x00000001,
     VK_BLEND_OP_REVERSE_SUBTRACT                            = 0x00000002,
     VK_BLEND_OP_MIN                                         = 0x00000003,
     VK_BLEND_OP_MAX                                         = 0x00000004,

     //@extension("VK_EXT_blend_operation_advanced") // 149
     VK_BLEND_OP_ZERO_EXT                                    = 1000148000,
     VK_BLEND_OP_SRC_EXT                                     = 1000148001,
     VK_BLEND_OP_DST_EXT                                     = 1000148002,
     VK_BLEND_OP_SRC_OVER_EXT                                = 1000148003,
     VK_BLEND_OP_DST_OVER_EXT                                = 1000148004,
     VK_BLEND_OP_SRC_IN_EXT                                  = 1000148005,
     VK_BLEND_OP_DST_IN_EXT                                  = 1000148006,
     VK_BLEND_OP_SRC_OUT_EXT                                 = 1000148007,
     VK_BLEND_OP_DST_OUT_EXT                                 = 1000148008,
     VK_BLEND_OP_SRC_ATOP_EXT                                = 1000148009,
     VK_BLEND_OP_DST_ATOP_EXT                                = 1000148010,
     VK_BLEND_OP_XOR_EXT                                     = 1000148011,
     VK_BLEND_OP_MULTIPLY_EXT                                = 1000148012,
     VK_BLEND_OP_SCREEN_EXT                                  = 1000148013,
     VK_BLEND_OP_OVERLAY_EXT                                 = 1000148014,
     VK_BLEND_OP_DARKEN_EXT                                  = 1000148015,
     VK_BLEND_OP_LIGHTEN_EXT                                 = 1000148016,
     VK_BLEND_OP_COLORDODGE_EXT                              = 1000148017,
     VK_BLEND_OP_COLORBURN_EXT                               = 1000148018,
     VK_BLEND_OP_HARDLIGHT_EXT                               = 1000148019,
     VK_BLEND_OP_SOFTLIGHT_EXT                               = 1000148020,
     VK_BLEND_OP_DIFFERENCE_EXT                              = 1000148021,
     VK_BLEND_OP_EXCLUSION_EXT                               = 1000148022,
     VK_BLEND_OP_INVERT_EXT                                  = 1000148023,
     VK_BLEND_OP_INVERT_RGB_EXT                              = 1000148024,
     VK_BLEND_OP_LINEARDODGE_EXT                             = 1000148025,
     VK_BLEND_OP_LINEARBURN_EXT                              = 1000148026,
     VK_BLEND_OP_VIVIDLIGHT_EXT                              = 1000148027,
     VK_BLEND_OP_LINEARLIGHT_EXT                             = 1000148028,
     VK_BLEND_OP_PINLIGHT_EXT                                = 1000148029,
     VK_BLEND_OP_HARDMIX_EXT                                 = 1000148030,
     VK_BLEND_OP_HSL_HUE_EXT                                 = 1000148031,
     VK_BLEND_OP_HSL_SATURATION_EXT                          = 1000148032,
     VK_BLEND_OP_HSL_COLOR_EXT                               = 1000148033,
     VK_BLEND_OP_HSL_LUMINOSITY_EXT                          = 1000148034,
     VK_BLEND_OP_PLUS_EXT                                    = 1000148035,
     VK_BLEND_OP_PLUS_CLAMPED_EXT                            = 1000148036,
     VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT                      = 1000148037,
     VK_BLEND_OP_PLUS_DARKER_EXT                             = 1000148038,
     VK_BLEND_OP_MINUS_EXT                                   = 1000148039,
     VK_BLEND_OP_MINUS_CLAMPED_EXT                           = 1000148040,
     VK_BLEND_OP_CONTRAST_EXT                                = 1000148041,
     VK_BLEND_OP_INVERT_OVG_EXT                              = 1000148042,
     VK_BLEND_OP_RED_EXT                                     = 1000148043,
     VK_BLEND_OP_GREEN_EXT                                   = 1000148044,
     VK_BLEND_OP_BLUE_EXT                                    = 1000148045,
 }

 enum VkStencilOp {
     VK_STENCIL_OP_KEEP                                      = 0x00000000,
     VK_STENCIL_OP_ZERO                                      = 0x00000001,
     VK_STENCIL_OP_REPLACE                                   = 0x00000002,
     VK_STENCIL_OP_INCREMENT_AND_CLAMP                       = 0x00000003,
     VK_STENCIL_OP_DECREMENT_AND_CLAMP                       = 0x00000004,
     VK_STENCIL_OP_INVERT                                    = 0x00000005,
     VK_STENCIL_OP_INCREMENT_AND_WRAP                        = 0x00000006,
     VK_STENCIL_OP_DECREMENT_AND_WRAP                        = 0x00000007,
 }

 enum VkLogicOp {
     VK_LOGIC_OP_CLEAR                                       = 0x00000000,
     VK_LOGIC_OP_AND                                         = 0x00000001,
     VK_LOGIC_OP_AND_REVERSE                                 = 0x00000002,
     VK_LOGIC_OP_COPY                                        = 0x00000003,
     VK_LOGIC_OP_AND_INVERTED                                = 0x00000004,
     VK_LOGIC_OP_NO_OP                                       = 0x00000005,
     VK_LOGIC_OP_XOR                                         = 0x00000006,
     VK_LOGIC_OP_OR                                          = 0x00000007,
     VK_LOGIC_OP_NOR                                         = 0x00000008,
     VK_LOGIC_OP_EQUIVALENT                                  = 0x00000009,
     VK_LOGIC_OP_INVERT                                      = 0x0000000a,
     VK_LOGIC_OP_OR_REVERSE                                  = 0x0000000b,
     VK_LOGIC_OP_COPY_INVERTED                               = 0x0000000c,
     VK_LOGIC_OP_OR_INVERTED                                 = 0x0000000d,
     VK_LOGIC_OP_NAND                                        = 0x0000000e,
     VK_LOGIC_OP_SET                                         = 0x0000000f,
 }

 enum VkSystemAllocationScope {
     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND                      = 0x00000000,
     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT                       = 0x00000001,
     VK_SYSTEM_ALLOCATION_SCOPE_CACHE                        = 0x00000002,
     VK_SYSTEM_ALLOCATION_SCOPE_DEVICE                       = 0x00000003,
     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE                     = 0x00000004,
 }

 enum VkInternalAllocationType {
     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE                  = 0x00000000,
 }

 enum VkPhysicalDeviceType {
     VK_PHYSICAL_DEVICE_TYPE_OTHER                           = 0x00000000,
     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU                  = 0x00000001,
     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU                    = 0x00000002,
     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU                     = 0x00000003,
     VK_PHYSICAL_DEVICE_TYPE_CPU                             = 0x00000004,
 }

 enum VkVertexInputRate {
     VK_VERTEX_INPUT_RATE_VERTEX                             = 0x00000000,
     VK_VERTEX_INPUT_RATE_INSTANCE                           = 0x00000001,
 }

 /// Vulkan format definitions
 enum VkFormat {
     VK_FORMAT_UNDEFINED                                     = 0,
     VK_FORMAT_R4G4_UNORM_PACK8                              = 1,
     VK_FORMAT_R4G4B4A4_UNORM_PACK16                         = 2,
     VK_FORMAT_B4G4R4A4_UNORM_PACK16                         = 3,
     VK_FORMAT_R5G6B5_UNORM_PACK16                           = 4,
     VK_FORMAT_B5G6R5_UNORM_PACK16                           = 5,
     VK_FORMAT_R5G5B5A1_UNORM_PACK16                         = 6,
     VK_FORMAT_B5G5R5A1_UNORM_PACK16                         = 7,
     VK_FORMAT_A1R5G5B5_UNORM_PACK16                         = 8,
     VK_FORMAT_R8_UNORM                                      = 9,
     VK_FORMAT_R8_SNORM                                      = 10,
     VK_FORMAT_R8_USCALED                                    = 11,
     VK_FORMAT_R8_SSCALED                                    = 12,
     VK_FORMAT_R8_UINT                                       = 13,
     VK_FORMAT_R8_SINT                                       = 14,
     VK_FORMAT_R8_SRGB                                       = 15,
     VK_FORMAT_R8G8_UNORM                                    = 16,
     VK_FORMAT_R8G8_SNORM                                    = 17,
     VK_FORMAT_R8G8_USCALED                                  = 18,
     VK_FORMAT_R8G8_SSCALED                                  = 19,
     VK_FORMAT_R8G8_UINT                                     = 20,
     VK_FORMAT_R8G8_SINT                                     = 21,
     VK_FORMAT_R8G8_SRGB                                     = 22,
     VK_FORMAT_R8G8B8_UNORM                                  = 23,
     VK_FORMAT_R8G8B8_SNORM                                  = 24,
     VK_FORMAT_R8G8B8_USCALED                                = 25,
     VK_FORMAT_R8G8B8_SSCALED                                = 26,
     VK_FORMAT_R8G8B8_UINT                                   = 27,
     VK_FORMAT_R8G8B8_SINT                                   = 28,
     VK_FORMAT_R8G8B8_SRGB                                   = 29,
     VK_FORMAT_B8G8R8_UNORM                                  = 30,
     VK_FORMAT_B8G8R8_SNORM                                  = 31,
     VK_FORMAT_B8G8R8_USCALED                                = 32,
     VK_FORMAT_B8G8R8_SSCALED                                = 33,
     VK_FORMAT_B8G8R8_UINT                                   = 34,
     VK_FORMAT_B8G8R8_SINT                                   = 35,
     VK_FORMAT_B8G8R8_SRGB                                   = 36,
     VK_FORMAT_R8G8B8A8_UNORM                                = 37,
     VK_FORMAT_R8G8B8A8_SNORM                                = 38,
     VK_FORMAT_R8G8B8A8_USCALED                              = 39,
     VK_FORMAT_R8G8B8A8_SSCALED                              = 40,
     VK_FORMAT_R8G8B8A8_UINT                                 = 41,
     VK_FORMAT_R8G8B8A8_SINT                                 = 42,
     VK_FORMAT_R8G8B8A8_SRGB                                 = 43,
     VK_FORMAT_B8G8R8A8_UNORM                                = 44,
     VK_FORMAT_B8G8R8A8_SNORM                                = 45,
     VK_FORMAT_B8G8R8A8_USCALED                              = 46,
     VK_FORMAT_B8G8R8A8_SSCALED                              = 47,
     VK_FORMAT_B8G8R8A8_UINT                                 = 48,
     VK_FORMAT_B8G8R8A8_SINT                                 = 49,
     VK_FORMAT_B8G8R8A8_SRGB                                 = 50,
     VK_FORMAT_A8B8G8R8_UNORM_PACK32                         = 51,
     VK_FORMAT_A8B8G8R8_SNORM_PACK32                         = 52,
     VK_FORMAT_A8B8G8R8_USCALED_PACK32                       = 53,
     VK_FORMAT_A8B8G8R8_SSCALED_PACK32                       = 54,
     VK_FORMAT_A8B8G8R8_UINT_PACK32                          = 55,
     VK_FORMAT_A8B8G8R8_SINT_PACK32                          = 56,
     VK_FORMAT_A8B8G8R8_SRGB_PACK32                          = 57,
     VK_FORMAT_A2R10G10B10_UNORM_PACK32                      = 58,
     VK_FORMAT_A2R10G10B10_SNORM_PACK32                      = 59,
     VK_FORMAT_A2R10G10B10_USCALED_PACK32                    = 60,
     VK_FORMAT_A2R10G10B10_SSCALED_PACK32                    = 61,
     VK_FORMAT_A2R10G10B10_UINT_PACK32                       = 62,
     VK_FORMAT_A2R10G10B10_SINT_PACK32                       = 63,
     VK_FORMAT_A2B10G10R10_UNORM_PACK32                      = 64,
     VK_FORMAT_A2B10G10R10_SNORM_PACK32                      = 65,
     VK_FORMAT_A2B10G10R10_USCALED_PACK32                    = 66,
     VK_FORMAT_A2B10G10R10_SSCALED_PACK32                    = 67,
     VK_FORMAT_A2B10G10R10_UINT_PACK32                       = 68,
     VK_FORMAT_A2B10G10R10_SINT_PACK32                       = 69,
     VK_FORMAT_R16_UNORM                                     = 70,
     VK_FORMAT_R16_SNORM                                     = 71,
     VK_FORMAT_R16_USCALED                                   = 72,
     VK_FORMAT_R16_SSCALED                                   = 73,
     VK_FORMAT_R16_UINT                                      = 74,
     VK_FORMAT_R16_SINT                                      = 75,
     VK_FORMAT_R16_SFLOAT                                    = 76,
     VK_FORMAT_R16G16_UNORM                                  = 77,
     VK_FORMAT_R16G16_SNORM                                  = 78,
     VK_FORMAT_R16G16_USCALED                                = 79,
     VK_FORMAT_R16G16_SSCALED                                = 80,
     VK_FORMAT_R16G16_UINT                                   = 81,
     VK_FORMAT_R16G16_SINT                                   = 82,
     VK_FORMAT_R16G16_SFLOAT                                 = 83,
     VK_FORMAT_R16G16B16_UNORM                               = 84,
     VK_FORMAT_R16G16B16_SNORM                               = 85,
     VK_FORMAT_R16G16B16_USCALED                             = 86,
     VK_FORMAT_R16G16B16_SSCALED                             = 87,
     VK_FORMAT_R16G16B16_UINT                                = 88,
     VK_FORMAT_R16G16B16_SINT                                = 89,
     VK_FORMAT_R16G16B16_SFLOAT                              = 90,
     VK_FORMAT_R16G16B16A16_UNORM                            = 91,
     VK_FORMAT_R16G16B16A16_SNORM                            = 92,
     VK_FORMAT_R16G16B16A16_USCALED                          = 93,
     VK_FORMAT_R16G16B16A16_SSCALED                          = 94,
     VK_FORMAT_R16G16B16A16_UINT                             = 95,
     VK_FORMAT_R16G16B16A16_SINT                             = 96,
     VK_FORMAT_R16G16B16A16_SFLOAT                           = 97,
     VK_FORMAT_R32_UINT                                      = 98,
     VK_FORMAT_R32_SINT                                      = 99,
     VK_FORMAT_R32_SFLOAT                                    = 100,
     VK_FORMAT_R32G32_UINT                                   = 101,
     VK_FORMAT_R32G32_SINT                                   = 102,
     VK_FORMAT_R32G32_SFLOAT                                 = 103,
     VK_FORMAT_R32G32B32_UINT                                = 104,
     VK_FORMAT_R32G32B32_SINT                                = 105,
     VK_FORMAT_R32G32B32_SFLOAT                              = 106,
     VK_FORMAT_R32G32B32A32_UINT                             = 107,
     VK_FORMAT_R32G32B32A32_SINT                             = 108,
     VK_FORMAT_R32G32B32A32_SFLOAT                           = 109,
     VK_FORMAT_R64_UINT                                      = 110,
     VK_FORMAT_R64_SINT                                      = 111,
     VK_FORMAT_R64_SFLOAT                                    = 112,
     VK_FORMAT_R64G64_UINT                                   = 113,
     VK_FORMAT_R64G64_SINT                                   = 114,
     VK_FORMAT_R64G64_SFLOAT                                 = 115,
     VK_FORMAT_R64G64B64_UINT                                = 116,
     VK_FORMAT_R64G64B64_SINT                                = 117,
     VK_FORMAT_R64G64B64_SFLOAT                              = 118,
     VK_FORMAT_R64G64B64A64_UINT                             = 119,
     VK_FORMAT_R64G64B64A64_SINT                             = 120,
     VK_FORMAT_R64G64B64A64_SFLOAT                           = 121,
     VK_FORMAT_B10G11R11_UFLOAT_PACK32                       = 122,
     VK_FORMAT_E5B9G9R9_UFLOAT_PACK32                        = 123,
     VK_FORMAT_D16_UNORM                                     = 124,
     VK_FORMAT_X8_D24_UNORM_PACK32                           = 125,
     VK_FORMAT_D32_SFLOAT                                    = 126,
     VK_FORMAT_S8_UINT                                       = 127,
     VK_FORMAT_D16_UNORM_S8_UINT                             = 128,
     VK_FORMAT_D24_UNORM_S8_UINT                             = 129,
     VK_FORMAT_D32_SFLOAT_S8_UINT                            = 130,
     VK_FORMAT_BC1_RGB_UNORM_BLOCK                           = 131,
     VK_FORMAT_BC1_RGB_SRGB_BLOCK                            = 132,
     VK_FORMAT_BC1_RGBA_UNORM_BLOCK                          = 133,
     VK_FORMAT_BC1_RGBA_SRGB_BLOCK                           = 134,
     VK_FORMAT_BC2_UNORM_BLOCK                               = 135,
     VK_FORMAT_BC2_SRGB_BLOCK                                = 136,
     VK_FORMAT_BC3_UNORM_BLOCK                               = 137,
     VK_FORMAT_BC3_SRGB_BLOCK                                = 138,
     VK_FORMAT_BC4_UNORM_BLOCK                               = 139,
     VK_FORMAT_BC4_SNORM_BLOCK                               = 140,
     VK_FORMAT_BC5_UNORM_BLOCK                               = 141,
     VK_FORMAT_BC5_SNORM_BLOCK                               = 142,
     VK_FORMAT_BC6H_UFLOAT_BLOCK                             = 143,
     VK_FORMAT_BC6H_SFLOAT_BLOCK                             = 144,
     VK_FORMAT_BC7_UNORM_BLOCK                               = 145,
     VK_FORMAT_BC7_SRGB_BLOCK                                = 146,
     VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK                       = 147,
     VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK                        = 148,
     VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK                     = 149,
     VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK                      = 150,
     VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK                     = 151,
     VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK                      = 152,
     VK_FORMAT_EAC_R11_UNORM_BLOCK                           = 153,
     VK_FORMAT_EAC_R11_SNORM_BLOCK                           = 154,
     VK_FORMAT_EAC_R11G11_UNORM_BLOCK                        = 155,
     VK_FORMAT_EAC_R11G11_SNORM_BLOCK                        = 156,
     VK_FORMAT_ASTC_4x4_UNORM_BLOCK                          = 157,
     VK_FORMAT_ASTC_4x4_SRGB_BLOCK                           = 158,
     VK_FORMAT_ASTC_5x4_UNORM_BLOCK                          = 159,
     VK_FORMAT_ASTC_5x4_SRGB_BLOCK                           = 160,
     VK_FORMAT_ASTC_5x5_UNORM_BLOCK                          = 161,
     VK_FORMAT_ASTC_5x5_SRGB_BLOCK                           = 162,
     VK_FORMAT_ASTC_6x5_UNORM_BLOCK                          = 163,
     VK_FORMAT_ASTC_6x5_SRGB_BLOCK                           = 164,
     VK_FORMAT_ASTC_6x6_UNORM_BLOCK                          = 165,
     VK_FORMAT_ASTC_6x6_SRGB_BLOCK                           = 166,
     VK_FORMAT_ASTC_8x5_UNORM_BLOCK                          = 167,
     VK_FORMAT_ASTC_8x5_SRGB_BLOCK                           = 168,
     VK_FORMAT_ASTC_8x6_UNORM_BLOCK                          = 169,
     VK_FORMAT_ASTC_8x6_SRGB_BLOCK                           = 170,
     VK_FORMAT_ASTC_8x8_UNORM_BLOCK                          = 171,
     VK_FORMAT_ASTC_8x8_SRGB_BLOCK                           = 172,
     VK_FORMAT_ASTC_10x5_UNORM_BLOCK                         = 173,
     VK_FORMAT_ASTC_10x5_SRGB_BLOCK                          = 174,
     VK_FORMAT_ASTC_10x6_UNORM_BLOCK                         = 175,
     VK_FORMAT_ASTC_10x6_SRGB_BLOCK                          = 176,
     VK_FORMAT_ASTC_10x8_UNORM_BLOCK                         = 177,
     VK_FORMAT_ASTC_10x8_SRGB_BLOCK                          = 178,
     VK_FORMAT_ASTC_10x10_UNORM_BLOCK                        = 179,
     VK_FORMAT_ASTC_10x10_SRGB_BLOCK                         = 180,
     VK_FORMAT_ASTC_12x10_UNORM_BLOCK                        = 181,
     VK_FORMAT_ASTC_12x10_SRGB_BLOCK                         = 182,
     VK_FORMAT_ASTC_12x12_UNORM_BLOCK                        = 183,
     VK_FORMAT_ASTC_12x12_SRGB_BLOCK                         = 184,

     //@vulkan1_1
     VK_FORMAT_G8B8G8R8_422_UNORM                            = 1000156000,
     VK_FORMAT_B8G8R8G8_422_UNORM                            = 1000156001,
     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM                     = 1000156002,
     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM                      = 1000156003,
     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM                     = 1000156004,
     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM                      = 1000156005,
     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM                     = 1000156006,
     VK_FORMAT_R10X6_UNORM_PACK16                            = 1000156007,
     VK_FORMAT_R10X6G10X6_UNORM_2PACK16                      = 1000156008,
     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16            = 1000156009,
     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16        = 1000156010,
     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16        = 1000156011,
     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16    = 1000156012,
     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16     = 1000156013,
     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16    = 1000156014,
     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16     = 1000156015,
     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16    = 1000156016,
     VK_FORMAT_R12X4_UNORM_PACK16                            = 1000156017,
     VK_FORMAT_R12X4G12X4_UNORM_2PACK16                      = 1000156018,
     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16            = 1000156019,
     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16        = 1000156020,
     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16        = 1000156021,
     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16    = 1000156022,
     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16     = 1000156023,
     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16    = 1000156024,
     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16     = 1000156025,
     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16    = 1000156026,
     VK_FORMAT_G16B16G16R16_422_UNORM                        = 1000156027,
     VK_FORMAT_B16G16R16G16_422_UNORM                        = 1000156028,
     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM                  = 1000156029,
     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM                   = 1000156030,
     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM                  = 1000156031,
     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM                   = 1000156032,
     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM                  = 1000156033,

     //@extension("VK_IMG_format_pvrtc") // 28
     VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG                   = 1000054000,
     VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG                   = 1000054001,
     VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG                   = 1000054002,
     VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG                   = 1000054003,
     VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG                    = 1000054004,
     VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG                    = 1000054005,
     VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG                    = 1000054006,
     VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG                    = 1000054007,

     //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
     VK_FORMAT_G8B8G8R8_422_UNORM_KHR                            = 1000156000,
     VK_FORMAT_B8G8R8G8_422_UNORM_KHR                            = 1000156001,
     VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR                     = 1000156002,
     VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR                      = 1000156003,
     VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR                     = 1000156004,
     VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR                      = 1000156005,
     VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR                     = 1000156006,
     VK_FORMAT_R10X6_UNORM_PACK16_KHR                            = 1000156007,
     VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR                      = 1000156008,
     VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR            = 1000156009,
     VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR        = 1000156010,
     VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR        = 1000156011,
     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR    = 1000156012,
     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR     = 1000156013,
     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR    = 1000156014,
     VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR     = 1000156015,
     VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR    = 1000156016,
     VK_FORMAT_R12X4_UNORM_PACK16_KHR                            = 1000156017,
     VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR                      = 1000156018,
     VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR            = 1000156019,
     VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR        = 1000156020,
     VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR        = 1000156021,
     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR    = 1000156022,
     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR     = 1000156023,
     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR    = 1000156024,
     VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR     = 1000156025,
     VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR    = 1000156026,
     VK_FORMAT_G16B16G16R16_422_UNORM_KHR                        = 1000156027,
     VK_FORMAT_B16G16R16G16_422_UNORM_KHR                        = 1000156028,
     VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR                  = 1000156029,
     VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR                   = 1000156030,
     VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR                  = 1000156031,
     VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR                   = 1000156032,
     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR                  = 1000156033,
 }

 /// Structure type enumerant
 enum VkStructureType {
     VK_STRUCTURE_TYPE_APPLICATION_INFO                          = 0,
     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO                      = 1,
     VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO                  = 2,
     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO                        = 3,
     VK_STRUCTURE_TYPE_SUBMIT_INFO                               = 4,
     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO                      = 5,
     VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE                       = 6,
     VK_STRUCTURE_TYPE_BIND_SPARSE_INFO                          = 7,
     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO                         = 8,
     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO                     = 9,
     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO                         = 10,
     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO                    = 11,
     VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO                        = 12,
     VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO                   = 13,
     VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO                         = 14,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO                    = 15,
     VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO                 = 16,
     VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO                = 17,
     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO         = 18,
     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO   = 19,
     VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO   = 21,
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO       = 22,
     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO  = 23,
     VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO    = 24,
     VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO  = 25,
     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO    = 26,
     VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO        = 27,
     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO             = 28,
     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO              = 29,
     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO               = 30,
     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO                       = 31,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO         = 32,
     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO               = 33,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO              = 34,
     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET                      = 35,
     VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET                       = 36,
     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO                   = 37,
     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO                   = 38,
     VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO                  = 39,
     VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO              = 40,
     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO           = 41,
     VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO                 = 42,
     VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO                    = 43,
     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER                     = 44,
     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER                      = 45,
     VK_STRUCTURE_TYPE_MEMORY_BARRIER                            = 46,
     VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO               = 47,
     VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO                 = 48,

     //@vulkan1_1
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES       = 1000094000,
     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO                   = 1000157000,
     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO                    = 1000157001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES    = 1000083000,
     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS             = 1000127000,
     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO            = 1000127001,
     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO                = 1000060000,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO       = 1000060003,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO    = 1000060004,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO                  = 1000060005,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO             = 1000060006,
     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO      = 1000060013,
     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO       = 1000060014,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES          = 1000070000,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO           = 1000070001,
     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2         = 1000146000,
     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2          = 1000146001,
     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2   = 1000146002,
     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2                     = 1000146003,
     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2        = 1000146004,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2                = 1000059000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2              = 1000059001,
     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2                       = 1000059002,
     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2                 = 1000059003,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2       = 1000059004,
     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2                 = 1000059005,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2       = 1000059006,
     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2          = 1000059007,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2            = 1000059008,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES             = 1000117000,
     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO       = 1000117001,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO                          = 1000117002,
     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,
     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO                 = 1000053000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES                = 1000053001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES              = 1000053002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES         = 1000120000,
     VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO                             = 1000145000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES         = 1000145001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES       = 1000145002,
     VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2                               = 1000145003,
     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO              = 1000156000,
     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO                     = 1000156001,
     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO                      = 1000156002,
     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO              = 1000156003,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES  = 1000156005,
     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO            = 1000085000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO        = 1000071000,
     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES                  = 1000071001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO              = 1000071002,
     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES                        = 1000071003,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES                     = 1000071004,
     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO                = 1000072000,
     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO                 = 1000072001,
     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO                       = 1000072002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO               = 1000112000,
     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES                         = 1000112001,
     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO                          = 1000113000,
     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO                      = 1000077000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO           = 1000076000,
     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES                     = 1000076001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES          = 1000168000,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT                     = 1000168001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES    = 1000063000,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR             = 1000060007,

     //@extension("VK_KHR_swapchain") // 2
     VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR                 = 1000001000,
     VK_STRUCTURE_TYPE_PRESENT_INFO_KHR                          = 1000001001,
     // added as interaction from VK_KHR_device_group / VK 1.1
     VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR           = 1000060008,
     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR      = 1000060009,
     VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR               = 1000060010,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR             = 1000060011,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR    = 1000060012,

     //@extension("VK_KHR_display") // 3
     VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR              = 1000002000,
     VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR           = 1000002001,

     //@extension("VK_KHR_display_swapchain") // 4
     VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR          = 1000003000,

     //@extension("VK_KHR_xlib_surface") // 5
     VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR              = 1000004000,

     //@extension("VK_KHR_xcb_surface") // 6
     VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR               = 1000005000,

     //@extension("VK_KHR_wayland_surface") // 7
     VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR           = 1000006000,

     //@extension("VK_KHR_mir_surface") // 8
     VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR               = 1000007000,

     //@extension("VK_KHR_android_surface") // 9
     VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR           = 1000008000,

     //@extension("VK_KHR_win32_surface") // 10
     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR             = 1000009000,

     //@extension("VK_ANDROID_native_buffer") // 11
     VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID                     = 1000010000,
     VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID       = 1000010001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID = 1000010002,

     //@extension("VK_EXT_debug_report") // 12
     VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT     = 1000011000,

     //@extension("VK_AMD_rasterization_order") // 19
     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,

     //@extension("VK_EXT_debug_marker") // 23
     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT         = 1000022000,
     VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT          = 1000022001,
     VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT              = 1000022002,

     //@extension("VK_NV_dedicated_allocation") // 27
     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
     VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,

     //@extension("VK_AMD_texture_gather_bias_lod") // 42
     VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD  = 1000041000,

     //@extension("VK_NV_corner_sampled_image") // 51
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV  = 1000050000,

     //@extension("VK_KHR_multiview") // 54
     VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR     = 1000053000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR    = 1000053001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR  = 1000053002,

     //@extension("VK_NV_external_memory") // 57
     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV      = 1000056000,
     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV            = 1000056001,

     //@extension("VK_NV_external_memory_win32") // 58
     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV        = 1000057000,
     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV        = 1000057001,

     //@extension("VK_NV_win32_keyed_mutex") // 59
     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,

     //@extension("VK_KHR_get_physical_device_properties2") // 60
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR            = 1000059000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR          = 1000059001,
     VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR                   = 1000059002,
     VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR             = 1000059003,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR   = 1000059004,
     VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR             = 1000059005,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR   = 1000059006,
     VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR      = 1000059007,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,

     //@extension("VK_KHR_device_group") // 61
     VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR            = 1000060000,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR   = 1000060003,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = 1000060004,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR              = 1000060005,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR         = 1000060006,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR     = 1000060007,
     // tokens 08-12 are listed with VK_KHR_swapchain
     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR  = 1000060013,
     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR   = 1000060014,

     //@extension("VK_EXT_validation_flags") // 62
     VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT                      = 1000061000,

     //@extension("VK_NN_vi_surface") // 63
     VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN                 = 1000062000,

     //@extension("VK_EXT_astc_decode_mode") // 68
     VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT           = 1000067000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT  = 1000067001,

     //@extension("VK_KHR_device_group_creation") // 71
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR      = 1000070000,
     VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR       = 1000070001,

     //@extension("VK_KHR_external_memory_capabilities") // 72
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR    = 1000071000,
     VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR      = 1000071001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR  = 1000071002,
     VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR            = 1000071003,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR         = 1000071004,

     //@extension("VK_KHR_external_memory") // 73
     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR    = 1000072000,
     VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR     = 1000072001,
     VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR           = 1000072002,

     //@extension("VK_KHR_external_memory_win32") // 74
     VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR       = 1000073000,
     VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR       = 1000073001,
     VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR        = 1000073002,

     //@extension("VK_KHR_external_memory_fd") // 75
     VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR                 = 1000074000,
     VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR                  = 1000074001,

     //@extension("VK_KHR_win32_keyed_mutex") // 76
     VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR    = 1000075000,

     //@extension("VK_KHR_external_semaphore_capabilities") // 77
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR   = 1000076000,
     VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR         = 1000076001,

     //@extension("VK_KHR_external_semaphore") // 78
     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR          = 1000077000,

     //@extension("VK_KHR_external_semaphore_win32") // 79
     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR    = 1000078000,
     VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR    = 1000078001,
     VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR               = 1000078002,

     //@extension("VK_KHR_external_semaphore_fd") // 80
     VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR              = 1000079000,
     VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR                 = 1000079001,

     //@extension("VK_KHR_push_descriptor") // 81
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR    = 1000080000,

     //@extension("VK_KHR_16bit_storage") // 84
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR    = 1000083000,

     //@extension("VK_KHR_incremental_present") // 85
     VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR                       = 1000084000,

     //@extension("VK_EXT_conditional_rendering") // 82
     VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT        = 1000081001,
     VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT                      = 1000081002,

     //@extension("VK_KHR_descriptor_update_template") // 86
     VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR    = 1000085000,

     //@extension("VK_NVX_device_generated_commands") // 87
     VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX              = 1000086000,
     VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX  = 1000086001,
     VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX             = 1000086002,
     VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX   = 1000086003,
     VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX      = 1000086004,
     VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX    = 1000086005,

     //@extension("VK_NV_clip_space_w_scaling") // 88
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV  = 1000087000,

     //@extension("VK_EXT_display_surface_counter") // 91
     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT                = 1000090000,

     //@extension("VK_EXT_display_control") // 92
     VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT                    = 1000091000,
     VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT                     = 1000091001,
     VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT                    = 1000091002,
     VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT         = 1000091003,

     //@extension("VK_GOOGLE_display_timing") // 93
     VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE                 = 1000092000,

     //@extension("VK_NVX_multiview_per_view_attributes") // 98
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX  = 1000097000,

     //@extension("VK_NV_viewport_swizzle") // 99
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV    = 1000098000,

     //@extension("VK_EXT_discard_rectangles") // 100
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT  = 1000099000,
     VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT  = 1000099001,

     //@extension("VK_EXT_conservative_rasterization") // 102
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
     VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,

     //@extension("VK_KHR_create_renderpass2") // 110
     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR              = 1000109000,
     VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR                = 1000109001,
     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR                 = 1000109002,
     VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR                  = 1000109003,
     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR             = 1000109004,
     VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR                    = 1000109005,
     VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR                      = 1000109006,

     //@extension("VK_EXT_hdr_metadata") // 106
     VK_STRUCTURE_TYPE_HDR_METADATA_EXT                          = 1000105000,

     //@extension("VK_KHR_shared_presentable_image") // 112
     VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR   = 1000111000,

     //@extension("VK_KHR_external_fence_capabilities") // 113
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR   = 1000112000,
     VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR             = 1000112001,

     //@extension("VK_KHR_external_fence") // 114
     VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR              = 1000113000,

     //@extension("VK_KHR_external_fence_win32") // 115
     VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR        = 1000114000,
     VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR        = 1000114001,
     VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR           = 1000114002,

     //@extension("VK_KHR_external_fence_fd") // 117
     VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR                  = 1000115000,
     VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR                     = 1000115001,

     //@extension("VK_KHR_maintenance2") // 118
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR             = 1000117000,
     VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR       = 1000117001,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR                          = 1000117002,
     VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = 1000117003,

     //@extension("VK_KHR_get_surface_capabilities2") // 120
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR        = 1000119000,
     VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR                = 1000119001,
     VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR                      = 1000119002,

     //@extension("VK_KHR_variable_pointers") // 121
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000,

     //@extension("VK_KHR_display_properties2") // 122
     VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR                  = 1000121000,
     VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR            = 1000121001,
     VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR             = 1000121002,
     VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR                  = 1000121003,
     VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR          = 1000121004,

     //@extension("VK_MVK_ios_surface") // 123
     VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK               = 1000122000,

     //@extension("VK_MVK_macos_surface") // 124
     VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK             = 1000123000,

     //@extension("VK_KHR_dedicated_allocation") // 128
     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR         = 1000127000,
     VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR        = 1000127001,

     //@extension("VK_EXT_debug_utils") // 129
     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT          = 1000128000,
     VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT           = 1000128001,
     VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT                     = 1000128002,
     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT   = 1000128003,
     VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT     = 1000128004,

     //@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID             = 1000129000,
     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID        = 1000129001,
     VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,
     VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID       = 1000129003,
     VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID   = 1000129004,
     VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID                           = 1000129005,

     //@extension("VK_EXT_sampler_filter_minmax") // 131
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000,
     VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001,

     //@extension("VK_EXT_inline_uniform_block") // 139
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT     = 1000138000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT   = 1000138001,
     VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT         = 1000138002,
     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT  = 1000138003,

     //@extension("VK_EXT_sample_locations") // 144
     VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT                         = 1000143000,
     VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT       = 1000143001,
     VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT   = 1000143002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT   = 1000143003,
     VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT                        = 1000143004,

     //@extension("VK_KHR_get_memory_requirements2") // 147
     VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR         = 1000146000,
     VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR          = 1000146001,
     VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR   = 1000146002,
     VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR                     = 1000146003,
     VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR        = 1000146004,

     //@extension("VK_KHR_image_format_list") // 148
     VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR             = 1000147000,

     //@extension("VK_EXT_blend_operation_advanced") // 149
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,

     //@extension("VK_NV_fragment_coverage_to_color") // 150
     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,

     //@extension("VK_NV_framebuffer_mixed_samples") // 153
     VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,

     //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR              = 1000156000,
     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR                     = 1000156001,
     VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR                      = 1000156002,
     VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR              = 1000156003,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = 1000156004,
     VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR  = 1000156005,

     //@extension("VK_KHR_bind_memory2") // 158
     VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR                       = 1000157000,
     VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR                        = 1000157001,

     //@extension("VK_EXT_validation_cache") // 161
     VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT                  = 1000160000,
     VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT    = 1000160001,

     //@extension("VK_EXT_descriptor_indexing") // 162
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT           = 1000161000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT              = 1000161001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT            = 1000161002,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT    = 1000161003,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT   = 1000161004,

     //@extension("VK_NV_shading_rate_image") // 165
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002,
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005,

     //@extension("VK_NVX_raytracing") // 166
     VK_STRUCTURE_TYPE_RAYTRACING_PIPELINE_CREATE_INFO_NVX = 1000165000,
     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NVX = 1000165001,
     VK_STRUCTURE_TYPE_GEOMETRY_INSTANCE_NVX = 1000165002,
     VK_STRUCTURE_TYPE_GEOMETRY_NVX = 1000165003,
     VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NVX = 1000165004,
     VK_STRUCTURE_TYPE_GEOMETRY_AABB_NVX = 1000165005,
     VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NVX = 1000165006,
     VK_STRUCTURE_TYPE_DESCRIPTOR_ACCELERATION_STRUCTURE_INFO_NVX = 1000165007,
     VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NVX = 1000165008,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAYTRACING_PROPERTIES_NVX = 1000165009,
     VK_STRUCTURE_TYPE_HIT_SHADER_MODULE_CREATE_INFO_NVX = 1000165010,

     //@extension("VK_NV_representative_fragment_test") // 167
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000,
     VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,

     //@extension("VK_KHR_maintenance3") // 169
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR      = 1000168000,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR                 = 1000168001,

     //@extension("VK_EXT_global_priority") // 175
     VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT      = 1000174000,

     //@extension("VK_KHR_8bit_storage") // 178
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR         = 1000177000,

     //@extension("VK_EXT_external_memory_host") // 179
     VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT                   = 1000178000,
     VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT                    = 1000178001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT   = 1000178002,

     //@extension("VK_KHR_shader_atomic_int64") // 181
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR  = 1000180000,

     //@extension("VK_KHR_driver_properties") // 197
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR             = 1000196000,

     //@extension("VK_AMD_shader_core_properties") // 186
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD        = 1000185000,

     //@extension("VK_EXT_vertex_attribute_divisor") // 191
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT   = 1000190000,
     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT       = 1000190001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT     = 1000190002,

     //@extension("VK_NV_device_diagnostic_checkpoints") // 207
     VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV                        = 1000206000,
     VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV     = 1000206001,

     //@extension("VK_KHR_vulkan_memory_model") // 212
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = 1000211000,
 }

 enum VkSubpassContents {
     VK_SUBPASS_CONTENTS_INLINE                              = 0x00000000,
     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS           = 0x00000001,
 }

 enum VkPipelineCacheHeaderVersion {
     VK_PIPELINE_CACHE_HEADER_VERSION_ONE                    = 1,
 }

 @lastUnused(-11)
 /// Error and return codes
 enum VkResult {
     // Return codes for successful operation execution (positive values)
     VK_SUCCESS                                              = 0,
     VK_NOT_READY                                            = 1,
     VK_TIMEOUT                                              = 2,
     VK_EVENT_SET                                            = 3,
     VK_EVENT_RESET                                          = 4,
     VK_INCOMPLETE                                           = 5,

     //@extension("VK_KHR_swapchain") // 2
     VK_SUBOPTIMAL_KHR                                       = 1000001003,

     // Error codes (negative values)
     VK_ERROR_OUT_OF_HOST_MEMORY                             = 0xFFFFFFFF, // -1
     VK_ERROR_OUT_OF_DEVICE_MEMORY                           = 0xFFFFFFFE, // -2
     VK_ERROR_INITIALIZATION_FAILED                          = 0xFFFFFFFD, // -3
     VK_ERROR_DEVICE_LOST                                    = 0xFFFFFFFC, // -4
     VK_ERROR_MEMORY_MAP_FAILED                              = 0xFFFFFFFB, // -5
     VK_ERROR_LAYER_NOT_PRESENT                              = 0xFFFFFFFA, // -6
     VK_ERROR_EXTENSION_NOT_PRESENT                          = 0xFFFFFFF9, // -7
     VK_ERROR_FEATURE_NOT_PRESENT                            = 0xFFFFFFF8, // -8
     VK_ERROR_INCOMPATIBLE_DRIVER                            = 0xFFFFFFF7, // -9
     VK_ERROR_TOO_MANY_OBJECTS                               = 0xFFFFFFF6, // -10
     VK_ERROR_FORMAT_NOT_SUPPORTED                           = 0xFFFFFFF5, // -11
     VK_ERROR_FRAGMENTED_POOL                                = 0xFFFFFFF4, // -12

     //@vulkan1_1
     VK_ERROR_OUT_OF_POOL_MEMORY                             = 0xC4642878, // -1000069000
     VK_ERROR_INVALID_EXTERNAL_HANDLE                        = 0xC4641CBD, // -1000072003

     //@extension("VK_KHR_surface") // 1
     VK_ERROR_SURFACE_LOST_KHR                               = 0xC4653600, // -1000000000
     VK_ERROR_NATIVE_WINDOW_IN_USE_KHR                       = 0xC46535FF, // -1000000001

     //@extension("VK_KHR_swapchain") // 2
     VK_ERROR_OUT_OF_DATE_KHR                                = 0xC4653214, // -1000001004

     //@extension("VK_KHR_display_swapchain") // 4
     VK_ERROR_INCOMPATIBLE_DISPLAY_KHR                       = 0xC4652A47, // -1000003001

     //@extension("VK_EXT_debug_report") // 12
     VK_ERROR_VALIDATION_FAILED_EXT                          = 0xC4650B07, // -1000011001

     //@extension("VK_NV_glsl_shader") // 13
     VK_ERROR_INVALID_SHADER_NV                              = 0xC4650720, // -1000012000

     //@extension("VK_KHR_maintenance1") // 70
     VK_ERROR_OUT_OF_POOL_MEMORY_KHR                         = 0xC4642878, // -1000069000

     //@extension("VK_EXT_global_priority") // 175
     VK_ERROR_NOT_PERMITTED_EXT                              = 0xC4628E4F, // -1000174001

     //@extension("VK_KHR_external_memory") // 73
     VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR                    = 0xC4641CBD, // -1000072003

     //@extension("VK_EXT_descriptor_indexing") // 162
     VK_ERROR_FRAGMENTATION_EXT                              = 0xc462c118, // -1000161000
 }

 enum VkDynamicState {
     VK_DYNAMIC_STATE_VIEWPORT                               = 0x00000000,
     VK_DYNAMIC_STATE_SCISSOR                                = 0x00000001,
     VK_DYNAMIC_STATE_LINE_WIDTH                             = 0x00000002,
     VK_DYNAMIC_STATE_DEPTH_BIAS                             = 0x00000003,
     VK_DYNAMIC_STATE_BLEND_CONSTANTS                        = 0x00000004,
     VK_DYNAMIC_STATE_DEPTH_BOUNDS                           = 0x00000005,
     VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK                   = 0x00000006,
     VK_DYNAMIC_STATE_STENCIL_WRITE_MASK                     = 0x00000007,
     VK_DYNAMIC_STATE_STENCIL_REFERENCE                      = 0x00000008,

     //@extension("VK_NV_clip_space_w_scaling") // 88
     VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV                  = 1000087000,

     //@extension("VK_EXT_discard_rectangles") // 100
     VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT                  = 1000099000,

     //@extension("VK_EXT_sample_locations") // 144
     VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT                   = 1000143000,

     //@extension("VK_NV_shading_rate_image") // 165
     VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV       = 1000164004,
     VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV        = 1000164006,

     //@extension("VK_NV_scissor_exclusive") // 206
     VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV                   = 1000205001,
 }

 enum VkObjectType {
     VK_OBJECT_TYPE_UNKNOWN                                  = 0,
     VK_OBJECT_TYPE_INSTANCE                                 = 1,
     VK_OBJECT_TYPE_PHYSICAL_DEVICE                          = 2,
     VK_OBJECT_TYPE_DEVICE                                   = 3,
     VK_OBJECT_TYPE_QUEUE                                    = 4,
     VK_OBJECT_TYPE_SEMAPHORE                                = 5,
     VK_OBJECT_TYPE_COMMAND_BUFFER                           = 6,
     VK_OBJECT_TYPE_FENCE                                    = 7,
     VK_OBJECT_TYPE_DEVICE_MEMORY                            = 8,
     VK_OBJECT_TYPE_BUFFER                                   = 9,
     VK_OBJECT_TYPE_IMAGE                                    = 10,
     VK_OBJECT_TYPE_EVENT                                    = 11,
     VK_OBJECT_TYPE_QUERY_POOL                               = 12,
     VK_OBJECT_TYPE_BUFFER_VIEW                              = 13,
     VK_OBJECT_TYPE_IMAGE_VIEW                               = 14,
     VK_OBJECT_TYPE_SHADER_MODULE                            = 15,
     VK_OBJECT_TYPE_PIPELINE_CACHE                           = 16,
     VK_OBJECT_TYPE_PIPELINE_LAYOUT                          = 17,
     VK_OBJECT_TYPE_RENDER_PASS                              = 18,
     VK_OBJECT_TYPE_PIPELINE                                 = 19,
     VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT                    = 20,
     VK_OBJECT_TYPE_SAMPLER                                  = 21,
     VK_OBJECT_TYPE_DESCRIPTOR_POOL                          = 22,
     VK_OBJECT_TYPE_DESCRIPTOR_SET                           = 23,
     VK_OBJECT_TYPE_FRAMEBUFFER                              = 24,
     VK_OBJECT_TYPE_COMMAND_POOL                             = 25,

     //@vulkan1_1
     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION                 = 1000156000,
     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE               = 1000085000,

     //@extension("VK_KHR_surface") // 1
     VK_OBJECT_TYPE_SURFACE_KHR                              = 1000000000,

     //@extension("VK_KHR_swapchain") // 2
     VK_OBJECT_TYPE_SWAPCHAIN_KHR                            = 1000001000,

     //@extension("VK_KHR_display") // 3
     VK_OBJECT_TYPE_DISPLAY_KHR                              = 1000002000,
     VK_OBJECT_TYPE_DISPLAY_MODE_KHR                         = 1000002001,

     //@extension("VK_KHR_debug_report") // 12
     VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT                = 1000011000,

     //@extension("VK_KHR_descriptor_update_template") // 86
     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR           = 1000085000,

     //@extension("VK_NVX_device_generated_commands") // 87
     VK_OBJECT_TYPE_OBJECT_TABLE_NVX                         = 1000086000,
     VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX             = 1000086001,

     //@extension("VK_EXT_debug_utils") // 129
     VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT                = 1000128000,

     //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR             = 1000156000,

     //@extension("VK_EXT_validation_cache") // 161
     VK_OBJECT_TYPE_VALIDATION_CACHE_EXT                     = 1000160000,

     //@extension("VK_NVX_raytracing") // 166
     VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX               = 1000165000,
 }


 //@vulkan1_1 enums

 enum VkPointClippingBehavior {
     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES              = 0,
     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY        = 1,
 }

 enum VkTessellationDomainOrigin {
     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT                = 0,
     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT                = 1,
 }

 enum VkSamplerYcbcrModelConversion {
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY          = 0,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY        = 1,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709             = 2,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601             = 3,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020            = 4,
 }

 enum VkSamplerYcbcrRange {
     VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
 }

 enum VkChromaLocation {
     VK_CHROMA_LOCATION_COSITED_EVEN = 0,
     VK_CHROMA_LOCATION_MIDPOINT = 1,
 }

 enum VkDescriptorUpdateTemplateType {
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
 }

 enum VkVendorId {
     VK_VENDOR_ID_VIV                                        = 0x10001,
     VK_VENDOR_ID_VSI                                        = 0x10002,
     VK_VENDOR_ID_KAZAN                                      = 0x10003,
 }

 @extension("VK_KHR_surface") // 1
 enum VkPresentModeKHR {
     VK_PRESENT_MODE_IMMEDIATE_KHR                           = 0x00000000,
     VK_PRESENT_MODE_MAILBOX_KHR                             = 0x00000001,
     VK_PRESENT_MODE_FIFO_KHR                                = 0x00000002,
     VK_PRESENT_MODE_FIFO_RELAXED_KHR                        = 0x00000003,

     //@extension("VK_KHR_shared_presentable_image") // 112
     VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR               = 1000111000,
     VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR           = 1000111001,
 }

 @extension("VK_KHR_surface") // 1
 enum VkColorSpaceKHR {
     VK_COLOR_SPACE_SRGB_NONLINEAR_KHR                       = 0x00000000,

     //@extension("VK_EXT_swapchain_colorspace") // 105
     VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT                 = 1000104001,
     VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT                 = 1000104002,
     VK_COLOR_SPACE_DCI_P3_LINEAR_EXT                        = 1000104003,
     VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT                     = 1000104004,
     VK_COLOR_SPACE_BT709_LINEAR_EXT                         = 1000104005,
     VK_COLOR_SPACE_BT709_NONLINEAR_EXT                      = 1000104006,
     VK_COLOR_SPACE_BT2020_LINEAR_EXT                        = 1000104007,
     VK_COLOR_SPACE_HDR10_ST2084_EXT                         = 1000104008,
     VK_COLOR_SPACE_DOLBYVISION_EXT                          = 1000104009,
     VK_COLOR_SPACE_HDR10_HLG_EXT                            = 1000104010,
     VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT                      = 1000104011,
     VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT                   = 1000104012,
     VK_COLOR_SPACE_PASS_THROUGH_EXT                         = 1000104013,
     VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT              = 1000104014,
 }

 @extension("VK_EXT_debug_report") // 12
 enum VkDebugReportObjectTypeEXT {
     VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT                 = 0,
     VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT                = 1,
     VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT         = 2,
     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT                  = 3,
     VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT                   = 4,
     VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT               = 5,
     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT          = 6,
     VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT                   = 7,
     VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT           = 8,
     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT                  = 9,
     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT                   = 10,
     VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT                   = 11,
     VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT              = 12,
     VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT             = 13,
     VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT              = 14,
     VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT           = 15,
     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT          = 16,
     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT         = 17,
     VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT             = 18,
     VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT                = 19,
     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT   = 20,
     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT                 = 21,
     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT         = 22,
     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT          = 23,
     VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT             = 24,
     VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT            = 25,
     VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT             = 26,
     VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT           = 27,
     VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT             = 29,
     VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT        = 30,
     VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT        = 31,
     VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,

     //extension("VK_EXT_validation_cache") // 161
     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT    = 33,

     //extension("VK_KHR_descriptor_update_template") // 86
     VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,

     //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
     VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = 1000156000,

     //@extension("VK_NVX_raytracing") // 166
     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NVX_EXT  = 1000165000,
 }

 @extension("VK_AMD_rasterization_order") // 19
 enum VkRasterizationOrderAMD {
     VK_RASTERIZATION_ORDER_STRICT_AMD                       = 0,
     VK_RASTERIZATION_ORDER_RELAXED_AMD                      = 1,
 }

 @extension("VK_AMD_shader_info") // 43
 enum VkShaderInfoTypeAMD {
     VK_SHADER_INFO_TYPE_STATISTICS_AMD                      = 0,
     VK_SHADER_INFO_TYPE_BINARY_AMD                          = 1,
     VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD                     = 2,
 }

 @extension("VK_EXT_validation_flags") // 62
 enum VkValidationCheckEXT {
     VK_VALIDATION_CHECK_ALL_EXT                             = 0,
     VK_VALIDATION_CHECK_SHADERS_EXT                         = 1,
 }

 @extension("VK_KHR_descriptor_update_template") // 86
 enum VkDescriptorUpdateTemplateTypeKHR {
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR   = 0,
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
 }

 @extension("VK_NVX_device_generated_commands") // 87
 enum VkIndirectCommandsTokenTypeNVX {
     VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX            = 0,
     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX      = 1,
     VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX        = 2,
     VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX       = 3,
     VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX       = 4,
     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX        = 5,
     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX                = 6,
     VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX            = 7,
 }

 @extension("VK_NVX_device_generated_commands") // 87
 enum VkObjectEntryTypeNVX {
     VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX                 = 0,
     VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX                       = 1,
     VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX                   = 2,
     VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX                  = 3,
     VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX                  = 4,
 }

 @extension("VK_EXT_display_control") // 92
 enum VkDisplayPowerStateEXT {
     VK_DISPLAY_POWER_STATE_OFF_EXT                          = 0,
     VK_DISPLAY_POWER_STATE_SUSPEND_EXT                      = 1,
     VK_DISPLAY_POWER_STATE_ON_EXT                           = 2,
 }

 @extension("VK_EXT_display_control") // 92
 enum VkDeviceEventTypeEXT {
     VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT                = 0,
 }

 @extension("VK_EXT_display_control") // 92
 enum VkDisplayEventTypeEXT {
     VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT               = 0,
 }

 @extension("VK_NV_viewport_swizzle") // 99
 enum VkViewportCoordinateSwizzleNV {
     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV            = 0,
     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV            = 1,
     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV            = 2,
     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV            = 3,
     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV            = 4,
     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV            = 5,
     VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV            = 6,
     VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV            = 7,
 }

 @extension("VK_EXT_discard_rectangles") // 100
 enum VkDiscardRectangleModeEXT {
     VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
     VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
 }

 @extension("VK_EXT_conservative_rasterization") // 102
 enum VkConservativeRasterizationModeEXT {
     VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT         = 0,
     VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT     = 1,
     VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT    = 2,
 }

 @extension("VK_KHR_maintenance2") // 118
 enum VkPointClippingBehaviorKHR {
     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR          = 0,
     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR    = 1,
 }

 @extension("VK_KHR_maintenance2") // 118
 enum VkTessellationDomainOriginKHR {
     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR            = 0,
     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR            = 1,
 }

 @extension("VK_EXT_sampler_filter_minmax") // 131
 enum VkSamplerReductionModeEXT {
     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT          = 0,
     VK_SAMPLER_REDUCTION_MODE_MIN_EXT                       = 1,
     VK_SAMPLER_REDUCTION_MODE_MAX_EXT                       = 2,
 }

 @extension("VK_EXT_blend_operation_advanced") // 149
 enum VkBlendOverlapEXT {
     VK_BLEND_OVERLAP_UNCORRELATED_EXT                       = 0,
     VK_BLEND_OVERLAP_DISJOINT_EXT                           = 1,
     VK_BLEND_OVERLAP_CONJOINT_EXT                           = 2,
 }

 @extension("VK_NV_framebuffer_mixed_samples") // 153
 enum VkCoverageModulationModeNV {
     VK_COVERAGE_MODULATION_MODE_NONE_NV                     = 0,
     VK_COVERAGE_MODULATION_MODE_RGB_NV                      = 1,
     VK_COVERAGE_MODULATION_MODE_ALPHA_NV                    = 2,
     VK_COVERAGE_MODULATION_MODE_RGBA_NV                     = 3,
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 enum VkSamplerYcbcrModelConversionKHR {
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR      = 0,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR    = 1,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR         = 2,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR         = 3,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR        = 4,
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 enum VkSamplerYcbcrRangeKHR {
     VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR                     = 0,
     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR                   = 1,
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 enum VkChromaLocationKHR {
     VK_CHROMA_LOCATION_COSITED_EVEN_KHR                     = 0,
     VK_CHROMA_LOCATION_MIDPOINT_KHR                         = 1,
 }

 @extension("VK_EXT_validation_cache") // 161
 enum VkValidationCacheHeaderVersionEXT {
     VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT              = 1,
 }

 @extension("VK_NV_shading_rate_image") // 165
 enum VkShadingRatePaletteEntryNV {
     VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV                 = 0,
     VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV       = 1,
     VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV        = 2,
     VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV        = 3,
     VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV        = 4,
     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV         = 5,
     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV    = 6,
     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV    = 7,
     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV    = 8,
     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV    = 9,
     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV    = 10,
     VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV    = 11,
 }

 @extension("VK_NV_shading_rate_image") // 165
 enum VkCoarseSampleOrderTypeNV {
     VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV                  = 0,
     VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV                   = 1,
     VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV              = 2,
     VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV             = 3,
 }

 @extension("VK_NVX_raytracing") // 166
 enum VkGeometryTypeNVX {
     VK_GEOMETRY_TYPE_TRIANGLES_NVX                          = 0,
     VK_GEOMETRY_TYPE_AABBS_NVX                              = 1,
 }

 @extension("VK_NVX_raytracing") // 166
 enum VkAccelerationStructureTypeNVX {
     VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NVX            = 0,
     VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NVX         = 1,
 }

 @extension("VK_NVX_raytracing") // 166
 enum VkCopyAccelerationStructureModeNVX {
     VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NVX           = 0,
     VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NVX         = 1,
 }

 @extension("VK_EXT_global_priority") // 175
 enum VkQueueGlobalPriorityEXT {
     VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT                        = 128,
     VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT                     = 256,
     VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT                       = 512,
     VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT                   = 1024,
 }

 @extension("VK_KHR_driver_properties") // 197
 enum VkDriverIdKHR {
     VK_DRIVER_ID_AMD_PROPRIETARY_KHR                        = 1,
     VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR                        = 2,
     VK_DRIVER_ID_MESA_RADV_KHR                              = 3,
     VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR                     = 4,
     VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR              = 5,
     VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR                 = 6,
     VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR                = 7,
     VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR                   = 8,
     VK_DRIVER_ID_ARM_PROPRIETARY_KHR                        = 9,
 }

 /////////////////
 //  Bitfields  //
 /////////////////

 /// Queue capabilities
 type VkFlags VkQueueFlags
 bitfield VkQueueFlagBits {
     VK_QUEUE_GRAPHICS_BIT                                   = 0x00000001,    /// Queue supports graphics operations
     VK_QUEUE_COMPUTE_BIT                                    = 0x00000002,    /// Queue supports compute operations
     VK_QUEUE_TRANSFER_BIT                                   = 0x00000004,    /// Queue supports transfer operations
     VK_QUEUE_SPARSE_BINDING_BIT                             = 0x00000008,    /// Queue supports sparse resource memory management operations

     //@vulkan1_1
     VK_QUEUE_PROTECTED_BIT                                  = 0x00000010,
 }

 /// Memory properties passed into vkAllocMemory().
 type VkFlags VkMemoryPropertyFlags
 bitfield VkMemoryPropertyFlagBits {
     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT                     = 0x00000001,
     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT                     = 0x00000002,
     VK_MEMORY_PROPERTY_HOST_COHERENT_BIT                    = 0x00000004,
     VK_MEMORY_PROPERTY_HOST_CACHED_BIT                      = 0x00000008,
     VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT                 = 0x00000010,

     //@vulkan1_1
     VK_MEMORY_PROPERTY_PROTECTED_BIT                        = 0x00000020,
 }

 /// Memory heap flags
 type VkFlags VkMemoryHeapFlags
 bitfield VkMemoryHeapFlagBits {
     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT                         = 0x00000001,

     //@vulkan1_1
     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT                       = 0x00000002,

     //@extension("VK_KHR_device_group_creation") // 71
     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR                   = 0x00000002,
 }

 /// Access flags
 type VkFlags VkAccessFlags
 bitfield VkAccessFlagBits {
     VK_ACCESS_INDIRECT_COMMAND_READ_BIT                     = 0x00000001,
     VK_ACCESS_INDEX_READ_BIT                                = 0x00000002,
     VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT                     = 0x00000004,
     VK_ACCESS_UNIFORM_READ_BIT                              = 0x00000008,
     VK_ACCESS_INPUT_ATTACHMENT_READ_BIT                     = 0x00000010,
     VK_ACCESS_SHADER_READ_BIT                               = 0x00000020,
     VK_ACCESS_SHADER_WRITE_BIT                              = 0x00000040,
     VK_ACCESS_COLOR_ATTACHMENT_READ_BIT                     = 0x00000080,
     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT                    = 0x00000100,
     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT             = 0x00000200,
     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT            = 0x00000400,
     VK_ACCESS_TRANSFER_READ_BIT                             = 0x00000800,
     VK_ACCESS_TRANSFER_WRITE_BIT                            = 0x00001000,
     VK_ACCESS_HOST_READ_BIT                                 = 0x00002000,
     VK_ACCESS_HOST_WRITE_BIT                                = 0x00004000,
     VK_ACCESS_MEMORY_READ_BIT                               = 0x00008000,
     VK_ACCESS_MEMORY_WRITE_BIT                              = 0x00010000,

     //@extension("VK_NVX_device_generated_commands") // 87
     VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX                  = 0x00020000,
     VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX                 = 0x00040000,

     //@extension("VK_EXT_blend_operation_advanced") // 149
     VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT     = 0x00080000,

     //@extension("VK_EXT_conditional_rendering") // 82
     VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT            = 0x00100000,

     //@extension("VK_NV_shading_rate_image") // 165
     VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV                = 0x00800000,

     //@extension("VK_NVX_raytracing") // 166
     VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NVX           = 0x00200000,
     VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NVX          = 0x00400000,
 }

 /// Buffer usage flags
 type VkFlags VkBufferUsageFlags
 bitfield VkBufferUsageFlagBits {
     VK_BUFFER_USAGE_TRANSFER_SRC_BIT                        = 0x00000001,    /// Can be used as a source of transfer operations
     VK_BUFFER_USAGE_TRANSFER_DST_BIT                        = 0x00000002,    /// Can be used as a destination of transfer operations
     VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT                = 0x00000004,    /// Can be used as TBO
     VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT                = 0x00000008,    /// Can be used as IBO
     VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT                      = 0x00000010,    /// Can be used as UBO
     VK_BUFFER_USAGE_STORAGE_BUFFER_BIT                      = 0x00000020,    /// Can be used as SSBO
     VK_BUFFER_USAGE_INDEX_BUFFER_BIT                        = 0x00000040,    /// Can be used as source of fixed function index fetch (index buffer)
     VK_BUFFER_USAGE_VERTEX_BUFFER_BIT                       = 0x00000080,    /// Can be used as source of fixed function vertex fetch (VBO)
     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT                     = 0x00000100,    /// Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)

     //@extension("VK_EXT_conditional_rendering") // 82
     VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT           = 0x00000200,

     //@extension("VK_NVX_raytracing") // 166
     VK_BUFFER_USAGE_RAYTRACING_BIT_NVX                      = 0x00000400,
 }

 /// Buffer creation flags
 type VkFlags VkBufferCreateFlags
 bitfield VkBufferCreateFlagBits {
     VK_BUFFER_CREATE_SPARSE_BINDING_BIT                     = 0x00000001,    /// Buffer should support sparse backing
     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT                   = 0x00000002,    /// Buffer should support sparse backing with partial residency
     VK_BUFFER_CREATE_SPARSE_ALIASED_BIT                     = 0x00000004,    /// Buffer should support constent data access to physical memory blocks mapped into multiple locations of sparse buffers

     //@vulkan1_1
     VK_BUFFER_CREATE_PROTECTED_BIT                          = 0x00000008,
 }

 /// Shader stage flags
 type VkFlags VkShaderStageFlags
 bitfield VkShaderStageFlagBits {
     VK_SHADER_STAGE_VERTEX_BIT                              = 0x00000001,
     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT                = 0x00000002,
     VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT             = 0x00000004,
     VK_SHADER_STAGE_GEOMETRY_BIT                            = 0x00000008,
     VK_SHADER_STAGE_FRAGMENT_BIT                            = 0x00000010,
     VK_SHADER_STAGE_COMPUTE_BIT                             = 0x00000020,
     VK_SHADER_STAGE_ALL_GRAPHICS                            = 0x0000001F,

     VK_SHADER_STAGE_ALL                                     = 0x7FFFFFFF,

     //@extension("VK_NVX_raytracing") // 166
     VK_SHADER_STAGE_RAYGEN_BIT_NVX                          = 0x00000100,
     VK_SHADER_STAGE_ANY_HIT_BIT_NVX                         = 0x00000200,
     VK_SHADER_STAGE_CLOSEST_HIT_BIT_NVX                     = 0x00000400,
     VK_SHADER_STAGE_MISS_BIT_NVX                            = 0x00000800,
     VK_SHADER_STAGE_INTERSECTION_BIT_NVX                    = 0x00001000,
     VK_SHADER_STAGE_CALLABLE_BIT_NVX                        = 0x00002000,

     //@extension("VK_NV_mesh_shader") // 203
     VK_SHADER_STAGE_TASK_BIT_NV                             = 0x00000040,
     VK_SHADER_STAGE_MESH_BIT_NV                             = 0x00000080,
 }

 /// Descriptor pool create flags
 type VkFlags VkDescriptorPoolCreateFlags
 bitfield VkDescriptorPoolCreateFlagBits {
     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT       = 0x00000001,

     //@extension("VK_EXT_descriptor_indexing") // 162
     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT     = 0x00000002,
 }

 /// Descriptor pool reset flags
 type VkFlags VkDescriptorPoolResetFlags
 //bitfield VkDescriptorPoolResetFlagBits {
 //}

 /// Image usage flags
 type VkFlags VkImageUsageFlags
 bitfield VkImageUsageFlagBits {
     VK_IMAGE_USAGE_TRANSFER_SRC_BIT                         = 0x00000001,    /// Can be used as a source of transfer operations
     VK_IMAGE_USAGE_TRANSFER_DST_BIT                         = 0x00000002,    /// Can be used as a destination of transfer operations
     VK_IMAGE_USAGE_SAMPLED_BIT                              = 0x00000004,    /// Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
     VK_IMAGE_USAGE_STORAGE_BIT                              = 0x00000008,    /// Can be used as storage image (STORAGE_IMAGE descriptor type)
     VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                     = 0x00000010,    /// Can be used as framebuffer color attachment
     VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT             = 0x00000020,    /// Can be used as framebuffer depth/stencil attachment
     VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT                 = 0x00000040,    /// Image data not needed outside of rendering
     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT                     = 0x00000080,    /// Can be used as framebuffer input attachment

     //@extension("VK_NV_shading_rate_image") // 165
     VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV                = 0x00000100,
 }

 /// Image creation flags
 type VkFlags VkImageCreateFlags
 bitfield VkImageCreateFlagBits {
     VK_IMAGE_CREATE_SPARSE_BINDING_BIT                      = 0x00000001,    /// Image should support sparse backing
     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT                    = 0x00000002,    /// Image should support sparse backing with partial residency
     VK_IMAGE_CREATE_SPARSE_ALIASED_BIT                      = 0x00000004,    /// Image should support constent data access to physical memory blocks mapped into multiple locations of sparse images
     VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT                      = 0x00000008,    /// Allows image views to have different format than the base image
     VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT                     = 0x00000010,    /// Allows creating image views with cube type from the created image

     //@vulkan1_1
     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT                 = 0x00000020,
     VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT         = 0x00000040,
     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT         = 0x00000080,
     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT                      = 0x00000100,
     VK_IMAGE_CREATE_DISJOINT_BIT                            = 0x00000200,
     VK_IMAGE_CREATE_ALIAS_BIT                               = 0x00000400,
     VK_IMAGE_CREATE_PROTECTED_BIT                           = 0x00000800,

     //@extension("VK_KHR_maintenance1") // 70
     VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR             = 0x00000020,

     //@extension("VK_KHR_device_group") // 61
     VK_IMAGE_CREATE_BIND_SFR_BIT_KHR                        = 0x00000040,

     //@extension("VK_KHR_maintenance2") // 118
     VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR     = 0x00000080,
     VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR                  = 0x00000100,

     //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
     VK_IMAGE_CREATE_DISJOINT_BIT_KHR                        = 0x00000200,

     //@extension("VK_KHR_bind_memory2") // 158
     VK_IMAGE_CREATE_ALIAS_BIT_KHR                           = 0x00000400,

     //@extension("VK_EXT_sample_locations") // 144
     VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,

     //@extension("VK_NV_corner_sampled_image") // 51
     VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV                   = 0x00002000,
 }

 /// Image view creation flags
 type VkFlags VkImageViewCreateFlags
 //bitfield VkImageViewCreateFlagBits {
 //}

 /// Pipeline creation flags
 type VkFlags VkPipelineCreateFlags
 bitfield VkPipelineCreateFlagBits {
     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT             = 0x00000001,
     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT                = 0x00000002,
     VK_PIPELINE_CREATE_DERIVATIVE_BIT                       = 0x00000004,

     //@vulkan1_1
     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT     = 0x00000008,
     VK_PIPELINE_CREATE_DISPATCH_BASE                        = 0x00000010,

     //@extension("VK_KHR_device_group") // 61
     VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008,
     VK_PIPELINE_CREATE_DISPATCH_BASE_KHR                    = 0x00000010,

     //@extension("VK_NVX_raytracing") // 166
     VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NVX                = 0x00000020,
 }

 /// Color component flags
 type VkFlags VkColorComponentFlags
 bitfield VkColorComponentFlagBits {
     VK_COLOR_COMPONENT_R_BIT                                = 0x00000001,
     VK_COLOR_COMPONENT_G_BIT                                = 0x00000002,
     VK_COLOR_COMPONENT_B_BIT                                = 0x00000004,
     VK_COLOR_COMPONENT_A_BIT                                = 0x00000008,
 }

 /// Fence creation flags
 type VkFlags VkFenceCreateFlags
 bitfield VkFenceCreateFlagBits {
     VK_FENCE_CREATE_SIGNALED_BIT                            = 0x00000001,
 }

 /// Semaphore creation flags
 type VkFlags VkSemaphoreCreateFlags
 //bitfield VkSemaphoreCreateFlagBits {
 //}

 /// Format capability flags
 type VkFlags VkFormatFeatureFlags
 bitfield VkFormatFeatureFlagBits {
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT                     = 0x00000001,    /// Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT                     = 0x00000002,    /// Format can be used for storage images (STORAGE_IMAGE descriptor type)
     VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT              = 0x00000004,    /// Format supports atomic operations in case it's used for storage images
     VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT              = 0x00000008,    /// Format can be used for uniform texel buffers (TBOs)
     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT              = 0x00000010,    /// Format can be used for storage texel buffers (IBOs)
     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT       = 0x00000020,    /// Format supports atomic operations in case it's used for storage texel buffers
     VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT                     = 0x00000040,    /// Format can be used for vertex buffers (VBOs)
     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT                  = 0x00000080,    /// Format can be used for color attachment images
     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT            = 0x00000100,    /// Format supports blending in case it's used for color attachment images
     VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT          = 0x00000200,    /// Format can be used for depth/stencil attachment images
     VK_FORMAT_FEATURE_BLIT_SRC_BIT                          = 0x00000400,    /// Format can be used as the source image of blits with vkCommandBlitImage
     VK_FORMAT_FEATURE_BLIT_DST_BIT                          = 0x00000800,    /// Format can be used as the destination image of blits with vkCommandBlitImage
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT       = 0x00001000,

     //@vulkan1_1
     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT                      = 0x00004000,
     VK_FORMAT_FEATURE_TRANSFER_DST_BIT                      = 0x00008000,
     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT                                                   = 0x00020000,
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT                              = 0x00040000,
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT             = 0x00080000,
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT             = 0x00100000,
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT   = 0x00200000,
     VK_FORMAT_FEATURE_DISJOINT_BIT                                                                  = 0x00400000,
     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT                                                    = 0x00800000,

     //@extension("VK_IMG_filter_cubic") // 16
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG    = 0x00002000,

     //@extension("VK_KHR_maintenance1") // 70
     VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR                  = 0x00004000,
     VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR                  = 0x00008000,

     //@extension("VK_EXT_sampler_filter_minmax") // 131
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT   = 0x00010000,

     //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
     VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR                                                   = 0x00020000,
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR                              = 0x00040000,
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR             = 0x00080000,
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR             = 0x00100000,
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR   = 0x00200000,
     VK_FORMAT_FEATURE_DISJOINT_BIT_KHR                                                                  = 0x00400000,
     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR                                                    = 0x00800000,
 }

 /// Query control flags
 type VkFlags VkQueryControlFlags
 bitfield VkQueryControlFlagBits {
     VK_QUERY_CONTROL_PRECISE_BIT                            = 0x00000001,
 }

 /// Query result flags
 type VkFlags VkQueryResultFlags
 bitfield VkQueryResultFlagBits {
     VK_QUERY_RESULT_64_BIT                                  = 0x00000001,   /// Results of the queries are written to the destination buffer as 64-bit values
     VK_QUERY_RESULT_WAIT_BIT                                = 0x00000002,   /// Results of the queries are waited on before proceeding with the result copy
     VK_QUERY_RESULT_WITH_AVAILABILITY_BIT                   = 0x00000004,   /// Besides the results of the query, the availability of the results is also written
     VK_QUERY_RESULT_PARTIAL_BIT                             = 0x00000008,   /// Copy the partial results of the query even if the final results aren't available
 }

 /// Shader module creation flags
 type VkFlags VkShaderModuleCreateFlags
 //bitfield VkShaderModuleCreateFlagBits {
 //}

 /// Event creation flags
 type VkFlags VkEventCreateFlags
 //bitfield VkEventCreateFlagBits {
 //}

 /// Command buffer usage flags
 type VkFlags VkCommandBufferUsageFlags
 bitfield VkCommandBufferUsageFlagBits {
     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT             = 0x00000001,
     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT        = 0x00000002,
     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT            = 0x00000004,
 }

 /// Pipeline statistics flags
 type VkFlags VkQueryPipelineStatisticFlags
 bitfield VkQueryPipelineStatisticFlagBits {
     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT                     = 0x00000001,  /// Optional
     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT                   = 0x00000002,  /// Optional
     VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT                   = 0x00000004,  /// Optional
     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT                 = 0x00000008,  /// Optional
     VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT                  = 0x00000010,  /// Optional
     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT                        = 0x00000020,  /// Optional
     VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT                         = 0x00000040,  /// Optional
     VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT                 = 0x00000080,  /// Optional
     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT         = 0x00000100,  /// Optional
     VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT  = 0x00000200,  /// Optional
     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT                  = 0x00000400,  /// Optional
 }

 /// Memory mapping flags
 type VkFlags VkMemoryMapFlags
 //bitfield VkMemoryMapFlagBits {
 //}

 /// Bitfield of image aspects
 type VkFlags VkImageAspectFlags
 bitfield VkImageAspectFlagBits {
     VK_IMAGE_ASPECT_COLOR_BIT                               = 0x00000001,
     VK_IMAGE_ASPECT_DEPTH_BIT                               = 0x00000002,
     VK_IMAGE_ASPECT_STENCIL_BIT                             = 0x00000004,
     VK_IMAGE_ASPECT_METADATA_BIT                            = 0x00000008,

     //@vulkan1_1
     VK_IMAGE_ASPECT_PLANE_0_BIT                             = 0x00000010,
     VK_IMAGE_ASPECT_PLANE_1_BIT                             = 0x00000020,
     VK_IMAGE_ASPECT_PLANE_2_BIT                             = 0x00000040,

     //@extension("VK_KHR_sampler_ycbcr_conversion") // 157
     VK_IMAGE_ASPECT_PLANE_0_BIT_KHR                         = 0x00000010,
     VK_IMAGE_ASPECT_PLANE_1_BIT_KHR                         = 0x00000020,
     VK_IMAGE_ASPECT_PLANE_2_BIT_KHR                         = 0x00000040,
 }

 /// Sparse memory bind flags
 type VkFlags VkSparseMemoryBindFlags
 bitfield VkSparseMemoryBindFlagBits {
     VK_SPARSE_MEMORY_BIND_METADATA_BIT                      = 0x00000001,
 }

 /// Sparse image memory requirements flags
 type VkFlags VkSparseImageFormatFlags
 bitfield VkSparseImageFormatFlagBits {
     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT                  = 0x00000001,  /// Image uses a single miptail region for all array slices
     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT                = 0x00000002,  /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.
     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT          = 0x00000004,  /// Image uses a non-standard sparse block size
 }

 /// Pipeline stages
 type VkFlags VkPipelineStageFlags
 bitfield VkPipelineStageFlagBits {
     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT                       = 0x00000001,  /// Before subsequent commands are processed
     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT                     = 0x00000002,  /// Draw/DispatchIndirect command fetch
     VK_PIPELINE_STAGE_VERTEX_INPUT_BIT                      = 0x00000004,  /// Vertex/index fetch
     VK_PIPELINE_STAGE_VERTEX_SHADER_BIT                     = 0x00000008,  /// Vertex shading
     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT       = 0x00000010,  /// Tessellation control shading
     VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT    = 0x00000020,  /// Tessellation evaluation shading
     VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT                   = 0x00000040,  /// Geometry shading
     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT                   = 0x00000080,  /// Fragment shading
     VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT              = 0x00000100,  /// Early fragment (depth/stencil) tests
     VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT               = 0x00000200,  /// Late fragment (depth/stencil) tests
     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT           = 0x00000400,  /// Color attachment writes
     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT                    = 0x00000800,  /// Compute shading
     VK_PIPELINE_STAGE_TRANSFER_BIT                          = 0x00001000,  /// Transfer/copy operations
     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT                    = 0x00002000,
     VK_PIPELINE_STAGE_HOST_BIT                              = 0x00004000,  /// Indicates host (CPU) is a source/sink of the dependency

     VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT                      = 0x00008000,  /// All stages of the graphics pipeline
     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT                      = 0x00010000,  /// All graphics, compute, copy, and transition commands

     //@extension("VK_NVX_device_generated_commands") // 87
     VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX               = 0x00020000,

     //@extension("VK_EXT_conditional_rendering") // 82
     VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT         = 0x00040000,

     //@extension("VK_NV_shading_rate_image") // 165
     VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV             = 0x00400000,

     //@extension("VK_NVX_raytracing") // 166
     VK_PIPELINE_STAGE_RAYTRACING_BIT_NVX                    = 0x00200000,

     //@extension("VK_NV_mesh_shader") // 203
     VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV                    = 0x00080000,
     VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV                    = 0x00100000,
 }

 /// Render pass attachment description flags
 type VkFlags VkAttachmentDescriptionFlags
 bitfield VkAttachmentDescriptionFlagBits {
     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT                 = 0x00000001,  /// The attachment may alias physical memory of another attachment in the same renderpass
 }

 /// Subpass description flags
 type VkFlags VkSubpassDescriptionFlags
 bitfield VkSubpassDescriptionFlagBits {
     //@extension("VK_NVX_multiview_per_view_attributes") // 98
     VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX      = 0x00000001,
     VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
 }

 /// Command pool creation flags
 type VkFlags VkCommandPoolCreateFlags
 bitfield VkCommandPoolCreateFlagBits {
     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT                    = 0x00000001,  /// Command buffers have a short lifetime
     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT         = 0x00000002,  /// Command buffers may release their memory individually

     //@vulkan1_1
     VK_COMMAND_POOL_CREATE_PROTECTED_BIT                    = 0x00000004,
 }

 /// Command pool reset flags
 type VkFlags VkCommandPoolResetFlags
 bitfield VkCommandPoolResetFlagBits {
     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT             = 0x00000001,  /// Release resources owned by the pool
 }

 type VkFlags VkCommandBufferResetFlags
 bitfield VkCommandBufferResetFlagBits {
     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT           = 0x00000001,  /// Release resources owned by the buffer
 }

 type VkFlags VkSampleCountFlags
 bitfield VkSampleCountFlagBits {
     VK_SAMPLE_COUNT_1_BIT                                   = 0x00000001,
     VK_SAMPLE_COUNT_2_BIT                                   = 0x00000002,
     VK_SAMPLE_COUNT_4_BIT                                   = 0x00000004,
     VK_SAMPLE_COUNT_8_BIT                                   = 0x00000008,
     VK_SAMPLE_COUNT_16_BIT                                  = 0x00000010,
     VK_SAMPLE_COUNT_32_BIT                                  = 0x00000020,
     VK_SAMPLE_COUNT_64_BIT                                  = 0x00000040,
 }

 type VkFlags VkStencilFaceFlags
 bitfield VkStencilFaceFlagBits {
     VK_STENCIL_FACE_FRONT_BIT                               = 0x00000001,   /// Front face
     VK_STENCIL_FACE_BACK_BIT                                = 0x00000002,   /// Back face
     VK_STENCIL_FRONT_AND_BACK                               = 0x00000003,
 }

 /// Instance creation flags
 type VkFlags VkInstanceCreateFlags
 //bitfield VkInstanceCreateFlagBits {
 //}

 /// Device creation flags
 type VkFlags VkDeviceCreateFlags
 //bitfield VkDeviceCreateFlagBits {
 //}

 /// Device queue creation flags
 type VkFlags VkDeviceQueueCreateFlags
 @vulkan1_1
 bitfield VkDeviceQueueCreateFlagBits {
     VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT                    = 0x00000001,
 }

 /// Query pool creation flags
 type VkFlags VkQueryPoolCreateFlags
 //bitfield VkQueryPoolCreateFlagBits {
 //}

 /// Buffer view creation flags
 type VkFlags VkBufferViewCreateFlags
 //bitfield VkBufferViewCreateFlagBits {
 //}

 /// Pipeline cache creation flags
 type VkFlags VkPipelineCacheCreateFlags
 //bitfield VkPipelineCacheCreateFlagBits {
 //}

 /// Pipeline shader stage creation flags
 type VkFlags VkPipelineShaderStageCreateFlags
 //bitfield VkPipelineShaderStageCreateFlagBits {
 //}

 /// Descriptor set layout creation flags
 type VkFlags VkDescriptorSetLayoutCreateFlags
 bitfield VkDescriptorSetLayoutCreateFlagBits {
     //@extension("VK_KHR_push_descriptor") // 81
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR     = 0x00000001,

     //@extension("VK_EXT_descriptor_indexing") // 162
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT  = 0x00000002,
 }

 /// Pipeline vertex input state creation flags
 type VkFlags VkPipelineVertexInputStateCreateFlags
 //bitfield VkPipelineVertexInputStateCreateFlagBits {
 //}

 /// Pipeline input assembly state creation flags
 type VkFlags VkPipelineInputAssemblyStateCreateFlags
 //bitfield VkPipelineInputAssemblyStateCreateFlagBits {
 //}

 /// Tessellation state creation flags
 type VkFlags VkPipelineTessellationStateCreateFlags
 //bitfield VkPipelineTessellationStateCreateFlagBits {
 //}

 /// Viewport state creation flags
 type VkFlags VkPipelineViewportStateCreateFlags
 //bitfield VkPipelineViewportStateCreateFlagBits {
 //}

 /// Rasterization state creation flags
 type VkFlags VkPipelineRasterizationStateCreateFlags
 //bitfield VkPipelineRasterizationStateCreateFlagBits {
 //}

 /// Multisample state creation flags
 type VkFlags VkPipelineMultisampleStateCreateFlags
 //bitfield VkPipelineMultisampleStateCreateFlagBits {
 //}

 /// Color blend state creation flags
 type VkFlags VkPipelineColorBlendStateCreateFlags
 //bitfield VkPipelineColorBlendStateCreateFlagBits {
 //}

 /// Depth/stencil state creation flags
 type VkFlags VkPipelineDepthStencilStateCreateFlags
 //bitfield VkPipelineDepthStencilStateCreateFlagBits {
 //}

 /// Dynamic state creation flags
 type VkFlags VkPipelineDynamicStateCreateFlags
 //bitfield VkPipelineDynamicStateCreateFlagBits {
 //}

 /// Pipeline layout creation flags
 type VkFlags VkPipelineLayoutCreateFlags
 //bitfield VkPipelineLayoutCreateFlagBits {
 //}

 /// Sampler creation flags
 type VkFlags VkSamplerCreateFlags
 //bitfield VkSamplerCreateFlagBits {
 //}

 /// Render pass creation flags
 type VkFlags VkRenderPassCreateFlags
 //bitfield VkRenderPassCreateFlagBits {
 //}

 /// Framebuffer creation flags
 type VkFlags VkFramebufferCreateFlags
 //bitfield VkFramebufferCreateFlagBits {
 //}

 /// Dependency flags
 type VkFlags VkDependencyFlags
 bitfield VkDependencyFlagBits {
     VK_DEPENDENCY_BY_REGION_BIT                             = 0x00000001,

     //@vulkan1_1
     VK_DEPENDENCY_DEVICE_GROUP_BIT                          = 0x00000004,
     VK_DEPENDENCY_VIEW_LOCAL_BIT                            = 0x00000002,

     //@extension("VK_KHR_multiview") // 54
     VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR                        = 0x00000002,

     //@extension("VK_KHR_device_group") // 61
     VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR                      = 0x00000004,
 }

 /// Cull mode flags
 type VkFlags VkCullModeFlags
 bitfield VkCullModeFlagBits {
     VK_CULL_MODE_NONE                                       = 0x00000000,
     VK_CULL_MODE_FRONT_BIT                                  = 0x00000001,
     VK_CULL_MODE_BACK_BIT                                   = 0x00000002,
     VK_CULL_MODE_FRONT_AND_BACK                             = 0x00000003,
 }

 //@vulkan1_1 flags

 /// Subgroup feature flags
 type VkFlags VkSubgroupFeatureFlags
 bitfield VkSubgroupFeatureFlagBits {
     VK_SUBGROUP_FEATURE_BASIC_BIT                           = 0x00000001,
     VK_SUBGROUP_FEATURE_VOTE_BIT                            = 0x00000002,
     VK_SUBGROUP_FEATURE_ARITHMETIC_BIT                      = 0x00000004,
     VK_SUBGROUP_FEATURE_BALLOT_BIT                          = 0x00000008,
     VK_SUBGROUP_FEATURE_SHUFFLE_BIT                         = 0x00000010,
     VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT                = 0x00000020,
     VK_SUBGROUP_FEATURE_CLUSTERED_BIT                       = 0x00000040,
     VK_SUBGROUP_FEATURE_QUAD_BIT                            = 0x00000080,

     //@extension("VK_NV_shader_subgroup_partitioned") // 199
     VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV                  = 0x00000100,
 }

 /// Peer memory feature flags
 type VkFlags VkPeerMemoryFeatureFlags
 bitfield VkPeerMemoryFeatureFlagBits {
     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT                     = 0x00000001,
     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT                     = 0x00000002,
     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT                  = 0x00000004,
     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT                  = 0x00000008,
 }

 /// Memory allocation flags
 type VkFlags VkMemoryAllocateFlags
 bitfield VkMemoryAllocateFlagBits {
     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT                      = 0x00000001,
 }

 type VkFlags VkCommandPoolTrimFlags
 //bitfield VkCommandPoolTrimFlagBits {
 //}

 type VkFlags VkDescriptorUpdateTemplateCreateFlags
 //bitfield VkDescriptorUpdateTemplateCreateFlagBits {
 //}

 /// External memory handle type flags
 type VkFlags VkExternalMemoryHandleTypeFlags
 bitfield VkExternalMemoryHandleTypeFlagBits {
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT            = 0x00000001,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT         = 0x00000002,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT     = 0x00000004,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT        = 0x00000008,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT    = 0x00000010,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT           = 0x00000020,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT       = 0x00000040,

     //@extension("VK_EXT_external_memory_host") // 179
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT              = 0x00000080,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT   = 0x00000100,

     //@extension("VK_EXT_external_memory_dma_buf") // 126
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT                      = 0x00000200,

     //@extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID  = 0x00000400,
 }

 /// External memory feature flags
 type VkFlags VkExternalMemoryFeatureFlags
 bitfield VkExternalMemoryFeatureFlagBits {
     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT           = 0x00000001,
     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT               = 0x00000002,
     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT               = 0x00000004,
 }

 /// External fence handle type flags
 type VkFlags VkExternalFenceHandleTypeFlags
 bitfield VkExternalFenceHandleTypeFlagBits {
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT             = 0x00000001,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT          = 0x00000002,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT      = 0x00000004,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT               = 0x00000008,
 }

 /// External fence feature flags
 type VkFlags VkExternalFenceFeatureFlags
 bitfield VkExternalFenceFeatureFlagBits {
     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT                = 0x00000001,
     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT                = 0x00000002,
 }

 /// Fence import flags
 type VkFlags VkFenceImportFlags
 bitfield VkFenceImportFlagBits {
     VK_FENCE_IMPORT_TEMPORARY_BIT                           = 0x00000001,
 }

 /// Semaphore import flags
 type VkFlags VkSemaphoreImportFlags
 bitfield VkSemaphoreImportFlagBits {
     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT                       = 0x00000001,
 }

 /// External semaphore handle type flags
 type VkFlags VkExternalSemaphoreHandleTypeFlags
 bitfield VkExternalSemaphoreHandleTypeFlagBits {
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT         = 0x00000001,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT      = 0x00000002,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT  = 0x00000004,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT       = 0x00000008,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT           = 0x00000010,
 }

 /// External semaphore feature flags
 type VkFlags VkExternalSemaphoreFeatureFlags
 bitfield VkExternalSemaphoreFeatureFlagBits {
     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT            = 0x00000001,
     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT            = 0x00000002,
 }

 @extension("VK_KHR_surface") // 1
 type VkFlags VkSurfaceTransformFlagsKHR
 @extension("VK_KHR_surface") // 1
 bitfield VkSurfaceTransformFlagBitsKHR {
     VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR                       = 0x00000001,
     VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR                      = 0x00000002,
     VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR                     = 0x00000004,
     VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR                     = 0x00000008,
     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR              = 0x00000010,
     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR    = 0x00000020,
     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR   = 0x00000040,
     VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR   = 0x00000080,
     VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR                        = 0x00000100,
 }

 @extension("VK_KHR_surface") // 1
 type VkFlags VkCompositeAlphaFlagsKHR
 @extension("VK_KHR_surface") // 1
 bitfield VkCompositeAlphaFlagBitsKHR {
     VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR                       = 0x00000001,
     VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR               = 0x00000002,
     VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR              = 0x00000004,
     VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR                      = 0x00000008,
 }

 @extension("VK_KHR_swapchain") // 2
 type VkFlags VkSwapchainCreateFlagsKHR
 @extension("VK_KHR_swapchain") // 2
 bitfield VkSwapchainCreateFlagBitsKHR {
     //@vulkan1_1
     VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001,
     VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR                   = 0x00000002,
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 type VkFlags VkDeviceGroupPresentModeFlagsKHR
 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 bitfield VkDeviceGroupPresentModeFlagBitsKHR {
     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR              = 0x00000001,
     VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR             = 0x00000002,
     VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR                = 0x00000004,
     VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008,
 }

 @extension("VK_KHR_display") // 3
 type VkFlags VkDisplayPlaneAlphaFlagsKHR
 @extension("VK_KHR_display") // 3
 bitfield VkDisplayPlaneAlphaFlagBitsKHR {
     VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR                   = 0x00000001,
     VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR                   = 0x00000002,
     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR                = 0x00000004,
     VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR  = 0x00000008,
 }

 @extension("VK_KHR_display") // 3
 type VkFlags VkDisplaySurfaceCreateFlagsKHR
 //@extension("VK_KHR_display") // 3
 //bitfield VkDisplaySurfaceCreateFlagBitsKHR {
 //}

 @extension("VK_KHR_display") // 3
 type VkFlags VkDisplayModeCreateFlagsKHR
 //@extension("VK_KHR_display") // 3
 //bitfield VkDisplayModeCreateFlagBitsKHR {
 //}

 @extension("VK_KHR_xlib_surface") // 5
 type VkFlags VkXlibSurfaceCreateFlagsKHR
 //@extension("VK_KHR_xlib_surface") // 5
 //bitfield VkXlibSurfaceCreateFlagBitsKHR {
 //}

 @extension("VK_KHR_xcb_surface") // 6
 type VkFlags VkXcbSurfaceCreateFlagsKHR
 //@extension("VK_KHR_xcb_surface") // 6
 //bitfield VkXcbSurfaceCreateFlagBitsKHR {
 //}

 @extension("VK_KHR_wayland_surface") // 7
 type VkFlags VkWaylandSurfaceCreateFlagsKHR
 //@extension("VK_KHR_wayland_surface") // 7
 //bitfield VkWaylandSurfaceCreateFlagBitsKHR {
 //}

 @extension("VK_KHR_mir_surface") // 8
 type VkFlags VkMirSurfaceCreateFlagsKHR
 //@extension("VK_KHR_mir_surface") // 8
 //bitfield VkMirSurfaceCreateFlagBitsKHR {
 //}

 @extension("VK_KHR_android_surface") // 9
 type VkFlags VkAndroidSurfaceCreateFlagsKHR
 //@extension("VK_KHR_android_surface") // 9
 //bitfield VkAndroidSurfaceCreateFlagBitsKHR {
 //}

 @extension("VK_KHR_win32_surface") // 10
 type VkFlags VkWin32SurfaceCreateFlagsKHR
 //@extension("VK_KHR_win32_surface") // 10
 //bitfield VkWin32SurfaceCreateFlagBitsKHR {
 //}

 @extension("VK_ANDROID_native_buffer") // 11
 type VkFlags VkSwapchainImageUsageFlagsANDROID
 @extension("VK_ANDROID_native_buffer") // 11
 bitfield VkSwapchainImageUsageFlagBitsANDROID {
     VK_SWAPCHAIN_IMAGE_USAGE_FLAGS_SHARED_BIT_ANDROID = 0x00000001,
 }

 @extension("VK_EXT_debug_report") // 12
 type VkFlags VkDebugReportFlagsEXT
 @extension("VK_EXT_debug_report") // 12
 bitfield VkDebugReportFlagBitsEXT {
     VK_DEBUG_REPORT_INFORMATION_BIT_EXT                     = 0x00000001,
     VK_DEBUG_REPORT_WARNING_BIT_EXT                         = 0x00000002,
     VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT             = 0x00000004,
     VK_DEBUG_REPORT_ERROR_BIT_EXT                           = 0x00000008,
     VK_DEBUG_REPORT_DEBUG_BIT_EXT                           = 0x00000010,
 }

 @extension("VK_NV_external_memory_capabilities") // 56
 type VkFlags VkExternalMemoryHandleTypeFlagsNV
 @extension("VK_NV_external_memory_capabilities") // 56
 bitfield VkExternalMemoryHandleTypeFlagBitsNV {
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV      = 0x00000001,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV  = 0x00000002,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV       = 0x00000004,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV   = 0x00000008,
 }

 @extension("VK_NV_external_memory_capabilities") // 56
 type VkFlags VkExternalMemoryFeatureFlagsNV
 @extension("VK_NV_external_memory_capabilities") // 56
 bitfield VkExternalMemoryFeatureFlagBitsNV {
     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV        = 0x00000001,
     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV            = 0x00000002,
     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV            = 0x00000004,
 }

 @extension("VK_KHR_device_group") // 61
 type VkFlags VkPeerMemoryFeatureFlagsKHR
 @extension("VK_KHR_device_group") // 61
 bitfield VkPeerMemoryFeatureFlagBitsKHR {
     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR                 = 0x00000001,
     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR                 = 0x00000002,
     VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR              = 0x00000004,
     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR              = 0x00000008,
 }

 @extension("VK_KHR_device_group") // 61
 type VkFlags VkMemoryAllocateFlagsKHR
 @extension("VK_KHR_device_group") // 61
 bitfield VkMemoryAllocateFlagBitsKHR {
     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR                  = 0x00000001,
 }

 @extension("VK_NN_vi_surface") // 63
 type VkFlags VkViSurfaceCreateFlagsNN
 //@extension("VK_NN_vi_surface") // 63
 //bitfield VkViSurfaceCreateFlagBitsNN {
 //}

 @extension("VK_KHR_maintenance1") // 70
 type VkFlags VkCommandPoolTrimFlagsKHR
 //@extension("VK_KHR_maintenance1") // 70
 //bitfield VkCommandPoolTrimFlagBitsKHR {
 //}

 @extension("VK_KHR_external_memory_capabilities") // 72
 type VkFlags VkExternalMemoryHandleTypeFlagsKHR
 @extension("VK_KHR_external_memory_capabilities") // 72
 bitfield VkExternalMemoryHandleTypeFlagBitsKHR {
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR            = 0x00000001,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR         = 0x00000002,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR     = 0x00000004,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR        = 0x00000008,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR    = 0x00000010,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR           = 0x00000020,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR       = 0x00000040,
 }

 @extension("VK_KHR_external_memory_capabilities") // 72
 type VkFlags VkExternalMemoryFeatureFlagsKHR
 @extension("VK_KHR_external_memory_capabilities") // 72
 bitfield VkExternalMemoryFeatureFlagBitsKHR {
     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR           = 0x00000001,
     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR               = 0x00000002,
     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR               = 0x00000004,
 }

 @extension("VK_KHR_external_semaphore_capabilities") // 77
 type VkFlags VkExternalSemaphoreHandleTypeFlagsKHR
 @extension("VK_KHR_external_semaphore_capabilities") // 77
 bitfield VkExternalSemaphoreHandleTypeFlagBitsKHR {
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR         = 0x00000001
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR      = 0x00000002
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR  = 0x00000004
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR       = 0x00000008
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHR          = 0x00000010
 }

 @extension("VK_KHR_external_semaphore_capabilities") // 77
 type VkFlags VkExternalSemaphoreFeatureFlagsKHR
 @extension("VK_KHR_external_semaphore_capabilities") // 77
 bitfield VkExternalSemaphoreFeatureFlagBitsKHR {
     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR            = 0x00000001,
     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR            = 0x00000002,
 }

 @extension("VK_KHR_external_semaphore") // 78
 type VkFlags VkSemaphoreImportFlagsKHR
 @extension("VK_KHR_external_semaphore") // 78
 bitfield VkSemaphoreImportFlagBitsKHR {
     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR                       = 0x00000001,
 }

 @extension("VK_EXT_conditional_rendering") // 82
 type VkFlags VkConditionalRenderingFlagsEXT
 @extension("VK_EXT_conditional_rendering") // 82
 bitfield VkConditionalRenderingFlagBitsEXT {
     VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT                   = 0x00000001,
 }

 @extension("VK_KHR_descriptor_update_template") // 86
 type VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR
 //@extension("VK_KHR_descriptor_update_template") // 86
 //bitfield VkDescriptorUpdateTemplateCreateFlagBitsKHR {
 //}

 @extension("VK_NVX_device_generated_commands") // 87
 type VkFlags VkIndirectCommandsLayoutUsageFlagsNVX
 @extension("VK_NVX_device_generated_commands") // 87
 bitfield VkIndirectCommandsLayoutUsageFlagBitsNVX {
     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX   = 0x00000001,
     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX      = 0x00000002,
     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX      = 0x00000004,
     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX     = 0x00000008,
 }

 @extension("VK_NVX_device_generated_commands") // 87
 type VkFlags VkObjectEntryUsageFlagsNVX
 @extension("VK_NVX_device_generated_commands") // 87
 bitfield VkObjectEntryUsageFlagBitsNVX {
     VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX                  = 0x00000001,
     VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX                   = 0x00000002,
 }

 @extension("VK_EXT_display_surface_counter") // 91
 type VkFlags VkSurfaceCounterFlagsEXT
 @extension("VK_EXT_display_surface_counter") // 91
 bitfield VkSurfaceCounterFlagBitsEXT {
     VK_SURFACE_COUNTER_VBLANK_EXT                           = 0x00000001,
 }

 @extension("VK_NV_viewport_swizzle") // 99
 type VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV
 //@extension("VK_NV_viewport_swizzle") // 99
 //bitfield VkPipelineViewportSwizzleStateCreateFlagBitsNV {
 //}

 @extension("VK_EXT_discard_rectangles") // 100
 type VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT
 //@extension("VK_EXT_discard_rectangles") // 100
 //bitfield VkPipelineDiscardRectangleStateCreateFlagBitsEXT {
 //}

 @extension("VK_EXT_conservative_rasterization") // 102
 type VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT
 //@extension("VK_EXT_conservative_rasterization") // 102
 //bitfield VkPipelineRasterizationConservativeStateCreateFlagBitsEXT {
 //}

 @extension("VK_KHR_external_fence_capabilities") // 113
 type VkFlags VkExternalFenceHandleTypeFlagsKHR
 @extension("VK_KHR_external_fence_capabilities") // 113
 bitfield VkExternalFenceHandleTypeFlagBitsKHR {
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR         = 0x00000001,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR      = 0x00000002,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR  = 0x00000004,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR           = 0x00000008,
 }

 @extension("VK_KHR_external_fence_capabilities") // 113
 type VkFlags VkExternalFenceFeatureFlagsKHR
 @extension("VK_KHR_external_fence_capabilities") // 113
 bitfield VkExternalFenceFeatureFlagBitsKHR {
     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR            = 0x00000001,
     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR            = 0x00000002,
 }

 @extension("VK_KHR_external_fence") // 114
 type VkFlags VkFenceImportFlagsKHR
 @extension("VK_KHR_external_fence") // 114
 bitfield VkFenceImportFlagBitsKHR {
     VK_FENCE_IMPORT_TEMPORARY_BIT_KHR                       = 0x00000001,
 }

 @extension("VK_MVK_ios_surface") // 123
 type VkFlags VkIOSSurfaceCreateFlagsMVK
 //@extension("VK_MVK_ios_surface") // 123
 //bitfield VkIOSSurfaceCreateFlagBitsMVK {
 //}

 @extension("VK_MVK_macos_surface") // 124
 type VkFlags VkMacOSSurfaceCreateFlagsMVK
 //@extension("VK_MVK_macos_surface") // 124
 //bitfield VkMacOSSurfaceCreateFlagBitsMVK {
 //}

 @extension("VK_EXT_debug_utils") // 129
 type VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT
 //@extension("VK_EXT_debug_utils") // 129
 //bitfield VkDebugUtilsMessengerCallbackDataFlagBitsEXT {
 //}

 @extension("VK_EXT_debug_utils") // 129
 type VkFlags VkDebugUtilsMessengerCreateFlagsEXT
 //@extension("VK_EXT_debug_utils") // 129
 //bitfield VkDebugUtilsMessengerCreateFlagBitsEXT {
 //}

 @extension("VK_EXT_debug_utils") // 129
 type VkFlags VkDebugUtilsMessageSeverityFlagsEXT
 @extension("VK_EXT_debug_utils") // 129
 bitfield VkDebugUtilsMessageSeverityFlagBitsEXT {
     VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001,
     VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT    = 0x00000010,
     VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100,
     VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT   = 0x00001000,
 }

 @extension("VK_EXT_debug_utils") // 129
 type VkFlags VkDebugUtilsMessageTypeFlagsEXT
 @extension("VK_EXT_debug_utils") // 129
 bitfield VkDebugUtilsMessageTypeFlagBitsEXT {
     VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT     = 0x00000001,
     VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT  = 0x00000002,
     VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,
 }

 @extension("VK_NV_fragment_coverage_to_color") // 150
 type VkFlags VkPipelineCoverageToColorStateCreateFlagsNV
 @extension("VK_NV_fragment_coverage_to_color") // 150
 //bitfield VkPipelineCoverageToColorStateCreateFlagBitsNV {
 //}

 @extension("VK_NV_framebuffer_mixed_samples") // 153
 type VkFlags VkPipelineCoverageModulationStateCreateFlagsNV
 @extension("VK_NV_framebuffer_mixed_samples") // 153
 //bitfield VkPipelineCoverageModulationStateCreateFlagBitsNV {
 //}

 @extension("VK_EXT_validation_cache") // 161
 type VkFlags VkValidationCacheCreateFlagsEXT
 @extension("VK_EXT_validation_cache") // 161
 //bitfield VkValidationCacheCreateFlagBitsEXT {
 //}

 @extension("VK_EXT_descriptor_indexing") // 162
 type VkFlags VkDescriptorBindingFlagsEXT
 @extension("VK_EXT_descriptor_indexing") // 162
 bitfield VkDescriptorBindingFlagBitsEXT {
     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT             = 0x00000001,
     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT   = 0x00000002,
     VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT               = 0x00000004,
     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT     = 0x00000008,
 }

 @extension("VK_NVX_raytracing") // 166
 type VkFlags VkGeometryFlagsNVX
 @extension("VK_NVX_raytracing") // 166
 bitfield VkGeometryFlagBitsNVX {
     VK_GEOMETRY_OPAQUE_BIT_NVX                          = 0x00000001,
     VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NVX = 0x00000002,
 }

 @extension("VK_NVX_raytracing") // 166
 type VkFlags VkGeometryInstanceFlagsNVX
 @extension("VK_NVX_raytracing") // 166
 bitfield VkGeometryInstanceFlagBitsNVX {
     VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NVX      = 0x00000001,
     VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_FLIP_WINDING_BIT_NVX = 0x00000002,
     VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NVX               = 0x00000004,
     VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NVX            = 0x00000008,
 }

 @extension("VK_NVX_raytracing") // 166
 type VkFlags VkBuildAccelerationStructureFlagsNVX
 @extension("VK_NVX_raytracing") // 166
 bitfield VkBuildAccelerationStructureFlagBitsNVX {
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NVX        = 0x00000001,
     VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NVX    = 0x00000002,
     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NVX   = 0x00000004,
     VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NVX   = 0x00000008,
     VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NVX          = 0x00000010,
 }

 //////////////////
 //  Structures  //
 //////////////////

 class VkOffset2D {
     s32                                         x
     s32                                         y
 }

 class VkOffset3D {
     s32                                         x
     s32                                         y
     s32                                         z
 }

 class VkExtent2D {
     u32                                         width
     u32                                         height
 }

 class VkExtent3D {
     u32                                         width
     u32                                         height
     u32                                         depth
 }

 class VkViewport {
     f32                                         x
     f32                                         y
     f32                                         width
     f32                                         height
     f32                                         minDepth
     f32                                         maxDepth
 }

 class VkRect2D {
     VkOffset2D                                  offset
     VkExtent2D                                  extent
 }

 class VkClearRect {
     VkRect2D                                    rect
     u32                                         baseArrayLayer
     u32                                         layerCount
 }

 class VkComponentMapping {
     VkComponentSwizzle                          r
     VkComponentSwizzle                          g
     VkComponentSwizzle                          b
     VkComponentSwizzle                          a
 }

 class VkPhysicalDeviceProperties {
     u32                                         apiVersion
     u32                                         driverVersion
     u32                                         vendorID
     u32                                         deviceID
     VkPhysicalDeviceType                        deviceType
     char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]      deviceName
     u8[VK_UUID_SIZE]                            pipelineCacheUUID
     VkPhysicalDeviceLimits                      limits
     VkPhysicalDeviceSparseProperties            sparseProperties
 }

 class VkExtensionProperties {
     char[VK_MAX_EXTENSION_NAME_SIZE]            extensionName      /// extension name
     u32                                         specVersion        /// version of the extension specification implemented
 }

 class VkLayerProperties {
     char[VK_MAX_EXTENSION_NAME_SIZE]            layerName               /// layer name
     u32                                         specVersion             /// version of the layer specification implemented
     u32                                         implementationVersion   /// build or release version of the layer's library
     char[VK_MAX_DESCRIPTION_SIZE]               description             /// Free-form description of the layer
 }

 class VkSubmitInfo {
     VkStructureType                             sType              /// Type of structure. Should be VK_STRUCTURE_TYPE_SUBMIT_INFO
     const void*                                 pNext              /// Next structure in chain
     u32                                         waitSemaphoreCount
     const VkSemaphore*                          pWaitSemaphores
     const VkPipelineStageFlags*                 pWaitDstStageMask
     u32                                         commandBufferCount
     const VkCommandBuffer*                      pCommandBuffers
     u32                                         signalSemaphoreCount
     const VkSemaphore*                          pSignalSemaphores
 }

 class VkApplicationInfo {
     VkStructureType                             sType              /// Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO
     const void*                                 pNext              /// Next structure in chain
     const char*                                 pApplicationName
     u32                                         applicationVersion
     const char*                                 pEngineName
     u32                                         engineVersion
     u32                                         apiVersion
 }

 class VkAllocationCallbacks {
     void*                                       pUserData
     PFN_vkAllocationFunction                    pfnAllocation
     PFN_vkReallocationFunction                  pfnReallocation
     PFN_vkFreeFunction                          pfnFree
     PFN_vkInternalAllocationNotification        pfnInternalAllocation
     PFN_vkInternalFreeNotification              pfnInternalFree
 }

 class VkDeviceQueueCreateInfo {
     VkStructureType                             sStype                    /// Should be VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
     const void*                                 pNext                     /// Pointer to next structure
     VkDeviceQueueCreateFlags                    flags
     u32                                         queueFamilyIndex
     u32                                         queueCount
     const f32*                                  pQueuePriorities
 }

 class VkDeviceCreateInfo {
     VkStructureType                             sType                      /// Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
     const void*                                 pNext                      /// Pointer to next structure
     VkDeviceCreateFlags                         flags
     u32                                         queueCreateInfoCount
     const VkDeviceQueueCreateInfo*              pQueueCreateInfos
     u32                                         enabledLayerCount
     const char* const*                          ppEnabledLayerNames        /// Ordered list of layer names to be enabled
     u32                                         enabledExtensionCount
     const char* const*                          ppEnabledExtensionNames
     const VkPhysicalDeviceFeatures*             pEnabledFeatures
 }

 class VkInstanceCreateInfo {
     VkStructureType                             sType                      /// Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
     const void*                                 pNext                      /// Pointer to next structure
     VkInstanceCreateFlags                       flags
     const VkApplicationInfo*                    pApplicationInfo
     u32                                         enabledLayerCount
     const char* const*                          ppEnabledLayerNames        /// Ordered list of layer names to be enabled
     u32                                         enabledExtensionCount
     const char* const*                          ppEnabledExtensionNames    /// Extension names to be enabled
 }

 class VkQueueFamilyProperties {
     VkQueueFlags                                queueFlags                 /// Queue flags
     u32                                         queueCount
     u32                                         timestampValidBits
     VkExtent3D                                  minImageTransferGranularity
 }

 class VkPhysicalDeviceMemoryProperties {
     u32                                         memoryTypeCount
     VkMemoryType[VK_MAX_MEMORY_TYPES]           memoryTypes
     u32                                         memoryHeapCount
     VkMemoryHeap[VK_MAX_MEMORY_HEAPS]           memoryHeaps
 }

 class VkMemoryAllocateInfo {
     VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
     const void*                                 pNext                      /// Pointer to next structure
     VkDeviceSize                                allocationSize             /// Size of memory allocation
     u32                                         memoryTypeIndex            /// Index of the of the memory type to allocate from
 }

 class VkMemoryRequirements {
     VkDeviceSize                                size                       /// Specified in bytes
     VkDeviceSize                                alignment                  /// Specified in bytes
     u32                                         memoryTypeBits             /// Bitfield of the allowed memory type indices into memoryTypes[] for this object
 }

 class VkSparseImageFormatProperties {
     VkImageAspectFlagBits                       aspectMask
     VkExtent3D                                  imageGranularity
     VkSparseImageFormatFlags                    flags
 }

 class VkSparseImageMemoryRequirements {
     VkSparseImageFormatProperties               formatProperties
     u32                                         imageMipTailFirstLod
     VkDeviceSize                                imageMipTailSize           /// Specified in bytes, must be a multiple of image block size / alignment
     VkDeviceSize                                imageMipTailOffset         /// Specified in bytes, must be a multiple of image block size / alignment
     VkDeviceSize                                imageMipTailStride         /// Specified in bytes, must be a multiple of image block size / alignment
 }

 class VkMemoryType {
     VkMemoryPropertyFlags                       propertyFlags              /// Memory properties of this memory type
     u32                                         heapIndex                  /// Index of the memory heap allocations of this memory type are taken from
 }

 class VkMemoryHeap {
     VkDeviceSize                                size                       /// Available memory in the heap
     VkMemoryHeapFlags                           flags                      /// Flags for the heap
 }

 class VkMappedMemoryRange {
     VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
     const void*                                 pNext                      /// Pointer to next structure
     VkDeviceMemory                              memory                     /// Mapped memory object
     VkDeviceSize                                offset                     /// Offset within the mapped memory the range starts from
     VkDeviceSize                                size                       /// Size of the range within the mapped memory
 }

 class VkFormatProperties {
     VkFormatFeatureFlags                        linearTilingFeatures       /// Format features in case of linear tiling
     VkFormatFeatureFlags                        optimalTilingFeatures      /// Format features in case of optimal tiling
     VkFormatFeatureFlags                        bufferFeatures             /// Format features supported by buffers
 }

 class VkImageFormatProperties {
     VkExtent3D                                  maxExtent                  /// max image dimensions for this resource type
     u32                                         maxMipLevels               /// max number of mipmap levels for this resource type
     u32                                         maxArrayLayers             /// max array layers for this resource type
     VkSampleCountFlags                          sampleCounts               /// supported sample counts for this resource type
     VkDeviceSize                                maxResourceSize            /// max size (in bytes) of this resource type
 }

 class VkDescriptorImageInfo {
     VkSampler                                   sampler
     VkImageView                                 imageView
     VkImageLayout                               imageLayout
 }

 class VkDescriptorBufferInfo {
     VkBuffer                                    buffer                     /// Buffer used for this descriptor when the descriptor is UNIFORM_BUFFER[_DYNAMIC]
     VkDeviceSize                                offset                     /// Base offset from buffer start in bytes to update in the descriptor set.
     VkDeviceSize                                range                      /// Size in bytes of the buffer resource for this descriptor update.
 }

 class VkWriteDescriptorSet {
     VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
     const void*                                 pNext                      /// Pointer to next structure
     VkDescriptorSet                             dstSet                     /// Destination descriptor set
     u32                                         dstBinding                 /// Binding within the destination descriptor set to write
     u32                                         dstArrayElement            /// Array element within the destination binding to write
     u32                                         descriptorCount            /// Number of descriptors to write (determines the size of the array pointed by <pDescriptors>)
     VkDescriptorType                            descriptorType             /// Descriptor type to write (determines which fields of the array pointed by <pDescriptors> are going to be used)
     const VkDescriptorImageInfo*                pImageInfo
     const VkDescriptorBufferInfo*               pBufferInfo
     const VkBufferView*                         pTexelBufferView
 }

 class VkCopyDescriptorSet {
     VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET
     const void*                                 pNext                      /// Pointer to next structure
     VkDescriptorSet                             srcSet                     /// Source descriptor set
     u32                                         srcBinding                 /// Binding within the source descriptor set to copy from
     u32                                         srcArrayElement            /// Array element within the source binding to copy from
     VkDescriptorSet                             dstSet                     /// Destination descriptor set
     u32                                         dstBinding                 /// Binding within the destination descriptor set to copy to
     u32                                         dstArrayElement            /// Array element within the destination binding to copy to
     u32                                         descriptorCount            /// Number of descriptors to copy
 }

 class VkBufferCreateInfo {
     VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
     const void*                                 pNext                      /// Pointer to next structure.
     VkBufferCreateFlags                         flags                      /// Buffer creation flags
     VkDeviceSize                                size                       /// Specified in bytes
     VkBufferUsageFlags                          usage                      /// Buffer usage flags
     VkSharingMode                               sharingMode
     u32                                         queueFamilyIndexCount
     const u32*                                  pQueueFamilyIndices
 }

 class VkBufferViewCreateInfo {
     VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
     const void*                                 pNext                      /// Pointer to next structure.
     VkBufferViewCreateFlags                     flags
     VkBuffer                                    buffer
     VkFormat                                    format                     /// Optionally specifies format of elements
     VkDeviceSize                                offset                     /// Specified in bytes
     VkDeviceSize                                range                      /// View size specified in bytes
 }

 class VkImageSubresource {
     VkImageAspectFlagBits                       aspectMask
     u32                                         mipLevel
     u32                                         arrayLayer
 }

 class VkImageSubresourceRange {
     VkImageAspectFlags                          aspectMask
     u32                                         baseMipLevel
     u32                                         levelCount
     u32                                         baseArrayLayer
     u32                                         layerCount
 }

 class VkMemoryBarrier {
     VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER
     const void*                                 pNext                      /// Pointer to next structure.
     VkAccessFlags                               srcAccessMask
     VkAccessFlags                               dstAccessMask
 }

 class VkBufferMemoryBarrier {
     VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
     const void*                                 pNext                      /// Pointer to next structure.
     VkAccessFlags                               srcAccessMask
     VkAccessFlags                               dstAccessMask
     u32                                         srcQueueFamilyIndex        /// Queue family to transition ownership from
     u32                                         dstQueueFamilyIndex        /// Queue family to transition ownership to
     VkBuffer                                    buffer                     /// Buffer to sync
     VkDeviceSize                                offset                     /// Offset within the buffer to sync
     VkDeviceSize                                size                       /// Amount of bytes to sync
 }

 class VkImageMemoryBarrier {
     VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
     const void*                                 pNext                      /// Pointer to next structure.
     VkAccessFlags                               srcAccessMask
     VkAccessFlags                               dstAccessMask
     VkImageLayout                               oldLayout                  /// Current layout of the image
     VkImageLayout                               newLayout                  /// New layout to transition the image to
     u32                                         srcQueueFamilyIndex        /// Queue family to transition ownership from
     u32                                         dstQueueFamilyIndex        /// Queue family to transition ownership to
     VkImage                                     image                      /// Image to sync
     VkImageSubresourceRange                     subresourceRange           /// Subresource range to sync
 }

 class VkImageCreateInfo {
     VkStructureType                             sType                      /// Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
     const void*                                 pNext                      /// Pointer to next structure.
     VkImageCreateFlags                          flags                      /// Image creation flags
     VkImageType                                 imageType
     VkFormat                                    format
     VkExtent3D                                  extent
     u32                                         mipLevels
     u32                                         arrayLayers
     VkSampleCountFlagBits                       samples
     VkImageTiling                               tiling
     VkImageUsageFlags                           usage                      /// Image usage flags
     VkSharingMode                               sharingMode                /// Cross-queue-family sharing mode
     u32                                         queueFamilyIndexCount      /// Number of queue families to share across
     const u32*                                  pQueueFamilyIndices        /// Array of queue family indices to share across
     VkImageLayout                               initialLayout              /// Initial image layout for all subresources
 }

 class VkSubresourceLayout {
     VkDeviceSize                                offset                 /// Specified in bytes
     VkDeviceSize                                size                   /// Specified in bytes
     VkDeviceSize                                rowPitch               /// Specified in bytes
     VkDeviceSize                                arrayPitch             /// Specified in bytes
     VkDeviceSize                                depthPitch             /// Specified in bytes
 }

 class VkImageViewCreateInfo {
     VkStructureType                             sType                  /// Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
     const void*                                 pNext                  /// Pointer to next structure
     VkImageViewCreateFlags                      flags
     VkImage                                     image
     VkImageViewType                             viewType
     VkFormat                                    format
     VkComponentMapping                          components
     VkImageSubresourceRange                     subresourceRange
 }

 class VkBufferCopy {
     VkDeviceSize                                srcOffset              /// Specified in bytes
     VkDeviceSize                                dstOffset              /// Specified in bytes
     VkDeviceSize                                size                   /// Specified in bytes
 }

 class VkSparseMemoryBind {
     VkDeviceSize                                resourceOffset        /// Specified in bytes
     VkDeviceSize                                size                  /// Specified in bytes
     VkDeviceMemory                              memory
     VkDeviceSize                                memoryOffset          /// Specified in bytes
     VkSparseMemoryBindFlags                     flags
 }

 class VkSparseImageMemoryBind {
     VkImageSubresource                          subresource
     VkOffset3D                                  offset
     VkExtent3D                                  extent
     VkDeviceMemory                              memory
     VkDeviceSize                                memoryOffset          /// Specified in bytes
     VkSparseMemoryBindFlags                     flags
 }

 class VkSparseBufferMemoryBindInfo {
     VkBuffer                                    buffer
     u32                                         bindCount
     const VkSparseMemoryBind*                   pBinds
 }

 class VkSparseImageOpaqueMemoryBindInfo {
     VkImage                                     image
     u32                                         bindCount
     const VkSparseMemoryBind*                   pBinds
 }

 class VkSparseImageMemoryBindInfo {
     VkImage                                     image
     u32                                         bindCount
     const VkSparseMemoryBind*                   pBinds
 }

 class VkBindSparseInfo {
     VkStructureType                             sType                 /// Must be VK_STRUCTURE_TYPE_BIND_SPARSE_INFO
     const void*                                 pNext
     u32                                         waitSemaphoreCount
     const VkSemaphore*                          pWaitSemaphores
     u32                                         numBufferBinds
     const VkSparseBufferMemoryBindInfo*         pBufferBinds
     u32                                         numImageOpaqueBinds
     const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds
     u32                                         numImageBinds
     const VkSparseImageMemoryBindInfo*          pImageBinds
     u32                                         signalSemaphoreCount
     const VkSemaphore*                          pSignalSemaphores
 }

 class VkImageSubresourceLayers {
     VkImageAspectFlags                          aspectMask
     u32                                         mipLevel
     u32                                         baseArrayLayer
     u32                                         layerCount
 }

 class VkImageCopy {
     VkImageSubresourceLayers                    srcSubresource
     VkOffset3D                                  srcOffset             /// Specified in pixels for both compressed and uncompressed images
     VkImageSubresourceLayers                    dstSubresource
     VkOffset3D                                  dstOffset             /// Specified in pixels for both compressed and uncompressed images
     VkExtent3D                                  extent                /// Specified in pixels for both compressed and uncompressed images
 }

 class VkImageBlit {
     VkImageSubresourceLayers                    srcSubresource
     VkOffset3D[2]                               srcOffsets
     VkImageSubresourceLayers                    dstSubresource
     VkOffset3D[2]                               dstOffsets
 }

 class VkBufferImageCopy {
     VkDeviceSize                                bufferOffset           /// Specified in bytes
     u32                                         bufferRowLength        /// Specified in texels
     u32                                         bufferImageHeight
     VkImageSubresourceLayers                    imageSubresource
     VkOffset3D                                  imageOffset            /// Specified in pixels for both compressed and uncompressed images
     VkExtent3D                                  imageExtent            /// Specified in pixels for both compressed and uncompressed images
 }

 class VkImageResolve {
     VkImageSubresourceLayers                    srcSubresource
     VkOffset3D                                  srcOffset
     VkImageSubresourceLayers                    dstSubresource
     VkOffset3D                                  dstOffset
     VkExtent3D                                  extent
 }

 class VkShaderModuleCreateInfo {
     VkStructureType                             sType                  /// Must be VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
     const void*                                 pNext                  /// Pointer to next structure
     VkShaderModuleCreateFlags                   flags                  /// Reserved
     platform.size_t                             codeSize               /// Specified in bytes
     const u32*                                  pCode                  /// Binary code of size codeSize
 }

 class VkDescriptorSetLayoutBinding {
     u32                                         binding
     VkDescriptorType                            descriptorType     /// Type of the descriptors in this binding
     u32                                         descriptorCount    /// Number of descriptors in this binding
     VkShaderStageFlags                          stageFlags         /// Shader stages this binding is visible to
     const VkSampler*                            pImmutableSamplers /// Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains <count> number of elements)
 }

 class VkDescriptorSetLayoutCreateInfo {
     VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
     const void*                                 pNext              /// Pointer to next structure
     VkDescriptorSetLayoutCreateFlags            flags
     u32                                         bindingCount       /// Number of bindings in the descriptor set layout
     const VkDescriptorSetLayoutBinding*         pBindings          /// Array of descriptor set layout bindings
 }

 class VkDescriptorPoolSize {
     VkDescriptorType                            type
     u32                                         descriptorCount
 }

 class VkDescriptorPoolCreateInfo {
     VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
     const void*                                 pNext              /// Pointer to next structure
     VkDescriptorPoolCreateFlags                 flags
     u32                                         maxSets
     u32                                         poolSizeCount
     const VkDescriptorPoolSize*                 pPoolSizes
 }

 class VkDescriptorSetAllocateInfo {
     VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
     const void*                                 pNext              /// Pointer to next structure
     VkDescriptorPool                            descriptorPool
     u32                                         setCount
     const VkDescriptorSetLayout*                pSetLayouts
 }

 class VkSpecializationMapEntry {
     u32                                         constantID         /// The SpecConstant ID specified in the BIL
     u32                                         offset             /// Offset of the value in the data block
     platform.size_t                             size               /// Size in bytes of the SpecConstant
 }

 class VkSpecializationInfo {
     u32                                         mapEntryCount      /// Number of entries in the map
     const VkSpecializationMapEntry*             pMapEntries        /// Array of map entries
     platform.size_t                             dataSize           /// Size in bytes of pData
     const void*                                 pData              /// Pointer to SpecConstant data
 }

 class VkPipelineShaderStageCreateInfo {
     VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
     const void*                                 pNext              /// Pointer to next structure
     VkPipelineShaderStageCreateFlags            flags
     VkShaderStageFlagBits                       stage
     VkShaderModule                              module
     const char*                                 pName
     const VkSpecializationInfo*                 pSpecializationInfo
 }

 class VkComputePipelineCreateInfo {
     VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
     const void*                                 pNext              /// Pointer to next structure
     VkPipelineCreateFlags                       flags              /// Pipeline creation flags
     VkPipelineShaderStageCreateInfo             stage
     VkPipelineLayout                            layout             /// Interface layout of the pipeline
     VkPipeline                                  basePipelineHandle /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
     s32                                         basePipelineIndex  /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
 }

 class VkVertexInputBindingDescription {
     u32                                         binding               /// Vertex buffer binding id
     u32                                         stride                /// Distance between vertices in bytes (0 = no advancement)
     VkVertexInputRate                           inputRate             /// Rate at which binding is incremented
 }

 class VkVertexInputAttributeDescription {
     u32                                         location              /// location of the shader vertex attrib
     u32                                         binding               /// Vertex buffer binding id
     VkFormat                                    format                /// format of source data
     u32                                         offset                /// Offset of first element in bytes from base of vertex
 }

 class VkPipelineVertexInputStateCreateInfo {
     VkStructureType                             sType                           /// Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
     const void*                                 pNext                           /// Pointer to next structure
     VkPipelineVertexInputStateCreateFlags       flags
     u32                                         vertexBindingDescriptionCount   /// number of bindings
     const VkVertexInputBindingDescription*      pVertexBindingDescriptions
     u32                                         vertexAttributeDescriptionCount /// number of attributes
     const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions
 }

 class VkPipelineInputAssemblyStateCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkPipelineInputAssemblyStateCreateFlags     flags
     VkPrimitiveTopology                         topology
     VkBool32                                    primitiveRestartEnable
 }

 class VkPipelineTessellationStateCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkPipelineTessellationStateCreateFlags      flags
     u32                                         patchControlPoints
 }

 class VkPipelineViewportStateCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkPipelineViewportStateCreateFlags          flags
     u32                                         viewportCount
     const VkViewport*                           pViewports
     u32                                         scissorCount
     const VkRect2D*                             pScissors
 }

 class VkPipelineRasterizationStateCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkPipelineRasterizationStateCreateFlags     flags
     VkBool32                                    depthClampEnable
     VkBool32                                    rasterizerDiscardEnable
     VkPolygonMode                               polygonMode                   /// optional (GL45)
     VkCullModeFlags                             cullMode
     VkFrontFace                                 frontFace
     VkBool32                                    depthBiasEnable
     f32                                         depthBiasConstantFactor
     f32                                         depthBiasClamp
     f32                                         depthBiasSlopeFactor
     f32                                         lineWidth
 }

 class VkPipelineMultisampleStateCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkPipelineMultisampleStateCreateFlags       flags
     VkSampleCountFlagBits                       rasterizationSamples       /// Number of samples used for rasterization
     VkBool32                                    sampleShadingEnable        /// optional (GL45)
     f32                                         minSampleShading           /// optional (GL45)
     const VkSampleMask*                         pSampleMask
     VkBool32                                    alphaToCoverageEnable
     VkBool32                                    alphaToOneEnable
 }

 class VkPipelineColorBlendAttachmentState {
     VkBool32                                    blendEnable
     VkBlendFactor                               srcColorBlendFactor
     VkBlendFactor                               dstColorBlendFactor
     VkBlendOp                                   colorBlendOp
     VkBlendFactor                               srcAlphaBlendFactor
     VkBlendFactor                               dstAlphaBlendFactor
     VkBlendOp                                   alphaBlendOp
     VkColorComponentFlags                       colorWriteMask
 }

 class VkPipelineColorBlendStateCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkPipelineColorBlendStateCreateFlags        flags
     VkBool32                                    logicOpEnable
     VkLogicOp                                   logicOp
     u32                                         attachmentCount    /// # of pAttachments
     const VkPipelineColorBlendAttachmentState*  pAttachments
     f32[4]                                      blendConstants
 }

 class VkStencilOpState {
     VkStencilOp                                 failOp
     VkStencilOp                                 passOp
     VkStencilOp                                 depthFailOp
     VkCompareOp                                 compareOp
     u32                                         compareMask
     u32                                         writeMask
     u32                                         reference
 }

 class VkPipelineDepthStencilStateCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkPipelineDepthStencilStateCreateFlags      flags
     VkBool32                                    depthTestEnable
     VkBool32                                    depthWriteEnable
     VkCompareOp                                 depthCompareOp
     VkBool32                                    depthBoundsTestEnable  /// optional (depth_bounds_test)
     VkBool32                                    stencilTestEnable
     VkStencilOpState                            front
     VkStencilOpState                            back
     f32                                         minDepthBounds
     f32                                         maxDepthBounds
 }

 class VkPipelineDynamicStateCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkPipelineDynamicStateCreateFlags           flags
     u32                                         dynamicStateCount
     const VkDynamicState*                       pDynamicStates
 }

 class VkGraphicsPipelineCreateInfo {
     VkStructureType                                 sType               /// Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
     const void*                                     pNext               /// Pointer to next structure
     VkPipelineCreateFlags                           flags               /// Pipeline creation flags
     u32                                             stageCount
     const VkPipelineShaderStageCreateInfo*          pStages             /// One entry for each active shader stage
     const VkPipelineVertexInputStateCreateInfo*     pVertexInputState
     const VkPipelineInputAssemblyStateCreateInfo*   pInputAssemblyState
     const VkPipelineTessellationStateCreateInfo*    pTessellationState
     const VkPipelineViewportStateCreateInfo*        pViewportState
     const VkPipelineRasterizationStateCreateInfo*   pRasterizationState
     const VkPipelineMultisampleStateCreateInfo*     pMultisampleState
     const VkPipelineDepthStencilStateCreateInfo*    pDepthStencilState
     const VkPipelineColorBlendStateCreateInfo*      pColorBlendState
     const VkPipelineDynamicStateCreateInfo*         pDynamicState
     VkPipelineLayout                                layout              /// Interface layout of the pipeline
     VkRenderPass                                    renderPass
     u32                                             subpass
     VkPipeline                                      basePipelineHandle  /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
     s32                                             basePipelineIndex   /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
 }

 class VkPipelineCacheCreateInfo {
     VkStructureType                             sType                 /// Must be VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
     const void*                                 pNext                 /// Pointer to next structure
     VkPipelineCacheCreateFlags                  flags
     platform.size_t                             initialDataSize       /// Size of initial data to populate cache, in bytes
     const void*                                 pInitialData          /// Initial data to populate cache
 }

 class VkPushConstantRange {
     VkShaderStageFlags                          stageFlags   /// Which stages use the range
     u32                                         offset       /// Start of the range, in bytes
     u32                                         size        /// Length of the range, in bytes
 }

 class VkPipelineLayoutCreateInfo {
     VkStructureType                             sType                   /// Must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
     const void*                                 pNext                   /// Pointer to next structure
     VkPipelineLayoutCreateFlags                 flags
     u32                                         descriptorSetCount      /// Number of descriptor sets interfaced by the pipeline
     const VkDescriptorSetLayout*                pSetLayouts             /// Array of <setCount> number of descriptor set layout objects defining the layout of the
     u32                                         pushConstantRangeCount  /// Number of push-constant ranges used by the pipeline
     const VkPushConstantRange*                  pPushConstantRanges     /// Array of pushConstantRangeCount number of ranges used by various shader stages
 }

 class VkSamplerCreateInfo {
     VkStructureType                             sType          /// Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
     const void*                                 pNext          /// Pointer to next structure
     VkSamplerCreateFlags                        flags
     VkFilter                                    magFilter      /// Filter mode for magnification
     VkFilter                                    minFilter      /// Filter mode for minifiation
     VkSamplerMipmapMode                         mipmapMode     /// Mipmap selection mode
     VkSamplerAddressMode                        addressModeU
     VkSamplerAddressMode                        addressModeV
     VkSamplerAddressMode                        addressModeW
     f32                                         mipLodBias
     VkBool32                                    anisotropyEnable
     f32                                         maxAnisotropy
     VkBool32                                    compareEnable
     VkCompareOp                                 compareOp
     f32                                         minLod
     f32                                         maxLod
     VkBorderColor                               borderColor
     VkBool32                                    unnormalizedCoordinates
 }

 class VkCommandPoolCreateInfo {
     VkStructureType                             sType            /// Must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
     const void*                                 pNext            /// Pointer to next structure
     VkCommandPoolCreateFlags                    flags            /// Command pool creation flags
     u32                                         queueFamilyIndex
 }

 class VkCommandBufferAllocateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkCommandPool                               commandPool
     VkCommandBufferLevel                        level
     u32                                         commandBufferCount
 }

 class VkCommandBufferInheritanceInfo {
     VkStructureType                             sType       /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
     const void*                                 pNext       /// Pointer to next structure
     VkRenderPass                                renderPass  /// Render pass for secondary command buffers
     u32                                         subpass
     VkFramebuffer                               framebuffer /// Framebuffer for secondary command buffers
     VkBool32                                    occlusionQueryEnable
     VkQueryControlFlags                         queryFlags
     VkQueryPipelineStatisticFlags               pipelineStatistics
 }

 class VkCommandBufferBeginInfo {
     VkStructureType                             sType       /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
     const void*                                 pNext       /// Pointer to next structure
     VkCommandBufferUsageFlags                   flags       /// Command buffer usage flags
     const VkCommandBufferInheritanceInfo*       pInheritanceInfo
 }

 class VkRenderPassBeginInfo {
     VkStructureType                             sType       /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
     const void*                                 pNext       /// Pointer to next structure
     VkRenderPass                                renderPass
     VkFramebuffer                               framebuffer
     VkRect2D                                    renderArea
     u32                                         clearValueCount
     const VkClearValue*                         pClearValues
 }

 @union
 /// Union allowing specification of floating point, integer, or unsigned integer color data. Actual value selected is based on image/attachment being cleared.
 class VkClearColorValue {
     f32[4]                                      float32
     s32[4]                                      int32
     u32[4]                                      uint32
 }

 class VkClearDepthStencilValue {
     f32                                         depth
     u32                                         stencil
 }

 @union
 /// Union allowing specification of color, depth, and stencil color values. Actual value selected is based on attachment being cleared.
 class VkClearValue {
     VkClearColorValue                           color
     VkClearDepthStencilValue                    depthStencil
 }

 class VkClearAttachment {
     VkImageAspectFlags                          aspectMask
     u32                                         colorAttachment
     VkClearValue                                clearValue
 }

 class VkAttachmentDescription {
     VkAttachmentDescriptionFlags                flags
     VkFormat                                    format
     VkSampleCountFlagBits                       samples
     VkAttachmentLoadOp                          loadOp          /// Load op for color or depth data
     VkAttachmentStoreOp                         storeOp         /// Store op for color or depth data
     VkAttachmentLoadOp                          stencilLoadOp   /// Load op for stencil data
     VkAttachmentStoreOp                         stencilStoreOp  /// Store op for stencil data
     VkImageLayout                               initialLayout
     VkImageLayout                               finalLayout
 }

 class VkAttachmentReference {
     u32                                         attachment
     VkImageLayout                               layout
 }

 class VkSubpassDescription {
     VkSubpassDescriptionFlags                   flags
     VkPipelineBindPoint                         pipelineBindPoint  /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now
     u32                                         inputAttachmentCount
     const VkAttachmentReference*                pInputAttachments
     u32                                         colorAttachmentCount
     const VkAttachmentReference*                pColorAttachments
     const VkAttachmentReference*                pResolveAttachments
     const VkAttachmentReference*                pDepthStencilAttachment
     u32                                         preserveAttachmentCount
     const u32*                                  pPreserveAttachments
 }

 class VkSubpassDependency {
     u32                                         srcSubpass
     u32                                         dstSubpass
     VkPipelineStageFlags                        srcStageMask
     VkPipelineStageFlags                        dstStageMask
     VkAccessFlags                               srcAccessMask
     VkAccessFlags                               dstAccessMask
     VkDependencyFlags                           dependencyFlags
 }

 class VkRenderPassCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkRenderPassCreateFlags                     flags
     u32                                         attachmentCount
     const VkAttachmentDescription*              pAttachments
     u32                                         subpassCount
     const VkSubpassDescription*                 pSubpasses
     u32                                         dependencyCount
     const VkSubpassDependency*                  pDependencies
 }

 class VkEventCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkEventCreateFlags                          flags      /// Event creation flags
 }

 class VkFenceCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkFenceCreateFlags                          flags      /// Fence creation flags
 }

 class VkPhysicalDeviceFeatures {
     VkBool32                                    robustBufferAccess                        /// out of bounds buffer accesses are well defined
     VkBool32                                    fullDrawIndexUint32                       /// full 32-bit range of indices for indexed draw calls
     VkBool32                                    imageCubeArray                            /// image views which are arrays of cube maps
     VkBool32                                    independentBlend                          /// blending operations are controlled per-attachment
     VkBool32                                    geometryShader                            /// geometry stage
     VkBool32                                    tessellationShader                        /// tessellation control and evaluation stage
     VkBool32                                    sampleRateShading                         /// per-sample shading and interpolation
     VkBool32                                    dualSrcBlend                              /// blend operations which take two sources
     VkBool32                                    logicOp                                   /// logic operations
     VkBool32                                    multiDrawIndirect                         /// multi draw indirect
     VkBool32                                    drawIndirectFirstInstance
     VkBool32                                    depthClamp                                /// depth clamping
     VkBool32                                    depthBiasClamp                            /// depth bias clamping
     VkBool32                                    fillModeNonSolid                          /// point and wireframe fill modes
     VkBool32                                    depthBounds                               /// depth bounds test
     VkBool32                                    wideLines                                 /// lines with width greater than 1
     VkBool32                                    largePoints                               /// points with size greater than 1
     VkBool32                                    alphaToOne                                /// The fragment alpha channel can be forced to maximum representable alpha value
     VkBool32                                    multiViewport
     VkBool32                                    samplerAnisotropy
     VkBool32                                    textureCompressionETC2                    /// ETC texture compression formats
     VkBool32                                    textureCompressionASTC_LDR                /// ASTC LDR texture compression formats
     VkBool32                                    textureCompressionBC                      /// BC1-7 texture compressed formats
     VkBool32                                    occlusionQueryPrecise
     VkBool32                                    pipelineStatisticsQuery                   /// pipeline statistics query
     VkBool32                                    vertexPipelineStoresAndAtomics
     VkBool32                                    fragmentStoresAndAtomics
     VkBool32                                    shaderTessellationAndGeometryPointSize
     VkBool32                                    shaderImageGatherExtended                 /// texture gather with run-time values and independent offsets
     VkBool32                                    shaderStorageImageExtendedFormats         /// the extended set of formats can be used for storage images
     VkBool32                                    shaderStorageImageMultisample             /// multisample images can be used for storage images
     VkBool32                                    shaderStorageImageReadWithoutFormat
     VkBool32                                    shaderStorageImageWriteWithoutFormat
     VkBool32                                    shaderUniformBufferArrayDynamicIndexing   /// arrays of uniform buffers can be accessed with dynamically uniform indices
     VkBool32                                    shaderSampledImageArrayDynamicIndexing    /// arrays of sampled images can be accessed with dynamically uniform indices
     VkBool32                                    shaderStorageBufferArrayDynamicIndexing   /// arrays of storage buffers can be accessed with dynamically uniform indices
     VkBool32                                    shaderStorageImageArrayDynamicIndexing    /// arrays of storage images can be accessed with dynamically uniform indices
     VkBool32                                    shaderClipDistance                        /// clip distance in shaders
     VkBool32                                    shaderCullDistance                        /// cull distance in shaders
     VkBool32                                    shaderFloat64                             /// 64-bit floats (doubles) in shaders
     VkBool32                                    shaderInt64                               /// 64-bit integers in shaders
     VkBool32                                    shaderInt16                               /// 16-bit integers in shaders
     VkBool32                                    shaderResourceResidency                   /// shader can use texture operations that return resource residency information (requires sparseNonResident support)
     VkBool32                                    shaderResourceMinLod                      /// shader can use texture operations that specify minimum resource LOD
     VkBool32                                    sparseBinding                             /// Sparse resources support: Resource memory can be managed at opaque page level rather than object level
     VkBool32                                    sparseResidencyBuffer                     /// Sparse resources support: GPU can access partially resident buffers
     VkBool32                                    sparseResidencyImage2D                    /// Sparse resources support: GPU can access partially resident 2D (non-MSAA non-DepthStencil) images
     VkBool32                                    sparseResidencyImage3D                    /// Sparse resources support: GPU can access partially resident 3D images
     VkBool32                                    sparseResidency2Samples                   /// Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples
     VkBool32                                    sparseResidency4Samples                   /// Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples
     VkBool32                                    sparseResidency8Samples                   /// Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples
     VkBool32                                    sparseResidency16Samples                  /// Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples
     VkBool32                                    sparseResidencyAliased                    /// Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in)
     VkBool32                                    variableMultisampleRate
     VkBool32                                    inheritedQueries
 }

 class VkPhysicalDeviceLimits {
     /// resource maximum sizes
     u32                                         maxImageDimension1D                       /// max 1D image dimension
     u32                                         maxImageDimension2D                       /// max 2D image dimension
     u32                                         maxImageDimension3D                       /// max 3D image dimension
     u32                                         maxImageDimensionCube                     /// max cubemap image dimension
     u32                                         maxImageArrayLayers                       /// max layers for image arrays
     u32                                         maxTexelBufferElements
     u32                                         maxUniformBufferRange                     /// max uniform buffer size (bytes)
     u32                                         maxStorageBufferRange                     /// max storage buffer size (bytes)
     u32                                         maxPushConstantsSize                      /// max size of the push constants pool (bytes)
     /// memory limits
     u32                                         maxMemoryAllocationCount                  /// max number of device memory allocations supported
     u32                                         maxSamplerAllocationCount
     VkDeviceSize                                bufferImageGranularity                    /// Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage
     VkDeviceSize                                sparseAddressSpaceSize                    /// Total address space available for sparse allocations (bytes)
     /// descriptor set limits
     u32                                         maxBoundDescriptorSets                    /// max number of descriptors sets that can be bound to a pipeline
     u32                                         maxPerStageDescriptorSamplers             /// max num of samplers allowed per-stage in a descriptor set
     u32                                         maxPerStageDescriptorUniformBuffers       /// max num of uniform buffers allowed per-stage in a descriptor set
     u32                                         maxPerStageDescriptorStorageBuffers       /// max num of storage buffers allowed per-stage in a descriptor set
     u32                                         maxPerStageDescriptorSampledImages        /// max num of sampled images allowed per-stage in a descriptor set
     u32                                         maxPerStageDescriptorStorageImages        /// max num of storage images allowed per-stage in a descriptor set
     u32                                         maxPerStageDescriptorInputAttachments
     u32                                         maxPerStageResources
     u32                                         maxDescriptorSetSamplers                  /// max num of samplers allowed in all stages in a descriptor set
     u32                                         maxDescriptorSetUniformBuffers            /// max num of uniform buffers allowed in all stages in a descriptor set
     u32                                         maxDescriptorSetUniformBuffersDynamic     /// max num of dynamic uniform buffers allowed in all stages in a descriptor set
     u32                                         maxDescriptorSetStorageBuffers            /// max num of storage buffers allowed in all stages in a descriptor set
     u32                                         maxDescriptorSetStorageBuffersDynamic     /// max num of dynamic storage buffers allowed in all stages in a descriptor set
     u32                                         maxDescriptorSetSampledImages             /// max num of sampled images allowed in all stages in a descriptor set
     u32                                         maxDescriptorSetStorageImages             /// max num of storage images allowed in all stages in a descriptor set
     u32                                         maxDescriptorSetInputAttachments
     /// vertex stage limits
     u32                                         maxVertexInputAttributes                  /// max num of vertex input attribute slots
     u32                                         maxVertexInputBindings                    /// max num of vertex input binding slots
     u32                                         maxVertexInputAttributeOffset             /// max vertex input attribute offset added to vertex buffer offset
     u32                                         maxVertexInputBindingStride               /// max vertex input binding stride
     u32                                         maxVertexOutputComponents                 /// max num of output components written by vertex shader
     /// tessellation control stage limits
     u32                                         maxTessellationGenerationLevel                  /// max level supported by tess primitive generator
     u32                                         maxTessellationPatchSize                        /// max patch size (vertices)
     u32                                         maxTessellationControlPerVertexInputComponents  /// max num of input components per-vertex in TCS
     u32                                         maxTessellationControlPerVertexOutputComponents /// max num of output components per-vertex in TCS
     u32                                         maxTessellationControlPerPatchOutputComponents  /// max num of output components per-patch in TCS
     u32                                         maxTessellationControlTotalOutputComponents     /// max total num of per-vertex and per-patch output components in TCS
     u32                                         maxTessellationEvaluationInputComponents        /// max num of input components per vertex in TES
     u32                                         maxTessellationEvaluationOutputComponents       /// max num of output components per vertex in TES
     /// geometry stage limits
     u32                                         maxGeometryShaderInvocations              /// max invocation count supported in geometry shader
     u32                                         maxGeometryInputComponents                /// max num of input components read in geometry stage
     u32                                         maxGeometryOutputComponents               /// max num of output components written in geometry stage
     u32                                         maxGeometryOutputVertices                 /// max num of vertices that can be emitted in geometry stage
     u32                                         maxGeometryTotalOutputComponents          /// max total num of components (all vertices) written in geometry stage
     /// fragment stage limits
     u32                                         maxFragmentInputComponents                /// max num of input compontents read in fragment stage
     u32                                         maxFragmentOutputAttachments              /// max num of output attachments written in fragment stage
     u32                                         maxFragmentDualSrcAttachments             /// max num of output attachments written when using dual source blending
     u32                                         maxFragmentCombinedOutputResources        /// max total num of storage buffers, storage images and output buffers
     /// compute stage limits
     u32                                         maxComputeSharedMemorySize                /// max total storage size of work group local storage (bytes)
     u32[3]                                      maxComputeWorkGroupCount                  /// max num of compute work groups that may be dispatched by a single command (x,y,z)
     u32                                         maxComputeWorkGroupInvocations            /// max total compute invocations in a single local work group
     u32[3]                                      maxComputeWorkGroupSize                   /// max local size of a compute work group (x,y,z)

     u32                                         subPixelPrecisionBits                     /// num bits of subpixel precision in screen x and y
     u32                                         subTexelPrecisionBits                     /// num bits of subtexel precision
     u32                                         mipmapPrecisionBits                       /// num bits of mipmap precision

     u32                                         maxDrawIndexedIndexValue                  /// max index value for indexed draw calls (for 32-bit indices)
     u32                                         maxDrawIndirectCount

     f32                                         maxSamplerLodBias                         /// max absolute sampler level of detail bias
     f32                                         maxSamplerAnisotropy                      /// max degree of sampler anisotropy

     u32                                         maxViewports                              /// max number of active viewports
     u32[2]                                      maxViewportDimensions                     /// max viewport dimensions (x,y)
     f32[2]                                      viewportBoundsRange                       /// viewport bounds range (min,max)
     u32                                         viewportSubPixelBits                      /// num bits of subpixel precision for viewport

     platform.size_t                             minMemoryMapAlignment                     /// min required alignment of pointers returned by MapMemory (bytes)
     VkDeviceSize                                minTexelBufferOffsetAlignment             /// min required alignment for texel buffer offsets (bytes)
     VkDeviceSize                                minUniformBufferOffsetAlignment           /// min required alignment for uniform buffer sizes and offsets (bytes)
     VkDeviceSize                                minStorageBufferOffsetAlignment           /// min required alignment for storage buffer offsets (bytes)

     s32                                         minTexelOffset                            /// min texel offset for OpTextureSampleOffset
     u32                                         maxTexelOffset                            /// max texel offset for OpTextureSampleOffset
     s32                                         minTexelGatherOffset                      /// min texel offset for OpTextureGatherOffset
     u32                                         maxTexelGatherOffset                      /// max texel offset for OpTextureGatherOffset
     f32                                         minInterpolationOffset                    /// furthest negative offset for interpolateAtOffset
     f32                                         maxInterpolationOffset                    /// furthest positive offset for interpolateAtOffset
     u32                                         subPixelInterpolationOffsetBits           /// num of subpixel bits for interpolateAtOffset

     u32                                         maxFramebufferWidth                       /// max width for a framebuffer
     u32                                         maxFramebufferHeight                      /// max height for a framebuffer
     u32                                         maxFramebufferLayers                      /// max layer count for a layered framebuffer
     VkSampleCountFlags                          framebufferColorSampleCounts
     VkSampleCountFlags                          framebufferDepthSampleCounts
     VkSampleCountFlags                          framebufferStencilSampleCounts
     VkSampleCountFlags                          framebufferNoAttachmentSampleCounts
     u32                                         maxColorAttachments                       /// max num of framebuffer color attachments

     VkSampleCountFlags                          sampledImageColorSampleCounts
     VkSampleCountFlags                          sampledImageIntegerSampleCounts
     VkSampleCountFlags                          sampledImageDepthSampleCounts
     VkSampleCountFlags                          sampledImageStencilSampleCounts
     VkSampleCountFlags                          storageImageSampleCounts
     u32                                         maxSampleMaskWords                        /// max num of sample mask words
     VkBool32                                    timestampComputeAndGraphics

     f32                                         timestampPeriod

     u32                                         maxClipDistances                          /// max number of clip distances
     u32                                         maxCullDistances                          /// max number of cull distances
     u32                                         maxCombinedClipAndCullDistances           /// max combined number of user clipping

     u32                                         discreteQueuePriorities

     f32[2]                                      pointSizeRange                            /// range (min,max) of supported point sizes
     f32[2]                                      lineWidthRange                            /// range (min,max) of supported line widths
     f32                                         pointSizeGranularity                      /// granularity of supported point sizes
     f32                                         lineWidthGranularity                      /// granularity of supported line widths
     VkBool32                                    strictLines
     VkBool32                                    standardSampleLocations

     VkDeviceSize                                optimalBufferCopyOffsetAlignment
     VkDeviceSize                                optimalBufferCopyRowPitchAlignment
     VkDeviceSize                                nonCoherentAtomSize
 }

 class VkPhysicalDeviceSparseProperties {
     VkBool32                                    residencyStandard2DBlockShape             /// Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard block shapes (based on pixel format)
     VkBool32                                    residencyStandard2DMultisampleBlockShape  /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard block shapes (based on pixel format)
     VkBool32                                    residencyStandard3DBlockShape             /// Sparse resources support: GPU will access all 3D sparse resources using the standard block shapes (based on pixel format)
     VkBool32                                    residencyAlignedMipSize                   /// Sparse resources support: Images with mip-level dimensions that are NOT a multiple of the block size will be placed in the mip tail
     VkBool32                                    residencyNonResidentStrict                /// Sparse resources support: GPU can safely access non-resident regions of a resource, all reads return as if data is 0, writes are discarded
 }

 class VkSemaphoreCreateInfo {
     VkStructureType                             sType      /// Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
     const void*                                 pNext      /// Pointer to next structure
     VkSemaphoreCreateFlags                      flags      /// Semaphore creation flags
 }

 class VkQueryPoolCreateInfo {
     VkStructureType                             sType              /// Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
     const void*                                 pNext              /// Pointer to next structure
     VkQueryPoolCreateFlags                      flags
     VkQueryType                                 queryType
     u32                                         queryCount
     VkQueryPipelineStatisticFlags               pipelineStatistics /// Optional
 }

 class VkFramebufferCreateInfo {
     VkStructureType                             sType  /// Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
     const void*                                 pNext  /// Pointer to next structure
     VkFramebufferCreateFlags                    flags
     VkRenderPass                                renderPass
     u32                                         attachmentCount
     const VkImageView*                          pAttachments
     u32                                         width
     u32                                         height
     u32                                         layers
 }

 class VkDrawIndirectCommand {
     u32                                         vertexCount
     u32                                         instanceCount
     u32                                         firstVertex
     u32                                         firstInstance
 }

 class VkDrawIndexedIndirectCommand {
     u32                                         indexCount
     u32                                         instanceCount
     u32                                         firstIndex
     s32                                         vertexOffset
     u32                                         firstInstance
 }

 class VkDispatchIndirectCommand {
     u32                                         x
     u32                                         y
     u32                                         z
 }

 class VkBaseOutStructure {
     VkStructureType                             sType
     void*                                       pNext
 }

 class VkBaseInStructure {
     VkStructureType                             sType
     const void*                                 pNext
 }

 //@vulkan1_1 structures

 class VkPhysicalDeviceSubgroupProperties {
     VkStructureType                             sType
     void*                                       pNext
     u32                                         subgroupSize
     VkShaderStageFlags                          supportedStages
     VkSubgroupFeatureFlags                      supportedOperations
     VkBool32                                    quadOperationsInAllStages
 }

 class VkBindBufferMemoryInfo {
     VkStructureType    sType
     const void*        pNext
     VkBuffer           buffer
     VkDeviceMemory     memory
     VkDeviceSize       memoryOffset
 }

 class VkBindImageMemoryInfo {
     VkStructureType    sType
     const void*        pNext
     VkImage            image
     VkDeviceMemory     memory
     VkDeviceSize       memoryOffset
 }

 class VkPhysicalDevice16BitStorageFeatures {
     VkStructureType    sType
     void*              pNext
     VkBool32           storageBuffer16BitAccess
     VkBool32           uniformAndStorageBuffer16BitAccess
     VkBool32           storagePushConstant16
     VkBool32           storageInputOutput16
 }

 class VkMemoryDedicatedRequirements {
     VkStructureType    sType
     void*              pNext
     VkBool32           prefersDedicatedAllocation
     VkBool32           requiresDedicatedAllocation
 }

 class VkMemoryDedicatedAllocateInfo {
     VkStructureType    sType
     const void*        pNext
     VkImage            image
     VkBuffer           buffer
 }

 class VkMemoryAllocateFlagsInfo {
     VkStructureType          sType
     const void*              pNext
     VkMemoryAllocateFlags    flags
     u32                      deviceMask
 }

 class VkDeviceGroupRenderPassBeginInfo {
     VkStructureType    sType
     const void*        pNext
     u32                deviceMask
     u32                deviceRenderAreaCount
     const VkRect2D*    pDeviceRenderAreas
 }

 class VkDeviceGroupCommandBufferBeginInfo {
     VkStructureType    sType
     const void*        pNext
     u32                deviceMask
 }

 class VkDeviceGroupSubmitInfo {
     VkStructureType             sType
     const void*                 pNext
     u32                         waitSemaphoreCount
     const u32*                  pWaitSemaphoreDeviceIndices
     u32                         commandBufferCount
     const u32*                  pCommandBufferDeviceMasks
     u32                         signalSemaphoreCount
     const u32*                  pSignalSemaphoreDeviceIndices
 }

 class VkDeviceGroupBindSparseInfo {
     VkStructureType    sType
     const void*        pNext
     u32                resourceDeviceIndex
     u32                memoryDeviceIndex
 }

 class VkBindBufferMemoryDeviceGroupInfo {
     VkStructureType                     sType
     const void*                         pNext
     u32                                 deviceIndexCount
     const u32*                          pDeviceIndices
 }

 class VkBindImageMemoryDeviceGroupInfo {
     VkStructureType                     sType
     const void*                         pNext
     u32                                 deviceIndexCount
     const u32*                          pDeviceIndices
     u32                                 splitInstanceBindRegionCount
     const VkRect2D*                     pSplitInstanceBindRegions
 }

 class VkPhysicalDeviceGroupProperties {
     VkStructureType                             sType
     void*                                       pNext
     u32                                         physicalDeviceCount
     VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE]  physicalDevices
     VkBool32                                    subsetAllocation
 }

 class VkDeviceGroupDeviceCreateInfo {
     VkStructureType            sType
     const void*                pNext
     u32                        physicalDeviceCount
     const VkPhysicalDevice*    pPhysicalDevices
 }

 class VkBufferMemoryRequirementsInfo2 {
     VkStructureType    sType
     const void*        pNext
     VkBuffer           buffer
 }

 class VkImageMemoryRequirementsInfo2 {
     VkStructureType    sType
     const void*        pNext
     VkImage            image
 }

 class VkImageSparseMemoryRequirementsInfo2 {
     VkStructureType    sType
     const void*        pNext
     VkImage            image
 }

 class VkMemoryRequirements2 {
     VkStructureType         sType
     void*                   pNext
     VkMemoryRequirements    memoryRequirements
 }

 class VkSparseImageMemoryRequirements2 {
     VkStructureType                    sType
     void*                              pNext
     VkSparseImageMemoryRequirements    memoryRequirements
 }

 class VkPhysicalDeviceFeatures2 {
     VkStructureType             sType
     void*                       pNext
     VkPhysicalDeviceFeatures    features
 }

 class VkPhysicalDeviceProperties2 {
     VkStructureType               sType
     void*                         pNext
     VkPhysicalDeviceProperties    properties
 }

 class VkFormatProperties2 {
     VkStructureType       sType
     void*                 pNext
     VkFormatProperties    formatProperties
 }

 class VkImageFormatProperties2 {
     VkStructureType            sType
     void*                      pNext
     VkImageFormatProperties    imageFormatProperties
 }

 class VkPhysicalDeviceImageFormatInfo2 {
     VkStructureType       sType
     const void*           pNext
     VkFormat              format
     VkImageType           type
     VkImageTiling         tiling
     VkImageUsageFlags     usage
     VkImageCreateFlags    flags
 }

 class VkQueueFamilyProperties2 {
     VkStructureType            sType
     void*                      pNext
     VkQueueFamilyProperties    queueFamilyProperties
 }

 class VkPhysicalDeviceMemoryProperties2 {
     VkStructureType                     sType
     void*                               pNext
     VkPhysicalDeviceMemoryProperties    memoryProperties
 }

 class VkSparseImageFormatProperties2 {
     VkStructureType                  sType
     void*                            pNext
     VkSparseImageFormatProperties    properties
 }

 class VkPhysicalDeviceSparseImageFormatInfo2 {
     VkStructureType          sType
     const void*              pNext
     VkFormat                 format
     VkImageType              type
     VkSampleCountFlagBits    samples
     VkImageUsageFlags        usage
     VkImageTiling            tiling
 }

 class VkPhysicalDevicePointClippingProperties {
     VkStructureType            sType
     void*                      pNext
     VkPointClippingBehavior    pointClippingBehavior
 }

 class VkInputAttachmentAspectReference {
     u32                   subpass
     u32                   inputAttachmentIndex
     VkImageAspectFlags    aspectMask
 }

 class VkRenderPassInputAttachmentAspectCreateInfo {
     VkStructureType                            sType
     const void*                                pNext
     u32                                        aspectReferenceCount
     const VkInputAttachmentAspectReference*    pAspectReferences
 }

 class VkImageViewUsageCreateInfo {
     VkStructureType      sType
     const void*          pNext
     VkImageUsageFlags    usage
 }

 class VkPipelineTessellationDomainOriginStateCreateInfo {
     VkStructureType               sType
     const void*                   pNext
     VkTessellationDomainOrigin    domainOrigin
 }

 class VkRenderPassMultiviewCreateInfo {
     VkStructureType    sType
     const void*        pNext
     u32                subpassCount
     const u32*         pViewMasks
     u32                dependencyCount
     const s32*         pViewOffsets
     u32                correlationMaskCount
     const u32*         pCorrelationMasks
 }

 class VkPhysicalDeviceMultiviewFeatures {
     VkStructureType    sType
     void*              pNext
     VkBool32           multiview
     VkBool32           multiviewGeometryShader
     VkBool32           multiviewTessellationShader
 }

 class VkPhysicalDeviceMultiviewProperties {
     VkStructureType    sType
     void*              pNext
     u32                maxMultiviewViewCount
     u32                maxMultiviewInstanceIndex
 }

 class VkPhysicalDeviceVariablePointerFeatures {
     VkStructureType    sType
     void*              pNext
     VkBool32           variablePointersStorageBuffer
     VkBool32           variablePointers
 }

 class VkPhysicalDeviceProtectedMemoryFeatures {
     VkStructureType    sType
     void*              pNext
     VkBool32           protectedMemory
 }

 class VkPhysicalDeviceProtectedMemoryProperties {
     VkStructureType    sType
     void*              pNext
     VkBool32           protectedNoFault
 }

 class VkDeviceQueueInfo2 {
     VkStructureType             sType
     const void*                 pNext
     VkDeviceQueueCreateFlags    flags
     u32                         queueFamilyIndex
     u32                         queueIndex
 }

 class VkProtectedSubmitInfo {
     VkStructureType    sType
     const void*        pNext
     VkBool32           protectedSubmit
 }

 class VkSamplerYcbcrConversionCreateInfo {
     VkStructureType                  sType
     const void*                      pNext
     VkFormat                         format
     VkSamplerYcbcrModelConversion    ycbcrModel
     VkSamplerYcbcrRange              ycbcrRange
     VkComponentMapping               components
     VkChromaLocation                 xChromaOffset
     VkChromaLocation                 yChromaOffset
     VkFilter                         chromaFilter
     VkBool32                         forceExplicitReconstruction
 }

 class VkSamplerYcbcrConversionInfo {
     VkStructureType             sType
     const void*                 pNext
     VkSamplerYcbcrConversion    conversion
 }

 class VkBindImagePlaneMemoryInfo {
     VkStructureType          sType
     const void*              pNext
     VkImageAspectFlagBits    planeAspect
 }

 class VkImagePlaneMemoryRequirementsInfo {
     VkStructureType          sType
     const void*              pNext
     VkImageAspectFlagBits    planeAspect
 }

 class VkPhysicalDeviceSamplerYcbcrConversionFeatures {
     VkStructureType    sType
     void*              pNext
     VkBool32           samplerYcbcrConversion
 }

 class VkSamplerYcbcrConversionImageFormatProperties {
     VkStructureType    sType
     void*              pNext
     u32                combinedImageSamplerDescriptorCount
 }

 class VkDescriptorUpdateTemplateEntry {
     u32                                 dstBinding
     u32                                 dstArrayElement
     u32                                 descriptorCount
     VkDescriptorType                    descriptorType
     platform.size_t                     offset
     platform.size_t                     stride
 }

 class VkDescriptorUpdateTemplateCreateInfo {
     VkStructureType                           sType
     void*                                     pNext
     VkDescriptorUpdateTemplateCreateFlags     flags
     u32                                       descriptorUpdateEntryCount
     const VkDescriptorUpdateTemplateEntry*    pDescriptorUpdateEntries
     VkDescriptorUpdateTemplateType            templateType
     VkDescriptorSetLayout                     descriptorSetLayout
     VkPipelineBindPoint                       pipelineBindPoint
     VkPipelineLayout                          pipelineLayout
     u32                                       set
 }

 class VkExternalMemoryProperties {
     VkExternalMemoryFeatureFlags       externalMemoryFeatures
     VkExternalMemoryHandleTypeFlags    exportFromImportedHandleTypes
     VkExternalMemoryHandleTypeFlags    compatibleHandleTypes
 }

 class VkPhysicalDeviceExternalImageFormatInfo {
     VkStructureType                       sType
     const void*                           pNext
     VkExternalMemoryHandleTypeFlagBits    handleType
 }

 class VkExternalImageFormatProperties {
     VkStructureType               sType
     void*                         pNext
     VkExternalMemoryProperties    externalMemoryProperties
 }

 class VkPhysicalDeviceExternalBufferInfo {
     VkStructureType                       sType
     const void*                           pNext
     VkBufferCreateFlags                   flags
     VkBufferUsageFlags                    usage
     VkExternalMemoryHandleTypeFlagBits    handleType
 }

 class VkExternalBufferProperties {
     VkStructureType               sType
     void*                         pNext
     VkExternalMemoryProperties    externalMemoryProperties
 }

 class VkPhysicalDeviceIDProperties {
     VkStructureType    sType
     void*              pNext
     u8[VK_UUID_SIZE]   deviceUUID
     u8[VK_UUID_SIZE]   driverUUID
     u8[VK_LUID_SIZE]   deviceLUID
     u32                deviceNodeMask
     VkBool32           deviceLUIDValid
 }

 class VkExternalMemoryImageCreateInfo {
     VkStructureType                    sType
     const void*                        pNext
     VkExternalMemoryHandleTypeFlags    handleTypes
 }

 class VkExternalMemoryBufferCreateInfo {
     VkStructureType                    sType
     const void*                        pNext
     VkExternalMemoryHandleTypeFlags    handleTypes
 }

 class VkExportMemoryAllocateInfo {
     VkStructureType                    sType
     const void*                        pNext
     VkExternalMemoryHandleTypeFlags    handleTypes
 }

 class VkPhysicalDeviceExternalFenceInfo {
     VkStructureType                      sType
     const void*                          pNext
     VkExternalFenceHandleTypeFlagBits    handleType
 }

 class VkExternalFenceProperties {
     VkStructureType                   sType
     void*                             pNext
     VkExternalFenceHandleTypeFlags    exportFromImportedHandleTypes
     VkExternalFenceHandleTypeFlags    compatibleHandleTypes
     VkExternalFenceFeatureFlags       externalFenceFeatures
 }

 class VkExportFenceCreateInfo {
     VkStructureType                   sType
     const void*                       pNext
     VkExternalFenceHandleTypeFlags    handleTypes
 }

 class VkExportSemaphoreCreateInfo {
     VkStructureType                       sType
     const void*                           pNext
     VkExternalSemaphoreHandleTypeFlags    handleTypes
 }

 class VkPhysicalDeviceExternalSemaphoreInfo {
     VkStructureType                          sType
     const void*                              pNext
     VkExternalSemaphoreHandleTypeFlagBits    handleType
 }

 class VkExternalSemaphoreProperties {
     VkStructureType                       sType
     void*                                 pNext
     VkExternalSemaphoreHandleTypeFlags    exportFromImportedHandleTypes
     VkExternalSemaphoreHandleTypeFlags    compatibleHandleTypes
     VkExternalSemaphoreFeatureFlags       externalSemaphoreFeatures
 }

 class VkPhysicalDeviceMaintenance3Properties {
     VkStructureType    sType
     void*              pNext
     u32                maxPerSetDescriptors
     VkDeviceSize       maxMemoryAllocationSize
 }

 class VkDescriptorSetLayoutSupport {
     VkStructureType    sType
     void*              pNext
     VkBool32           supported
 }

 class VkPhysicalDeviceShaderDrawParameterFeatures {
     VkStructureType    sType
     void*              pNext
     VkBool32           shaderDrawParameters
 }


 @extension("VK_KHR_surface") // 1
 class VkSurfaceCapabilitiesKHR {
     u32                                         minImageCount
     u32                                         maxImageCount
     VkExtent2D                                  currentExtent
     VkExtent2D                                  minImageExtent
     VkExtent2D                                  maxImageExtent
     u32                                         maxImageArrayLayers
     VkSurfaceTransformFlagsKHR                  supportedTransforms
     VkSurfaceTransformFlagBitsKHR               currentTransform
     VkCompositeAlphaFlagsKHR                    supportedCompositeAlpha
     VkImageUsageFlags                           supportedUsageFlags
 }

 @extension("VK_KHR_surface") // 1
 class VkSurfaceFormatKHR {
     VkFormat                                    format
     VkColorSpaceKHR                             colorSpace
 }

 @extension("VK_KHR_swapchain") // 2
 class VkSwapchainCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkSwapchainCreateFlagsKHR                   flags
     VkSurfaceKHR                                surface
     u32                                         minImageCount
     VkFormat                                    imageFormat
     VkColorSpaceKHR                             imageColorSpace
     VkExtent2D                                  imageExtent
     u32                                         imageArrayLayers
     VkImageUsageFlags                           imageUsage
     VkSharingMode                               sharingMode
     u32                                         queueFamilyIndexCount
     const u32*                                  pQueueFamilyIndices
     VkSurfaceTransformFlagBitsKHR               preTransform
     VkCompositeAlphaFlagBitsKHR                 compositeAlpha
     VkPresentModeKHR                            presentMode
     VkBool32                                    clipped
     VkSwapchainKHR                              oldSwapchain
 }

 @extension("VK_KHR_swapchain") // 2
 class VkPresentInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         waitSemaphoreCount
     const VkSemaphore*                          pWaitSemaphores
     u32                                         swapchainCount
     const VkSwapchainKHR*                       pSwapchains
     const u32*                                  pImageIndices
     VkResult*                                   pResults
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 class VkImageSwapchainCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkSwapchainKHR                              swapchain
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 class VkBindImageMemorySwapchainInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkSwapchainKHR                              swapchain
     u32                                         imageIndex
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 class VkAcquireNextImageInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkSwapchainKHR                              swapchain
     u64                                         timeout
     VkSemaphore                                 semaphore
     VkFence                                     fence
     u32                                         deviceMask
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 class VkDeviceGroupPresentCapabilitiesKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32[VK_MAX_DEVICE_GROUP_SIZE]               presentMask
     VkDeviceGroupPresentModeFlagsKHR            modes
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 class VkDeviceGroupPresentInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         swapchainCount
     const u32*                                  pDeviceMasks
     VkDeviceGroupPresentModeFlagBitsKHR         mode
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 class VkDeviceGroupSwapchainCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkDeviceGroupPresentModeFlagsKHR            modes
 }

 @extension("VK_KHR_display") // 3
 class VkDisplayPropertiesKHR {
     VkDisplayKHR                                display
     const char*                                 displayName
     VkExtent2D                                  physicalDimensions
     VkExtent2D                                  physicalResolution
     VkSurfaceTransformFlagsKHR                  supportedTransforms
     VkBool32                                    planeReorderPossible
     VkBool32                                    persistentContent
 }

 @extension("VK_KHR_display") // 3
 class VkDisplayModeParametersKHR {
     VkExtent2D                                  visibleRegion
     u32                                         refreshRate
 }

 @extension("VK_KHR_display") // 3
 class VkDisplayModePropertiesKHR {
     VkDisplayModeKHR                            displayMode
     VkDisplayModeParametersKHR                  parameters
 }

 @extension("VK_KHR_display") // 3
 class VkDisplayModeCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkDisplayModeCreateFlagsKHR                 flags
     VkDisplayModeParametersKHR                  parameters
 }

 @extension("VK_KHR_display") // 3
 class VkDisplayPlanePropertiesKHR {
     VkDisplayKHR                                currentDisplay
     u32                                         currentStackIndex
 }

 @extension("VK_KHR_display") // 3
 class VkDisplayPlaneCapabilitiesKHR {
     VkDisplayPlaneAlphaFlagsKHR                 supportedAlpha
     VkOffset2D                                  minSrcPosition
     VkOffset2D                                  maxSrcPosition
     VkExtent2D                                  minSrcExtent
     VkExtent2D                                  maxSrcExtent
     VkOffset2D                                  minDstPosition
     VkOffset2D                                  maxDstPosition
     VkExtent2D                                  minDstExtent
     VkExtent2D                                  maxDstExtent
 }

 @extension("VK_KHR_display") // 3
 class VkDisplaySurfaceCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkDisplaySurfaceCreateFlagsKHR              flags
     VkDisplayModeKHR                            displayMode
     u32                                         planeIndex
     u32                                         planeStackIndex
     VkSurfaceTransformFlagBitsKHR               transform
     f32                                         globalAlpha
     VkDisplayPlaneAlphaFlagBitsKHR              alphaMode
     VkExtent2D                                  imageExtent
 }

 @extension("VK_KHR_display_swapchain") // 4
 class VkDisplayPresentInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkRect2D                                    srcRect
     VkRect2D                                    dstRect
     VkBool32                                    persistent
 }

 @extension("VK_KHR_xlib_surface") // 5
 class VkXlibSurfaceCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkXlibSurfaceCreateFlagsKHR                 flags
     platform.Display*                           dpy
     platform.Window                             window
 }

 @extension("VK_KHR_xcb_surface") // 6
 class VkXcbSurfaceCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkXcbSurfaceCreateFlagsKHR                  flags
     platform.xcb_connection_t*                  connection
     platform.xcb_window_t                       window
 }

 @extension("VK_KHR_wayland_surface") // 7
 class VkWaylandSurfaceCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkWaylandSurfaceCreateFlagsKHR              flags
     platform.wl_display*                        display
     platform.wl_surface*                        surface
 }

 @extension("VK_KHR_mir_surface") // 8
 class VkMirSurfaceCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkMirSurfaceCreateFlagsKHR                  flags
     platform.MirConnection*                     connection
     platform.MirSurface*                        mirSurface
 }

 @extension("VK_KHR_android_surface") // 9
 class VkAndroidSurfaceCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkAndroidSurfaceCreateFlagsKHR              flags
     platform.ANativeWindow*                     window
 }

 @extension("VK_KHR_win32_surface") // 10
 class VkWin32SurfaceCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkWin32SurfaceCreateFlagsKHR                flags
     platform.HINSTANCE                          hinstance
     platform.HWND                               hwnd
 }

 @extension("VK_ANDROID_native_buffer") // 11
 @internal class Gralloc1Usage {
     u64                                         consumer
     u64                                         producer
 }

 @extension("VK_ANDROID_native_buffer") // 11
 class VkNativeBufferANDROID {
     VkStructureType                             sType
     const void*                                 pNext
     platform.buffer_handle_t                    handle
     s32                                         stride
     s32                                         format
     s32                                         usage
     Gralloc1Usage                               usage2
 }

 @extension("VK_ANDROID_native_buffer") // 11
 class VkSwapchainImageCreateInfoANDROID {
     VkStructureType                             sType
     const void*                                 pNext
     VkSwapchainImageUsageFlagsANDROID           flags
 }

 @extension("VK_ANDROID_native_buffer") // 11
 class VkPhysicalDevicePresentationPropertiesANDROID {
     VkStructureType                             sType
     void*                                       pNext
     VkBool32                                    sharedImage
 }

 @extension("VK_EXT_debug_report") // 12
 class VkDebugReportCallbackCreateInfoEXT {
     VkStructureType                             sType
     const void*                                 pNext
     VkDebugReportFlagsEXT                       flags
     PFN_vkDebugReportCallbackEXT                pfnCallback
     void*                                       pUserData
 }

 @extension("VK_AMD_rasterization_order") // 19
 class VkPipelineRasterizationStateRasterizationOrderAMD {
     VkStructureType                             sType
     const void*                                 pNext
     VkRasterizationOrderAMD                     rasterizationOrder
 }

 @extension("VK_EXT_debug_marker") // 23
 class VkDebugMarkerObjectNameInfoEXT {
     VkStructureType                             sType
     const void*                                 pNext
     VkDebugReportObjectTypeEXT                  objectType
     u64                                         object
     const char*                                 pObjectName
 }

 @extension("VK_EXT_debug_marker") // 23
 class VkDebugMarkerObjectTagInfoEXT {
     VkStructureType                             sType
     const void*                                 pNext
     VkDebugReportObjectTypeEXT                  objectType
     u64                                         object
     u64                                         tagName
     platform.size_t                             tagSize
     const void*                                 pTag
 }

 @extension("VK_EXT_debug_marker") // 23
 class VkDebugMarkerMarkerInfoEXT {
     VkStructureType                             sType
     const void*                                 pNext
     const char*                                 pMarkerName
     f32[4]                                      color
 }

 @extension("VK_NV_dedicated_allocation") // 27
 class VkDedicatedAllocationImageCreateInfoNV {
     VkStructureType                             sType
     const void*                                 pNext
     VkBool32                                    dedicatedAllocation
 }

 @extension("VK_NV_dedicated_allocation") // 27
 class VkDedicatedAllocationBufferCreateInfoNV {
     VkStructureType                             sType
     const void*                                 pNext
     VkBool32                                    dedicatedAllocation
 }

 @extension("VK_NV_dedicated_allocation") // 27
 class VkDedicatedAllocationMemoryAllocateInfoNV {
     VkStructureType                             sType
     const void*                                 pNext
     VkImage                                     image
     VkBuffer                                    buffer
 }

 @extension("VK_AMD_texture_gather_bias_lod") // 42
 class VkTextureLODGatherFormatPropertiesAMD {
     VkStructureType                             sType
     void*                                       pNext
     VkBool32                                    supportsTextureGatherLODBiasAMD
 }

 @extension("VK_AMD_shader_info") // 43
 class VkShaderResourceUsageAMD {
     u32                                         numUsedVgprs
     u32                                         numUsedSgprs
     u32                                         ldsSizePerLocalWorkGroup
     platform.size_t                             ldsUsageSizeInBytes
     platform.size_t                             scratchMemUsageInBytes
 }

 @extension("VK_AMD_shader_info") // 43
 class VkShaderStatisticsInfoAMD {
     VkShaderStageFlags                          shaderStageMask
     VkShaderResourceUsageAMD                    resourceUsage
     u32                                         numPhysicalVgprs
     u32                                         numPhysicalSgprs
     u32                                         numAvailableVgprs
     u32                                         numAvailableSgprs
     u32[3]                                      computeWorkGroupSize
 }

 @extension("VK_NV_corner_sampled_image") // 51
 class VkPhysicalDeviceCornerSampledImageFeaturesNV {
     VkStructureType                             sType
     void*                                       pNext
     VkBool32                                    cornerSampledImage
 }

 @extension("VK_KHR_multiview") // 54
 class VkRenderPassMultiviewCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         subpassCount
     const u32*                                  pViewMasks
     u32                                         dependencyCount
     const s32*                                  pViewOffsets
     u32                                         correlationMaskCount
     const u32*                                  pCorrelationMasks
 }

 @extension("VK_KHR_multiview") // 54
 class VkPhysicalDeviceMultiviewFeaturesKHR {
     VkStructureType                             sType
     void*                                       pNext
     VkBool32                                    multiview
     VkBool32                                    multiviewGeometryShader
     VkBool32                                    multiviewTessellationShader
 }

 @extension("VK_KHR_multiview") // 54
 class VkPhysicalDeviceMultiviewPropertiesKHR {
     VkStructureType                             sType
     void*                                       pNext
     u32                                         maxMultiviewViewCount
     u32                                         maxMultiviewInstanceIndex
 }

 @extension("VK_NV_external_memory_capabilities") // 56
 class VkExternalImageFormatPropertiesNV {
     VkImageFormatProperties                     imageFormatProperties
     VkExternalMemoryFeatureFlagsNV              externalMemoryFeatures
     VkExternalMemoryHandleTypeFlagsNV           exportFromImportedHandleTypes
     VkExternalMemoryHandleTypeFlagsNV           compatibleHandleTypes
 }

 @extension("VK_NV_external_memory") // 57
 class VkExternalMemoryImageCreateInfoNV {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalMemoryHandleTypeFlagsNV           handleTypes
 }

 @extension("VK_NV_external_memory") // 57
 class VkExportMemoryAllocateInfoNV {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalMemoryHandleTypeFlagsNV           handleTypes
 }

 @extension("VK_NV_external_memory_win32") // 58
 class VkImportMemoryWin32HandleInfoNV {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalMemoryHandleTypeFlagsNV           handleType
     platform.HANDLE                             handle
 }

 @extension("VK_NV_external_memory_win32") // 58
 class VkExportMemoryWin32HandleInfoNV {
     VkStructureType                             sType
     const void*                                 pNext
     const platform.SECURITY_ATTRIBUTES*         pAttributes
     platform.DWORD                              dwAccess
 }

 @extension("VK_NV_win32_keyed_mutex") // 59
 class VkWin32KeyedMutexAcquireReleaseInfoNV {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         acquireCount
     const VkDeviceMemory*                       pAcquireSyncs
     const u64*                                  pAcquireKeys
     const u32*                                  pAcquireTimeoutMilliseconds
     u32                                         releaseCount
     const VkDeviceMemory*                       pReleaseSyncs
     const u64*                                  pReleaseKeys
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 class VkPhysicalDeviceFeatures2KHR {
     VkStructureType                             sType
     void*                                       pNext
     VkPhysicalDeviceFeatures                    features
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 class VkPhysicalDeviceProperties2KHR {
     VkStructureType                             sType
     void*                                       pNext
     VkPhysicalDeviceProperties                  properties
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 class VkFormatProperties2KHR {
     VkStructureType                             sType
     void*                                       pNext
     VkFormatProperties                          formatProperties
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 class VkImageFormatProperties2KHR {
     VkStructureType                             sType
     void*                                       pNext
     VkImageFormatProperties                     imageFormatProperties
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 class VkPhysicalDeviceImageFormatInfo2KHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkFormat                                    format
     VkImageType                                 type
     VkImageTiling                               tiling
     VkImageUsageFlags                           usage
     VkImageCreateFlags                          flags
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 class VkQueueFamilyProperties2KHR {
     VkStructureType                             sType
     void*                                       pNext
     VkQueueFamilyProperties                     queueFamilyProperties
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 class VkPhysicalDeviceMemoryProperties2KHR {
     VkStructureType                             sType
     void*                                       pNext
     VkPhysicalDeviceMemoryProperties            memoryProperties
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 class VkSparseImageFormatProperties2KHR {
     VkStructureType                             sType
     void*                                       pNext
     VkSparseImageFormatProperties               properties
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 class VkPhysicalDeviceSparseImageFormatInfo2KHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkFormat                                    format
     VkImageType                                 type
     VkSampleCountFlagBits                       samples
     VkImageUsageFlags                           usage
     VkImageTiling                               tiling
 }

 @extension("VK_KHR_device_group") // 61
 class VkMemoryAllocateFlagsInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkMemoryAllocateFlagsKHR                    flags
     u32                                         deviceMask
 }

 @extension("VK_KHR_device_group") // 61
 class VkBindBufferMemoryDeviceGroupInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         deviceIndexCount
     const u32*                                  pDeviceIndices
 }

 @extension("VK_KHR_device_group") // 61
 class VkBindImageMemoryDeviceGroupInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         deviceIndexCount
     const u32*                                  pDeviceIndices
     u32                                         SFRRectCount
     const VkRect2D*                             pSFRRects
 }

 @extension("VK_KHR_device_group") // 61
 class VkDeviceGroupRenderPassBeginInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         deviceMask
     u32                                         deviceRenderAreaCount
     const VkRect2D*                             pDeviceRenderAreas
 }

 @extension("VK_KHR_device_group") // 61
 class VkDeviceGroupCommandBufferBeginInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         deviceMask
 }

 @extension("VK_KHR_device_group") // 61
 class VkDeviceGroupSubmitInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         waitSemaphoreCount
     const u32*                                  pWaitSemaphoreDeviceIndices
     u32                                         commandBufferCount
     const u32*                                  pCommandBufferDeviceMasks
     u32                                         signalSemaphoreCount
     const u32*                                  pSignalSemaphoreDeviceIndices
 }

 @extension("VK_KHR_device_group") // 61
 class VkDeviceGroupBindSparseInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         resourceDeviceIndex
     u32                                         memoryDeviceIndex
 }

 @extension("VK_EXT_validation_flags") // 62
 class VkValidationFlagsEXT {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         disabledValidationCheckCount
     const VkValidationCheckEXT*                 pDisabledValidationChecks
 }

 @extension("VK_NN_vi_surface") // 63
 class VkViSurfaceCreateInfoNN {
     VkStructureType                             sType
     const void*                                 pNext
     VkViSurfaceCreateFlagsNN                    flags
     void*                                       window
 }

 @extension("VK_EXT_astc_decode_mode") // 68
 class VkImageViewASTCDecodeModeEXT {
     VkStructureType                             sType
     const void*                                 pNext
     VkFormat                                    decodeMode
 }

 @extension("VK_EXT_astc_decode_mode") // 68
 class VkPhysicalDeviceASTCDecodeFeaturesEXT {
     VkStructureType                             sType
     void*                                       pNext
     VkBool32                                    decodeModeSharedExponent
 }

 @extension("VK_KHR_device_group_creation") // 71
 class VkPhysicalDeviceGroupPropertiesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             physicalDeviceCount
     VkPhysicalDevice[VK_MAX_DEVICE_GROUP_SIZE]      physicalDevices
     VkBool32                                        subsetAllocation
 }

 @extension("VK_KHR_device_group_creation") // 71
 class VkDeviceGroupDeviceCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         physicalDeviceCount
     const VkPhysicalDevice*                     pPhysicalDevices
 }

 @extension("VK_KHR_external_memory_capabilities") // 72
 class VkExternalMemoryPropertiesKHR {
     VkExternalMemoryFeatureFlagsKHR             externalMemoryFeatures
     VkExternalMemoryHandleTypeFlagsKHR          exportFromImportedHandleTypes
     VkExternalMemoryHandleTypeFlagsKHR          compatibleHandleTypes
 }

 @extension("VK_KHR_external_memory_capabilities") // 72
 class VkPhysicalDeviceExternalImageFormatInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalMemoryHandleTypeFlagBitsKHR       handleType
 }

 @extension("VK_KHR_external_memory_capabilities") // 72
 class VkExternalImageFormatPropertiesKHR {
     VkStructureType                             sType
     void*                                       pNext
     VkExternalMemoryPropertiesKHR               externalMemoryProperties
 }

 @extension("VK_KHR_external_memory_capabilities") // 72
 class VkPhysicalDeviceExternalBufferInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkBufferCreateFlags                         flags
     VkBufferUsageFlags                          usage
     VkExternalMemoryHandleTypeFlagBitsKHR       handleType
 }

 @extension("VK_KHR_external_memory_capabilities") // 72
 class VkExternalBufferPropertiesKHR {
     VkStructureType                             sType
     void*                                       pNext
     VkExternalMemoryPropertiesKHR               externalMemoryProperties
 }

 @extension("VK_KHR_external_memory_capabilities") // 72
 class VkPhysicalDeviceIDPropertiesKHR {
     VkStructureType                             sType
     void*                                       pNext
     u8[VK_UUID_SIZE]                            deviceUUID
     u8[VK_UUID_SIZE]                            driverUUID
     u8[VK_LUID_SIZE]                            deviceLUID
     u32                                         deviceNodeMask
     VkBool32                                    deviceLUIDValid
 }

 @extension("VK_KHR_external_memory") // 73
 class VkExternalMemoryImageCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalMemoryHandleTypeFlagsKHR          handleTypes
 }

 @extension("VK_KHR_external_memory") // 73
 class VkExternalMemoryBufferCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalMemoryHandleTypeFlagsKHR          handleTypes
 }

 @extension("VK_KHR_external_memory") // 73
 class VkExportMemoryAllocateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalMemoryHandleTypeFlagsKHR          handleTypes
 }

 @extension("VK_KHR_external_memory_win32") // 74
 class VkImportMemoryWin32HandleInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalMemoryHandleTypeFlagBitsKHR       handleType
     platform.HANDLE                             handle
     platform.LPCWSTR                            name
 }

 @extension("VK_KHR_external_memory_win32") // 74
 class VkExportMemoryWin32HandleInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     const platform.SECURITY_ATTRIBUTES*         pAttributes
     platform.DWORD                              dwAccess
     platform.LPCWSTR                            name
 }

 @extension("VK_KHR_external_memory_win32") // 74
 class VkMemoryWin32HandlePropertiesKHR {
     VkStructureType                             sType
     void*                                       pNext
     u32                                         memoryTypeBits
 }

 @extension("VK_KHR_external_memory_win32") // 74
 class VkMemoryGetWin32HandleInfoKHR {
     VkStructureType                             sType
     void*                                       pNext
     VkDeviceMemory                              memory
     VkExternalMemoryHandleTypeFlagBitsKHR       handleType
 }

 @extension("VK_KHR_external_memory_fd") // 75
 class VkImportMemoryFdInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalMemoryHandleTypeFlagBitsKHR       handleType
     int                                         fd
 }

 @extension("VK_KHR_external_memory_fd") // 75
 class VkMemoryFdPropertiesKHR {
     VkStructureType                             sType
     void*                                       pNext
     u32                                         memoryTypeBits
 }

 @extension("VK_KHR_external_memory_fd") // 75
 class VkMemoryGetFdInfoKHR {
     VkStructureType                             sType
     void*                                       pNext
     VkDeviceMemory                              memory
     VkExternalMemoryHandleTypeFlagBitsKHR       handleType
 }

 @extension("VK_KHR_win32_keyed_mutex") // 76
 class VkWin32KeyedMutexAcquireReleaseInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         acquireCount
     const VkDeviceMemory*                       pAcquireSyncs
     const u64*                                  pAcquireKeys
     const u32*                                  pAcquireTimeouts
     u32                                         releaseCount
     const VkDeviceMemory*                       pReleaseSyncs
     const u64*                                  pReleaseKeys
 }

 @extension("VK_KHR_external_semaphore_capabilities") // 77
 class VkPhysicalDeviceExternalSemaphoreInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType
 }

 @extension("VK_KHR_external_semaphore_capabilities") // 77
 class VkExternalSemaphorePropertiesKHR {
     VkStructureType                             sType
     void*                                       pNext
     VkExternalSemaphoreHandleTypeFlagsKHR       exportFromImportedHandleTypes
     VkExternalSemaphoreHandleTypeFlagsKHR       compatibleHandleTypes
     VkExternalSemaphoreFeatureFlagsKHR          externalSemaphoreFeatures
 }

 @extension("VK_KHR_external_semaphore") // 78
 class VkExportSemaphoreCreateInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkExternalSemaphoreHandleTypeFlagsKHR       handleTypes
 }

 @extension("VK_KHR_external_semaphore_win32") // 79
 class VkImportSemaphoreWin32HandleInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkSemaphore                                 semaphore
     VkSemaphoreImportFlagsKHR                   flags
     VkExternalSemaphoreHandleTypeFlagsKHR       handleType
     platform.HANDLE                             handle
     platform.LPCWSTR                            name
 }

 @extension("VK_KHR_external_semaphore_win32") // 79
 class VkExportSemaphoreWin32HandleInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     const platform.SECURITY_ATTRIBUTES*         pAttributes
     platform.DWORD                              dwAccess
     platform.LPCWSTR                            name
 }

 @extension("VK_KHR_external_semaphore_win32") // 79
 class VkD3D12FenceSubmitInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         waitSemaphoreValuesCount
     const u64*                                  pWaitSemaphoreValues
     u32                                         signalSemaphoreValuesCount
     const u64*                                  pSignalSemaphoreValues
 }

 @extension("VK_KHR_external_semaphore_win32") // 79
 class VkSemaphoreGetWin32HandleInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkSemaphore                                 semaphore
     VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType
 }

 @extension("VK_KHR_external_semaphore_fd") // 80
 class VkImportSemaphoreFdInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkSemaphore                                 semaphore
     VkSemaphoreImportFlagsKHR                   flags
     VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType
     s32                                         fd
 }

 @extension("VK_KHR_external_semaphore_fd") // 80
 class VkSemaphoreGetFdInfoKHR {
     VkStructureType                             sType
     const void*                                 pNext
     VkSemaphore                                 semaphore
     VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType
 }

 @extension("VK_KHR_push_descriptor") // 81
 class VkPhysicalDevicePushDescriptorPropertiesKHR {
     VkStructureType                             sType
     void*                                       pNext
     u32                                         maxPushDescriptors
 }

 @extension("VK_EXT_conditional_rendering") // 82
 class VkConditionalRenderingBeginInfoEXT {
     VkStructureType                             sType
     const void*                                 pNext
     VkBuffer                                    buffer
     VkDeviceSize                                offset
     VkConditionalRenderingFlagsEXT              flags
 }

 @extension("VK_EXT_conditional_rendering") // 82
 class VkPhysicalDeviceConditionalRenderingFeaturesEXT {
     VkStructureType                             sType
     void*                                       pNext
     VkBool32                                    conditionalRendering
     VkBool32                                    inheritedConditionalRendering
 }

 @extension("VK_EXT_conditional_rendering") // 82
 class VkCommandBufferInheritanceConditionalRenderingInfoEXT {
     VkStructureType                             sType
     const void*                                 pNext
     VkBool32                                    conditionalRenderingEnable
 }

 @extension("VK_KHR_16bit_storage") // 84
 class VkPhysicalDevice16BitStorageFeaturesKHR {
     VkStructureType                             sType
     void*                                       pNext
     VkBool32                                    storageBuffer16BitAccess
     VkBool32                                    uniformAndStorageBuffer16BitAccess
     VkBool32                                    storagePushConstant16
     VkBool32                                    storageInputOutput16
 }

 @extension("VK_KHR_incremental_present") // 85
 class VkRectLayerKHR {
     VkOffset2D                                  offset
     VkExtent2D                                  extent
     u32                                         layer
 }

 @extension("VK_KHR_incremental_present") // 85
 class VkPresentRegionKHR {
     u32                                         rectangleCount
     const VkRectLayerKHR*                       pRectangles
 }

 @extension("VK_KHR_incremental_present") // 85
 class VkPresentRegionsKHR {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         swapchainCount
     const VkPresentRegionKHR*                   pRegions
 }

 @extension("VK_KHR_descriptor_update_template") // 86
 class VkDescriptorUpdateTemplateEntryKHR {
     u32                                         dstBinding
     u32                                         dstArrayElement
     u32                                         descriptorCount
     VkDescriptorType                            descriptorType
     platform.size_t                             offset
     platform.size_t                             stride
 }

 @extension("VK_KHR_descriptor_update_template") // 86
 class VkDescriptorUpdateTemplateCreateInfoKHR {
     VkStructureType                              sType
     void*                                        pNext
     VkDescriptorUpdateTemplateCreateFlagsKHR     flags
     u32                                          descriptorUpdateEntryCount
     const VkDescriptorUpdateTemplateEntryKHR*    pDescriptorUpdateEntries
     VkDescriptorUpdateTemplateTypeKHR            templateType
     VkDescriptorSetLayout                        descriptorSetLayout
     VkPipelineBindPoint                          pipelineBindPoint
     VkPipelineLayout                             pipelineLayout
     u32                                          set
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkDeviceGeneratedCommandsFeaturesNVX {
     VkStructureType                             sType
     const void*                                 pNext
     VkBool32                                    computeBindingPointSupport
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkDeviceGeneratedCommandsLimitsNVX {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         maxIndirectCommandsLayoutTokenCount
     u32                                         maxObjectEntryCounts
     u32                                         minSequenceCountBufferOffsetAlignment
     u32                                         minSequenceIndexBufferOffsetAlignment
     u32                                         minCommandsTokenBufferOffsetAlignment
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkIndirectCommandsTokenNVX {
     VkIndirectCommandsTokenTypeNVX              tokenType
     VkBuffer                                    buffer
     VkDeviceSize                                offset
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkIndirectCommandsLayoutTokenNVX {
     VkIndirectCommandsTokenTypeNVX              tokenType
     u32                                         bindingUnit
     u32                                         dynamicCount
     u32                                         divisor
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkIndirectCommandsLayoutCreateInfoNVX {
     VkStructureType                             sType
     const void*                                 pNext
     VkPipelineBindPoint                         pipelineBindPoint
     VkIndirectCommandsLayoutUsageFlagsNVX       flags
     u32                                         tokenCount
     const VkIndirectCommandsLayoutTokenNVX*     pTokens
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkCmdProcessCommandsInfoNVX {
     VkStructureType                             sType
     const void*                                 pNext
     VkObjectTableNVX                            objectTable
     VkIndirectCommandsLayoutNVX                 indirectCommandsLayout
     u32                                         indirectCommandsTokenCount
     const VkIndirectCommandsTokenNVX*           pIndirectCommandsTokens
     u32                                         maxSequencesCount
     VkCommandBuffer                             targetCommandBuffer
     VkBuffer                                    sequencesCountBuffer
     VkDeviceSize                                sequencesCountOffset
     VkBuffer                                    sequencesIndexBuffer
     VkDeviceSize                                sequencesIndexOffset
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkCmdReserveSpaceForCommandsInfoNVX {
     VkStructureType                             sType
     const void*                                 pNext
     VkObjectTableNVX                            objectTable
     VkIndirectCommandsLayoutNVX                 indirectCommandsLayout
     u32                                         maxSequencesCount
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkObjectTableCreateInfoNVX {
     VkStructureType                             sType
     const void*                                 pNext
     u32                                         objectCount
     const VkObjectEntryTypeNVX*                 pObjectEntryTypes
     const u32*                                  pObjectEntryCounts
     const VkObjectEntryUsageFlagsNVX*           pObjectEntryUsageFlags
     u32                                         maxUniformBuffersPerDescriptor
     u32                                         maxStorageBuffersPerDescriptor
     u32                                         maxStorageImagesPerDescriptor
     u32                                         maxSampledImagesPerDescriptor
     u32                                         maxPipelineLayouts
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkObjectTableEntryNVX {
     VkObjectEntryTypeNVX                        type
     VkObjectEntryUsageFlagsNVX                  flags
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkObjectTablePipelineEntryNVX {
     VkObjectEntryTypeNVX                        type
     VkObjectEntryUsageFlagsNVX                  flags
     VkPipeline                                  pipeline
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkObjectTableDescriptorSetEntryNVX {
     VkObjectEntryTypeNVX                        type
     VkObjectEntryUsageFlagsNVX                  flags
     VkPipelineLayout                            pipelineLayout
     VkDescriptorSet                             descriptorSet
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkObjectTableVertexBufferEntryNVX {
     VkObjectEntryTypeNVX                        type
     VkObjectEntryUsageFlagsNVX                  flags
     VkBuffer                                    buffer
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkObjectTableIndexBufferEntryNVX {
     VkObjectEntryTypeNVX                        type
     VkObjectEntryUsageFlagsNVX                  flags
     VkBuffer                                    buffer
     VkIndexType                                 indexType
 }

 @extension("VK_NVX_device_generated_commands") // 87
 class VkObjectTablePushConstantEntryNVX {
     VkObjectEntryTypeNVX                        type
     VkObjectEntryUsageFlagsNVX                  flags
     VkPipelineLayout                            pipelineLayout
     VkShaderStageFlags                          stageFlags
 }

 @extension("VK_NV_clip_space_w_scaling") // 88
 class VkViewportWScalingNV {
     f32                                         xcoeff
     f32                                         ycoeff
 }

 @extension("VK_NV_clip_space_w_scaling") // 88
 class VkPipelineViewportWScalingStateCreateInfoNV {
     VkStructureType                             sType
     const void*                                 pNext
     VkBool32                                    viewportWScalingEnable
     u32                                         viewportCount
     const VkViewportWScalingNV*                 pViewportWScalings
 }

 @extension("VK_EXT_display_surface_counter") // 91
 class VkSurfaceCapabilities2EXT {
     VkStructureType                             sType
     void*                                       pNext
     u32                                         minImageCount
     u32                                         maxImageCount
     VkExtent2D                                  currentExtent
     VkExtent2D                                  minImageExtent
     VkExtent2D                                  maxImageExtent
     u32                                         maxImageArrayLayers
     VkSurfaceTransformFlagsKHR                  supportedTransforms
     VkSurfaceTransformFlagBitsKHR               currentTransform
     VkCompositeAlphaFlagsKHR                    supportedCompositeAlpha
     VkImageUsageFlags                           supportedUsageFlags
     VkSurfaceCounterFlagsEXT                    supportedSurfaceCounters
 }

 @extension("VK_EXT_display_control") // 92
 class VkDisplayPowerInfoEXT {
     VkStructureType                             sType
     const void*                                 pNext
     VkDisplayPowerStateEXT                      powerState
 }

 @extension("VK_EXT_display_control") // 92
 class VkDeviceEventInfoEXT {
     VkStructureType                             sType
     const void*                                 pNext
     VkDeviceEventTypeEXT                        deviceEvent
 }

 @extension("VK_EXT_display_control") // 92
 class VkDisplayEventInfoEXT {
     VkStructureType                             sType
     const void*                                 pNext
     VkDisplayEventTypeEXT                       displayEvent
 }

 @extension("VK_EXT_display_control") // 92
 class VkSwapchainCounterCreateInfoEXT {
     VkStructureType                             sType
     const void*                                 pNext
     VkSurfaceCounterFlagsEXT                    surfaceCounters
 }

 @extension("VK_GOOGLE_display_timing") // 93
 class VkRefreshCycleDurationGOOGLE {
     u64                                             refreshDuration
 }

 @extension("VK_GOOGLE_display_timing") // 93
 class VkPastPresentationTimingGOOGLE {
     u32                                             presentID
     u64                                             desiredPresentTime
     u64                                             actualPresentTime
     u64                                             earliestPresentTime
     u64                                             presentMargin
 }

 @extension("VK_GOOGLE_display_timing") // 93
 class VkPresentTimeGOOGLE {
     u32                                             presentID
     u64                                             desiredPresentTime
 }

 @extension("VK_GOOGLE_display_timing") // 93
 class VkPresentTimesInfoGOOGLE {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             swapchainCount
     const VkPresentTimeGOOGLE*                      pTimes
 }

 @extension("VK_NVX_multiview_per_view_attributes") // 98
 class VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
     VkStructureType                             sType
     void*                                       pNext
     VkBool32                                    perViewPositionAllComponents
 }

 @extension("VK_NV_viewport_swizzle") // 99
 class VkViewportSwizzleNV {
     VkViewportCoordinateSwizzleNV               x
     VkViewportCoordinateSwizzleNV               y
     VkViewportCoordinateSwizzleNV               z
     VkViewportCoordinateSwizzleNV               w
 }

 @extension("VK_NV_viewport_swizzle") // 99
 class VkPipelineViewportSwizzleStateCreateInfoNV {
     VkStructureType                             sType
     const void*                                 pNext
     VkPipelineViewportSwizzleStateCreateFlagsNV flags
     u32                                         viewportCount
     const VkViewportSwizzleNV*                  pViewportSwizzles
 }

 @extension("VK_EXT_discard_rectangles") // 100
 class VkPhysicalDeviceDiscardRectanglePropertiesEXT {
     VkStructureType                             sType
     void*                                       pNext
     u32                                         maxDiscardRectangles
 }

 @extension("VK_EXT_discard_rectangles") // 100
 class VkPipelineDiscardRectangleStateCreateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkPipelineDiscardRectangleStateCreateFlagsEXT   flags
     VkDiscardRectangleModeEXT                       discardRectangleMode
     u32                                             discardRectangleCount
     const VkRect2D*                                 pDiscardRectangles
 }

 @extension("VK_EXT_conservative_rasterization") // 102
 class VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     f32                                             primitiveOverestimationSize
     f32                                             maxExtraPrimitiveOverestimationSize
     f32                                             extraPrimitiveOverestimationSizeGranularity
     VkBool32                                        primitiveUnderestimation
     VkBool32                                        conservativePointAndLineRasterization
     VkBool32                                        degenerateTrianglesRasterized
     VkBool32                                        degenerateLinesRasterized
     VkBool32                                        fullyCoveredFragmentShaderInputVariable
     VkBool32                                        conservativeRasterizationPostDepthCoverage
 }

 @extension("VK_EXT_conservative_rasterization") // 102
 class VkPipelineRasterizationConservativeStateCreateInfoEXT {
     VkStructureType                                           sType
     const void*                                               pNext
     VkPipelineRasterizationConservativeStateCreateFlagsEXT    flags
     VkConservativeRasterizationModeEXT                        conservativeRasterizationMode
     f32                                                       extraPrimitiveOverestimationSize
 }

 @extension("VK_EXT_hdr_metadata") // 106
 class VkXYColorEXT {
     f32                                             x
     f32                                             y
 }

 @extension("VK_EXT_hdr_metadata") // 106
 class VkHdrMetadataEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkXYColorEXT                                    displayPrimaryRed
     VkXYColorEXT                                    displayPrimaryGreen
     VkXYColorEXT                                    displayPrimaryBlue
     VkXYColorEXT                                    whitePoint
     f32                                             maxLuminance
     f32                                             minLuminance
     f32                                             maxContentLightLevel
     f32                                             maxFrameAverageLightLevel
 }

 @extension("VK_KHR_create_renderpass2") // 110
 class VkAttachmentDescription2KHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkAttachmentDescriptionFlags                    flags
     VkFormat                                        format
     VkSampleCountFlagBits                           samples
     VkAttachmentLoadOp                              loadOp
     VkAttachmentStoreOp                             storeOp
     VkAttachmentLoadOp                              stencilLoadOp
     VkAttachmentStoreOp                             stencilStoreOp
     VkImageLayout                                   initialLayout
     VkImageLayout                                   finalLayout
 }

 @extension("VK_KHR_create_renderpass2") // 110
 class VkAttachmentReference2KHR {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             attachment
     VkImageLayout                                   layout
     VkImageAspectFlags                              aspectMask
 }

 @extension("VK_KHR_create_renderpass2") // 110
 class VkSubpassDescription2KHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkSubpassDescriptionFlags                       flags
     VkPipelineBindPoint                             pipelineBindPoint
     u32                                             viewMask
     u32                                             inputAttachmentCount
     const VkAttachmentReference2KHR*                pInputAttachments
     u32                                             colorAttachmentCount
     const VkAttachmentReference2KHR*                pColorAttachments
     const VkAttachmentReference2KHR*                pResolveAttachments
     const VkAttachmentReference2KHR*                pDepthStencilAttachment
     u32                                             preserveAttachmentCount
     const u32*                                      pPreserveAttachments
 }

 @extension("VK_KHR_create_renderpass2") // 110
 class VkSubpassDependency2KHR {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             srcSubpass
     u32                                             dstSubpass
     VkPipelineStageFlags                            srcStageMask
     VkPipelineStageFlags                            dstStageMask
     VkAccessFlags                                   srcAccessMask
     VkAccessFlags                                   dstAccessMask
     VkDependencyFlags                               dependencyFlags
     s32                                             viewOffset
 }

 @extension("VK_KHR_create_renderpass2") // 110
 class VkRenderPassCreateInfo2KHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkRenderPassCreateFlags                         flags
     u32                                             attachmentCount
     const VkAttachmentDescription2KHR*              pAttachments
     u32                                             subpassCount
     const VkSubpassDescription2KHR*                 pSubpasses
     u32                                             dependencyCount
     const VkSubpassDependency2KHR*                  pDependencies
     u32                                             correlatedViewMaskCount
     const u32*                                      pCorrelatedViewMasks
 }

 @extension("VK_KHR_create_renderpass2") // 110
 class VkSubpassBeginInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkSubpassContents                               contents
 }

 @extension("VK_KHR_create_renderpass2") // 110
 class VkSubpassEndInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
 }

 @extension("VK_KHR_shared_presentable_image") // 112
 class VkSharedPresentSurfaceCapabilitiesKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkImageUsageFlags                               sharedPresentSupportedUsageFlags
 }

 @extension("VK_KHR_external_fence_capabilities") // 113
 class VkPhysicalDeviceExternalFenceInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkExternalFenceHandleTypeFlagBitsKHR            handleType
 }

 @extension("VK_KHR_external_fence_capabilities") // 113
 class VkExternalFencePropertiesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkExternalFenceHandleTypeFlagsKHR               exportFromImportedHandleTypes
     VkExternalFenceHandleTypeFlagsKHR               compatibleHandleTypes
     VkExternalFenceFeatureFlagsKHR                  externalFenceFeatures
 }

 @extension("VK_KHR_external_fence") // 114
 class VkExportFenceCreateInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkExternalFenceHandleTypeFlagsKHR               handleTypes
 }

 @extension("VK_KHR_external_fence_win32") // 115
 class VkImportFenceWin32HandleInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkFence                                         fence
     VkFenceImportFlagsKHR                           flags
     VkExternalFenceHandleTypeFlagBitsKHR            handleType
     platform.HANDLE                                 handle
     platform.LPCWSTR                                name
 }

 @extension("VK_KHR_external_fence_win32") // 115
 class VkExportFenceWin32HandleInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     const platform.SECURITY_ATTRIBUTES*             pAttributes
     platform.DWORD                                  dwAccess
     platform.LPCWSTR                                name
 }

 @extension("VK_KHR_external_fence_win32") // 115
 class VkFenceGetWin32HandleInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkFence                                         fence
     VkExternalFenceHandleTypeFlagBitsKHR            handleType
 }

 @extension("VK_KHR_external_fence_fd") // 116
 class VkImportFenceFdInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkFence                                         fence
     VkFenceImportFlagsKHR                           flags
     VkExternalFenceHandleTypeFlagBitsKHR            handleType
     int                                             fd
 }

 @extension("VK_KHR_external_fence_fd") // 116
 class VkFenceGetFdInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkFence                                         fence
     VkExternalFenceHandleTypeFlagBitsKHR            handleType
 }

 @extension("VK_KHR_maintenance2") // 118
 class VkPhysicalDevicePointClippingPropertiesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkPointClippingBehaviorKHR                      pointClippingBehavior
 }

 @extension("VK_KHR_maintenance2") // 118
 class VkInputAttachmentAspectReferenceKHR {
     u32                                             subpass
     u32                                             inputAttachmentIndex
     VkImageAspectFlags                              aspectMask
 }

 @extension("VK_KHR_maintenance2") // 118
 class VkRenderPassInputAttachmentAspectCreateInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             aspectReferenceCount
     const VkInputAttachmentAspectReferenceKHR*      pAspectReferences
 }

 @extension("VK_KHR_maintenance2") // 118
 class VkImageViewUsageCreateInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkImageUsageFlags                               usage
 }

 @extension("VK_KHR_maintenance2") // 118
 class VkPipelineTessellationDomainOriginStateCreateInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkTessellationDomainOriginKHR                   domainOrigin
 }

 @extension("VK_KHR_get_surface_capabilities2") // 120
 class VkPhysicalDeviceSurfaceInfo2KHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkSurfaceKHR                                    surface
 }

 @extension("VK_KHR_get_surface_capabilities2") // 120
 class VkSurfaceCapabilities2KHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkSurfaceCapabilitiesKHR                        surfaceCapabilities
 }

 @extension("VK_KHR_get_surface_capabilities2") // 120
 class VkSurfaceFormat2KHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkSurfaceFormatKHR                              surfaceFormat
 }

 @extension("VK_KHR_variable_pointers") // 121
 class VkPhysicalDeviceVariablePointerFeaturesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        variablePointersStorageBuffer
     VkBool32                                        variablePointers
 }

 @extension("VK_KHR_display_properties2") // 122
 class VkDisplayProperties2KHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkDisplayPropertiesKHR                          displayProperties
 }

 @extension("VK_KHR_display_properties2") // 122
 class VkDisplayPlaneProperties2KHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkDisplayPlanePropertiesKHR                     displayPlaneProperties
 }

 @extension("VK_KHR_display_properties2") // 122
 class VkDisplayModeProperties2KHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkDisplayModePropertiesKHR                      displayModeProperties
 }

 @extension("VK_KHR_display_properties2") // 122
 class VkDisplayPlaneInfo2KHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkDisplayModeKHR                                mode
     u32                                             planeIndex
 }

 @extension("VK_KHR_display_properties2") // 122
 class VkDisplayPlaneCapabilities2KHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkDisplayPlaneCapabilitiesKHR                   capabilities
 }

 @extension("VK_MVK_ios_surface") // 123
 class VkIOSSurfaceCreateInfoMVK {
     VkStructureType                                 sType
     const void*                                     pNext
     VkIOSSurfaceCreateFlagsMVK                      flags
     const void*                                     pView
 }

 @extension("VK_MVK_macos_surface") // 124
 class VkMacOSSurfaceCreateInfoMVK {
     VkStructureType                                 sType
     const void*                                     pNext
     VkMacOSSurfaceCreateFlagsMVK                    flags
     const void*                                     pView
 }

 @extension("VK_KHR_dedicated_allocation") // 128
 class VkMemoryDedicatedRequirementsKHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        prefersDedicatedAllocation
     VkBool32                                        requiresDedicatedAllocation
 }

 @extension("VK_KHR_dedicated_allocation") // 128
 class VkMemoryDedicatedAllocateInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkImage                                         image
     VkBuffer                                        buffer
 }

 @extension("VK_EXT_debug_utils") // 129
 class VkDebugUtilsObjectNameInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkObjectType                                    objectType
     u64                                             objectHandle
     const char*                                     pObjectName
 }

 @extension("VK_EXT_debug_utils") // 129
 class VkDebugUtilsObjectTagInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkObjectType                                    objectType
     u64                                             objectHandle
     u64                                             tagName
     platform.size_t                                 tagSize
     const void*                                     pTag
 }

 @extension("VK_EXT_debug_utils") // 129
 class VkDebugUtilsLabelEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     const char*                                     pLabelName
     f32[4]                                          color
 }

 @extension("VK_EXT_debug_utils") // 129
 class VkDebugUtilsMessengerCallbackDataEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkDebugUtilsMessengerCallbackDataFlagsEXT       flags
     const char*                                     pMessageIdName
     s32                                             messageIdNumber
     const char*                                     pMessage
     u32                                             queueLabelCount
     VkDebugUtilsLabelEXT*                           pQueueLabels
     u32                                             cmdBufLabelCount
     VkDebugUtilsLabelEXT*                           pCmdBufLabels
     u32                                             objectCount
     VkDebugUtilsObjectNameInfoEXT*                  pObjects
 }

 @extension("VK_EXT_debug_utils") // 129
 class VkDebugUtilsMessengerCreateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkDebugUtilsMessengerCreateFlagsEXT             flags
     VkDebugUtilsMessageSeverityFlagsEXT             messageSeverity
     VkDebugUtilsMessageTypeFlagsEXT                 messageType
     PFN_vkDebugUtilsMessengerCallbackEXT            pfnUserCallback
     void*                                           pUserData
 }

 @extension("VK_ANDROID_external_memory_android_hardware_buffer") // 131
 class VkAndroidHardwareBufferUsageANDROID {
     VkStructureType                                 sType
     void*                                           pNext
     u64                                             androidHardwareBufferUsage
 }

 @extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
 class VkAndroidHardwareBufferPropertiesANDROID {
     VkStructureType                                 sType
     void*                                           pNext
     VkDeviceSize                                    allocationSize
     u32                                             memoryTypeBits
 }

 @extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
 class VkAndroidHardwareBufferFormatPropertiesANDROID {
     VkStructureType                                 sType
     void*                                           pNext
     VkFormat                                        format
     u64                                             externalFormat
     VkFormatFeatureFlags                            formatFeatures
     VkComponentMapping                              samplerYcbcrConversionComponents
     VkSamplerYcbcrModelConversion                   suggestedYcbcrModel
     VkSamplerYcbcrRange                             suggestedYcbcrRange
     VkChromaLocation                                suggestedXChromaOffset
     VkChromaLocation                                suggestedYChromaOffset
 }

 @extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
 class VkImportAndroidHardwareBufferInfoANDROID {
     VkStructureType                                 sType
     const void*                                     pNext
     platform.AHardwareBuffer*                       buffer
 }

 @extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
 class VkMemoryGetAndroidHardwareBufferInfoANDROID {
     VkStructureType                                 sType
     const void*                                     pNext
     VkDeviceMemory                                  memory
 }

 @extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
 class VkExternalFormatANDROID {
     VkStructureType                                 sType
     void*                                           pNext
     u64                                             externalFormat
 }

 @extension("VK_EXT_sampler_filter_minmax") // 131
 class VkSamplerReductionModeCreateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkSamplerReductionModeEXT                       reductionMode
 }

 @extension("VK_EXT_sampler_filter_minmax") // 131
 class VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        filterMinmaxSingleComponentFormats
     VkBool32                                        filterMinmaxImageComponentMapping
 }

 @extension("VK_EXT_inline_uniform_block") // 139
 class VkPhysicalDeviceInlineUniformBlockFeaturesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        inlineUniformBlock
     VkBool32                                        descriptorBindingInlineUniformBlockUpdateAfterBind
 }

 @extension("VK_EXT_inline_uniform_block") // 139
 class VkPhysicalDeviceInlineUniformBlockPropertiesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             maxInlineUniformBlockSize
     u32                                             maxPerStageDescriptorInlineUniformBlocks
     u32                                             maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks
     u32                                             maxDescriptorSetInlineUniformBlocks
     u32                                             maxDescriptorSetUpdateAfterBindInlineUniformBlocks
 }

 @extension("VK_EXT_inline_uniform_block") // 139
 class VkWriteDescriptorSetInlineUniformBlockEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             dataSize
     const void*                                     pData
 }

 @extension("VK_EXT_inline_uniform_block") // 139
 class VkDescriptorPoolInlineUniformBlockCreateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             maxInlineUniformBlockBindings
 }

 @extension("VK_EXT_sample_locations") // 144
 class VkSampleLocationEXT {
     f32                                             x
     f32                                             y
 }

 @extension("VK_EXT_sample_locations") // 144
 class VkSampleLocationsInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkSampleCountFlagBits                           sampleLocationsPerPixel
     VkExtent2D                                      sampleLocationGridSize
     u32                                             sampleLocationsCount
     const VkSampleLocationEXT*                      pSampleLocations
 }

 @extension("VK_EXT_sample_locations") // 144
 class VkAttachmentSampleLocationsEXT {
     u32                                             attachmentIndex
     VkSampleLocationsInfoEXT                        sampleLocationsInfo
 }

 @extension("VK_EXT_sample_locations") // 144
 class VkSubpassSampleLocationsEXT {
     u32                                             subpassIndex
     VkSampleLocationsInfoEXT                        sampleLocationsInfo
 }

 @extension("VK_EXT_sample_locations") // 144
 class VkRenderPassSampleLocationsBeginInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             attachmentInitialSampleLocationsCount
     const VkAttachmentSampleLocationsEXT*           pAttachmentInitialSampleLocations
     u32                                             postSubpassSampleLocationsCount
     const VkSubpassSampleLocationsEXT*              pPostSubpassSampleLocations
 }

 @extension("VK_EXT_sample_locations") // 144
 class VkPipelineSampleLocationsStateCreateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkBool32                                        sampleLocationsEnable
     VkSampleLocationsInfoEXT                        sampleLocationsInfo
 }

 @extension("VK_EXT_sample_locations") // 144
 class VkPhysicalDeviceSampleLocationsPropertiesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     VkSampleCountFlags                              sampleLocationSampleCounts
     VkExtent2D                                      maxSampleLocationGridSize
     f32[2]                                          sampleLocationCoordinateRange
     u32                                             sampleLocationSubPixelBits
     VkBool32                                        variableSampleLocations
 }

 @extension("VK_EXT_sample_locations") // 144
 class VkMultisamplePropertiesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     VkExtent2D                                      maxSampleLocationGridSize
 }

 @extension("VK_KHR_get_memory_requirements2") // 147
 class VkBufferMemoryRequirementsInfo2KHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkBuffer                                        buffer
 }

 @extension("VK_KHR_get_memory_requirements2") // 147
 class VkImageMemoryRequirementsInfo2KHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkImage                                         image
 }

 @extension("VK_KHR_get_memory_requirements2") // 147
 class VkImageSparseMemoryRequirementsInfo2KHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkImage                                         image
 }

 @extension("VK_KHR_get_memory_requirements2") // 147
 class VkMemoryRequirements2KHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkMemoryRequirements                            memoryRequirements
 }

 @extension("VK_KHR_get_memory_requirements2") // 147
 class VkSparseImageMemoryRequirements2KHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkSparseImageMemoryRequirements                 memoryRequirements
 }

 @extension("VK_KHR_image_format_list") // 148
 class VkImageFormatListCreateInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             viewFormatCount
     const VkFormat*                                 pViewFormats
 }

 @extension("VK_EXT_blend_operation_advanced") // 149
 class VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        advancedBlendCoherentOperations
 }

 @extension("VK_EXT_blend_operation_advanced") // 149
 class VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             advancedBlendMaxColorAttachments
     VkBool32                                        advancedBlendIndependentBlend
     VkBool32                                        advancedBlendNonPremultipliedSrcColor
     VkBool32                                        advancedBlendNonPremultipliedDstColor
     VkBool32                                        advancedBlendCorrelatedOverlap
     VkBool32                                        advancedBlendAllOperations
 }

 @extension("VK_EXT_blend_operation_advanced") // 149
 class VkPipelineColorBlendAdvancedStateCreateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkBool32                                        srcPremultiplied
     VkBool32                                        dstPremultiplied
     VkBlendOverlapEXT                               blendOverlap
 }

 @extension("VK_NV_fragment_coverage_to_color") // 150
 class VkPipelineCoverageToColorStateCreateInfoNV {
     VkStructureType                                 sType
     const void*                                     pNext
     VkPipelineCoverageToColorStateCreateFlagsNV     flags
     VkBool32                                        coverageToColorEnable
     u32                                             coverageToColorLocation
 }

 @extension("VK_NV_framebuffer_mixed_samples") // 153
 class VkPipelineCoverageModulationStateCreateInfoNV {
     VkStructureType                                 sType
     const void*                                     pNext
     VkPipelineCoverageModulationStateCreateFlagsNV  flags
     VkCoverageModulationModeNV                      coverageModulationMode
     VkBool32                                        coverageModulationTableEnable
     u32                                             coverageModulationTableCount
     const f32*                                      pCoverageModulationTable
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 class VkSamplerYcbcrConversionCreateInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkFormat                                        format
     VkSamplerYcbcrModelConversionKHR                ycbcrModel
     VkSamplerYcbcrRangeKHR                          ycbcrRange
     VkComponentMapping                              components
     VkChromaLocationKHR                             xChromaOffset
     VkChromaLocationKHR                             yChromaOffset
     VkFilter                                        chromaFilter
     VkBool32                                        forceExplicitReconstruction
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 class VkSamplerYcbcrConversionInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkSamplerYcbcrConversionKHR                     conversion
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 class VkBindImagePlaneMemoryInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkImageAspectFlagBits                           planeAspect
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 class VkImagePlaneMemoryRequirementsInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkImageAspectFlagBits                           planeAspect
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 class VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        samplerYcbcrConversion
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 class VkSamplerYcbcrConversionImageFormatPropertiesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             combinedImageSamplerDescriptorCount
 }

 @extension("VK_KHR_bind_memory2") // 158
 class VkBindBufferMemoryInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkBuffer                                        buffer
     VkDeviceMemory                                  memory
     VkDeviceSize                                    memoryOffset
 }

 @extension("VK_KHR_bind_memory2") // 158
 class VkBindImageMemoryInfoKHR {
     VkStructureType                                 sType
     const void*                                     pNext
     VkImage                                         image
     VkDeviceMemory                                  memory
     VkDeviceSize                                    memoryOffset
 }

 @extension("VK_EXT_validation_cache") // 161
 class VkValidationCacheCreateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkValidationCacheCreateFlagsEXT                 flags
     platform.size_t                                 initialDataSize
     const void*                                     pInitialData
 }

 @extension("VK_EXT_validation_cache") // 161
 class VkShaderModuleValidationCacheCreateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkValidationCacheEXT                            validationCache
 }

 @extension("VK_EXT_descriptor_indexing") // 162
 class VkDescriptorSetLayoutBindingFlagsCreateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             bindingCount
     const VkDescriptorBindingFlagsEXT*              pBindingFlags
 }

 @extension("VK_EXT_descriptor_indexing") // 162
 class VkPhysicalDeviceDescriptorIndexingFeaturesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        shaderInputAttachmentArrayDynamicIndexing
     VkBool32                                        shaderUniformTexelBufferArrayDynamicIndexing
     VkBool32                                        shaderStorageTexelBufferArrayDynamicIndexing
     VkBool32                                        shaderUniformBufferArrayNonUniformIndexing
     VkBool32                                        shaderSampledImageArrayNonUniformIndexing
     VkBool32                                        shaderStorageBufferArrayNonUniformIndexing
     VkBool32                                        shaderStorageImageArrayNonUniformIndexing
     VkBool32                                        shaderInputAttachmentArrayNonUniformIndexing
     VkBool32                                        shaderUniformTexelBufferArrayNonUniformIndexing
     VkBool32                                        shaderStorageTexelBufferArrayNonUniformIndexing
     VkBool32                                        descriptorBindingUniformBufferUpdateAfterBind
     VkBool32                                        descriptorBindingSampledImageUpdateAfterBind
     VkBool32                                        descriptorBindingStorageImageUpdateAfterBind
     VkBool32                                        descriptorBindingStorageBufferUpdateAfterBind
     VkBool32                                        descriptorBindingUniformTexelBufferUpdateAfterBind
     VkBool32                                        descriptorBindingStorageTexelBufferUpdateAfterBind
     VkBool32                                        descriptorBindingUpdateUnusedWhilePending
     VkBool32                                        descriptorBindingPartiallyBound
     VkBool32                                        descriptorBindingVariableDescriptorCount
     VkBool32                                        runtimeDescriptorArray
 }

 @extension("VK_EXT_descriptor_indexing") // 162
 class VkPhysicalDeviceDescriptorIndexingPropertiesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             maxUpdateAfterBindDescriptorsInAllPools
     VkBool32                                        shaderUniformBufferArrayNonUniformIndexingNative
     VkBool32                                        shaderSampledImageArrayNonUniformIndexingNative
     VkBool32                                        shaderStorageBufferArrayNonUniformIndexingNative
     VkBool32                                        shaderStorageImageArrayNonUniformIndexingNative
     VkBool32                                        shaderInputAttachmentArrayNonUniformIndexingNative
     VkBool32                                        robustBufferAccessUpdateAfterBind
     VkBool32                                        quadDivergentImplicitLod
     u32                                             maxPerStageDescriptorUpdateAfterBindSamplers
     u32                                             maxPerStageDescriptorUpdateAfterBindUniformBuffers
     u32                                             maxPerStageDescriptorUpdateAfterBindStorageBuffers
     u32                                             maxPerStageDescriptorUpdateAfterBindSampledImages
     u32                                             maxPerStageDescriptorUpdateAfterBindStorageImages
     u32                                             maxPerStageDescriptorUpdateAfterBindInputAttachments
     u32                                             maxPerStageUpdateAfterBindResources
     u32                                             maxDescriptorSetUpdateAfterBindSamplers
     u32                                             maxDescriptorSetUpdateAfterBindUniformBuffers
     u32                                             maxDescriptorSetUpdateAfterBindUniformBuffersDynamic
     u32                                             maxDescriptorSetUpdateAfterBindStorageBuffers
     u32                                             maxDescriptorSetUpdateAfterBindStorageBuffersDynamic
     u32                                             maxDescriptorSetUpdateAfterBindSampledImages
     u32                                             maxDescriptorSetUpdateAfterBindStorageImages
     u32                                             maxDescriptorSetUpdateAfterBindInputAttachments
 }

 @extension("VK_EXT_descriptor_indexing") // 162
 class VkDescriptorSetVariableDescriptorCountAllocateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             descriptorSetCount
     const u32*                                      pDescriptorCounts
 }

 @extension("VK_EXT_descriptor_indexing") // 162
 class VkDescriptorSetVariableDescriptorCountLayoutSupportEXT {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             maxVariableDescriptorCount
 }

 @extension("VK_NV_shading_rate_image") // 165
 class VkShadingRatePaletteNV {
     u32                                             shadingRatePaletteEntryCount
     const VkShadingRatePaletteEntryNV*              pShadingRatePaletteEntries
 }

 @extension("VK_NV_shading_rate_image") // 165
 class VkPipelineViewportShadingRateImageStateCreateInfoNV {
     VkStructureType                                 sType
     const void*                                     pNext
     VkBool32                                        shadingRateImageEnable
     u32                                             viewportCount
     const VkShadingRatePaletteNV*                   pShadingRatePalettes
 }

 @extension("VK_NV_shading_rate_image") // 165
 class VkPhysicalDeviceShadingRateImageFeaturesNV {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        shadingRateImage
     VkBool32                                        shadingRateCoarseSampleOrder
 }

 @extension("VK_NV_shading_rate_image") // 165
 class VkPhysicalDeviceShadingRateImagePropertiesNV {
     VkStructureType                                 sType
     void*                                           pNext
     VkExtent2D                                      shadingRateTexelSize
     u32                                             shadingRatePaletteSize
     u32                                             shadingRateMaxCoarseSamples
 }

 @extension("VK_NV_shading_rate_image") // 165
 class VkCoarseSampleLocationNV {
     u32                                             pixelX
     u32                                             pixelY
     u32                                             sample
 }

 @extension("VK_NV_shading_rate_image") // 165
 class VkCoarseSampleOrderCustomNV {
     VkShadingRatePaletteEntryNV                     shadingRate
     u32                                             sampleCount
     u32                                             sampleLocationCount
     const VkCoarseSampleLocationNV*                 pSampleLocations
 }

 @extension("VK_NV_shading_rate_image") // 165
 class VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
     VkStructureType                                 sType
     const void*                                     pNext
     VkCoarseSampleOrderTypeNV                       sampleOrderType
     u32                                             customSampleOrderCount
     const VkCoarseSampleOrderCustomNV*              pCustomSampleOrders
 }

 @extension("VK_NVX_raytracing") // 166
 class VkRaytracingPipelineCreateInfoNVX {
     VkStructureType                                 sType
     const void*                                     pNext
     VkPipelineCreateFlags                           flags
     u32                                             stageCount
     const VkPipelineShaderStageCreateInfo*          pStages
     const u32*                                      pGroupNumbers
     u32                                             maxRecursionDepth
     VkPipelineLayout                                layout
     VkPipeline                                      basePipelineHandle
     s32                                             basePipelineIndex
 }

 @extension("VK_NVX_raytracing") // 166
 class VkGeometryTrianglesNVX {
     VkStructureType                                 sType
     const void*                                     pNext
     VkBuffer                                        vertexData
     VkDeviceSize                                    vertexOffset
     u32                                             vertexCount
     VkDeviceSize                                    vertexStride
     VkFormat                                        vertexFormat
     VkBuffer                                        indexData
     VkDeviceSize                                    indexOffset
     u32                                             indexCount
     VkIndexType                                     indexType
     VkBuffer                                        transformData
     VkDeviceSize                                    transformOffset
 }

 @extension("VK_NVX_raytracing") // 166
 class VkGeometryAABBNVX {
     VkStructureType                                 sType
     const void*                                     pNext
     VkBuffer                                        aabbData
     u32                                             numAABBs
     u32                                             stride
     VkDeviceSize                                    offset
 }

 @extension("VK_NVX_raytracing") // 166
 class VkGeometryDataNVX {
     VkGeometryTrianglesNVX                          triangles
     VkGeometryAABBNVX                               aabbs
 }

 @extension("VK_NVX_raytracing") // 166
 class VkGeometryNVX {
     VkStructureType                                 sType
     const void*                                     pNext
     VkGeometryTypeNVX                               geometryType
     VkGeometryDataNVX                               geometry
     VkGeometryFlagsNVX                              flags
 }

 @extension("VK_NVX_raytracing") // 166
 class VkAccelerationStructureCreateInfoNVX {
     VkStructureType                                 sType
     const void*                                     pNext
     VkAccelerationStructureTypeNVX                  type
     VkBuildAccelerationStructureFlagsNVX            flags
     VkDeviceSize                                    compactedSize
     u32                                             instanceCount
     u32                                             geometryCount
     const VkGeometryNVX*                            pGeometries
 }

 @extension("VK_NVX_raytracing") // 166
 class VkBindAccelerationStructureMemoryInfoNVX {
     VkStructureType                                 sType
     const void*                                     pNext
     VkAccelerationStructureNVX                      accelerationStructure
     VkDeviceMemory                                  memory
     VkDeviceSize                                    memoryOffset
     u32                                             deviceIndexCount
     const u32*                                      pDeviceIndices
 }

 @extension("VK_NVX_raytracing") // 166
 class VkDescriptorAccelerationStructureInfoNVX {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             accelerationStructureCount
     const VkAccelerationStructureNVX*               pAccelerationStructures
 }

 @extension("VK_NVX_raytracing") // 166
 class VkAccelerationStructureMemoryRequirementsInfoNVX {
     VkStructureType                                 sType
     const void*                                     pNext
     VkAccelerationStructureNVX                      accelerationStructure
 }

 @extension("VK_NVX_raytracing") // 166
 class VkPhysicalDeviceRaytracingPropertiesNVX {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             shaderHeaderSize
     u32                                             maxRecursionDepth
     u32                                             maxGeometryCount
 }

 @extension("VK_NV_representative_fragment_test") // 167
 class VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        representativeFragmentTest
 }

 @extension("VK_NV_representative_fragment_test") // 167
 class VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
     VkStructureType                                 sType
     const void*                                     pNext
     VkBool32                                        representativeFragmentTestEnable
 }

 @extension("VK_KHR_maintenance3") // 169
 class VkPhysicalDeviceMaintenance3PropertiesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             maxPerSetDescriptors
     VkDeviceSize                                    maxMemoryAllocationSize
 }

 @extension("VK_KHR_maintenance3") // 169
 class VkDescriptorSetLayoutSupportKHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        supported
 }

 @extension("VK_EXT_global_priority") // 175
 class VkDeviceQueueGlobalPriorityCreateInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkQueueGlobalPriorityEXT                        globalPriority
 }

 @extension("VK_KHR_8bit_storage") // 178
 class VkPhysicalDevice8BitStorageFeaturesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        storageBuffer8BitAccess
     VkBool32                                        uniformAndStorageBuffer8BitAccess
     VkBool32                                        storagePushConstant8
 }

 @extension("VK_EXT_external_memory_host") // 179
 class VkImportMemoryHostPointerInfoEXT {
     VkStructureType                                 sType
     const void*                                     pNext
     VkExternalMemoryHandleTypeFlagBits              handleType
     void*                                           pHostPointer
 }

 @extension("VK_EXT_external_memory_host") // 179
 class VkMemoryHostPointerPropertiesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             memoryTypeBits
 }

 @extension("VK_EXT_external_memory_host") // 179
 class VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     VkDeviceSize                                    minImportedHostPointerAlignment
 }

 @extension("VK_KHR_shader_atomic_int64") // 181
 class VkPhysicalDeviceShaderAtomicInt64FeaturesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        shaderBufferInt64Atomics
     VkBool32                                        shaderSharedInt64Atomics
 }

 @extension("VK_AMD_shader_core_properties") // 186
 class VkPhysicalDeviceShaderCorePropertiesAMD {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             shaderEngineCount
     u32                                             shaderArraysPerEngineCount
     u32                                             computeUnitsPerShaderArray
     u32                                             simdPerComputeUnit
     u32                                             wavefrontsPerSimd
     u32                                             wavefrontSize
     u32                                             sgprsPerSimd
     u32                                             minSgprAllocation
     u32                                             maxSgprAllocation
     u32                                             sgprAllocationGranularity
     u32                                             vgprsPerSimd
     u32                                             minVgprAllocation
     u32                                             maxVgprAllocation
     u32                                             vgprAllocationGranularity
 }

 @extension("VK_EXT_vertex_attribute_divisor") // 191
 class VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             maxVertexAttribDivisor
 }

 @extension("VK_EXT_vertex_attribute_divisor") // 191
 class VkVertexInputBindingDivisorDescriptionEXT {
     u32                                             binding
     u32                                             divisor
 }

 @extension("VK_EXT_vertex_attribute_divisor") // 191
 class VkPipelineVertexInputDivisorStateCreateInfoEXT {
     VkStructureType                                     sType
     const void*                                         pNext
     u32                                                 vertexBindingDivisorCount
     const VkVertexInputBindingDivisorDescriptionEXT*    pVertexBindingDivisors
 }

 @extension("VK_EXT_vertex_attribute_divisor") // 191
 class VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        vertexAttributeInstanceRateDivisor
     VkBool32                                        vertexAttributeInstanceRateZeroDivisor
 }

 @extension("VK_KHR_driver_properties") // 197
 class VkConformanceVersionKHR {
     u8                                              major
     u8                                              minor
     u8                                              subminor
     u8                                              patch
 }

 @extension("VK_KHR_driver_properties") // 197
 class VkPhysicalDeviceDriverPropertiesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             driverID
     char[VK_MAX_DRIVER_NAME_SIZE_KHR]               driverName
     char[VK_MAX_DRIVER_INFO_SIZE_KHR]               driverInfo
     VkConformanceVersionKHR                         conformanceVersion
 }

 @extension("VK_NV_compute_shader_derivatives") // 202
 class VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        computeDerivativeGroupQuads
     VkBool32                                        computeDerivativeGroupLinear
 }

 @extension("VK_NV_mesh_shader") // 203
 class VkPhysicalDeviceMeshShaderFeaturesNV {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        taskShader
     VkBool32                                        meshShader
 }

 @extension("VK_NV_mesh_shader") // 203
 class VkPhysicalDeviceMeshShaderPropertiesNV {
     VkStructureType                                 sType
     void*                                           pNext
     u32                                             maxDrawMeshTasksCount
     u32                                             maxTaskWorkGroupInvocations
     u32[3]                                          maxTaskWorkGroupSize
     u32                                             maxTaskTotalMemorySize
     u32                                             maxTaskOutputCount
     u32                                             maxMeshWorkGroupInvocations
     u32[3]                                          maxMeshWorkGroupSize
     u32                                             maxMeshTotalMemorySize
     u32                                             maxMeshOutputVertices
     u32                                             maxMeshOutputPrimitives
     u32                                             maxMeshMultiviewViewCount
     u32                                             meshOutputPerVertexGranularity
     u32                                             meshOutputPerPrimitiveGranularity
 }

 @extension("VK_NV_mesh_shader") // 203
 class VkDrawMeshTasksIndirectCommandNV {
     u32                                             taskCount
     u32                                             firstTask
 }

 @extension("VK_NV_fragment_shader_barycentric") // 204
 class VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        fragmentShaderBarycentric
 }

 @extension("VK_NV_shader_image_footprint") // 205
 class VkPhysicalDeviceShaderImageFootprintFeaturesNV {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        imageFootprint
 }

 @extension("VK_NV_scissor_exclusive") // 206
 class VkPipelineViewportExclusiveScissorStateCreateInfoNV {
     VkStructureType                                 sType
     const void*                                     pNext
     u32                                             exclusiveScissorCount
     const VkRect2D*                                 pExclusiveScissors
 }

 @extension("VK_NV_scissor_exclusive") // 206
 class VkPhysicalDeviceExclusiveScissorFeaturesNV {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        exclusiveScissor
 }

 @extension("VK_NV_device_diagnostic_checkpoints") // 207
 class VkQueueFamilyCheckpointPropertiesNV {
     VkStructureType                                 sType
     void*                                           pNext
     VkPipelineStageFlags                            checkpointExecutionStageMask
 }

 @extension("VK_NV_device_diagnostic_checkpoints") // 207
 class VkCheckpointDataNV {
     VkStructureType                                 sType
     void*                                           pNext
     VkPipelineStageFlagBits                         stage
     void*                                           pCheckpointMarker
 }

 @extension("VK_KHR_vulkan_memory_model") // 212
 class VkPhysicalDeviceVulkanMemoryModelFeaturesKHR {
     VkStructureType                                 sType
     void*                                           pNext
     VkBool32                                        vulkanMemoryModel
     VkBool32                                        vulkanMemoryModelDeviceScope
 }


 ////////////////
 //  Commands  //
 ////////////////

 // Function pointers. TODO: add support for function pointers.

 @external type void* PFN_vkVoidFunction
 @pfn cmd void vkVoidFunction() {
 }

 @external type void* PFN_vkAllocationFunction
 @pfn cmd void* vkAllocationFunction(
         void*                                       pUserData,
         platform.size_t                             size,
         platform.size_t                             alignment,
         VkSystemAllocationScope                     allocationScope) {
     return ?
 }

 @external type void* PFN_vkReallocationFunction
 @pfn cmd void* vkReallocationFunction(
         void*                                       pUserData,
         void*                                       pOriginal,
         platform.size_t                             size,
         platform.size_t                             alignment,
         VkSystemAllocationScope                     allocationScope) {
     return ?
 }

 @external type void* PFN_vkFreeFunction
 @pfn cmd void vkFreeFunction(
         void*                                       pUserData,
         void*                                       pMemory) {
 }

 @external type void* PFN_vkInternalAllocationNotification
 @pfn cmd void vkInternalAllocationNotification(
         void*                                       pUserData,
         platform.size_t                             size,
         VkInternalAllocationType                    allocationType,
         VkSystemAllocationScope                     allocationScope) {
 }

 @external type void* PFN_vkInternalFreeNotification
 @pfn cmd void vkInternalFreeNotification(
         void*                                       pUserData,
         platform.size_t                             size,
         VkInternalAllocationType                    allocationType,
         VkSystemAllocationScope                     allocationScope) {
 }

 // Global functions

 @threadSafety("system")
 cmd VkResult vkCreateInstance(
         const VkInstanceCreateInfo*                 pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkInstance*                                 pInstance) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)

     instance := ?
     pInstance[0] = instance
     State.Instances[instance] = new!InstanceObject()

     layers := pCreateInfo.ppEnabledLayerNames[0:pCreateInfo.enabledLayerCount]
     extensions := pCreateInfo.ppEnabledExtensionNames[0:pCreateInfo.enabledExtensionCount]

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyInstance(
         VkInstance                                  instance,
         const VkAllocationCallbacks*                pAllocator) {
     instanceObject := GetInstance(instance)

     State.Instances[instance] = null
 }

 @threadSafety("system")
 cmd VkResult vkEnumeratePhysicalDevices(
         VkInstance                                  instance,
         u32*                                        pPhysicalDeviceCount,
         VkPhysicalDevice*                           pPhysicalDevices) {
     instanceObject := GetInstance(instance)

     physicalDeviceCount := as!u32(?)
     pPhysicalDeviceCount[0] = physicalDeviceCount
     physicalDevices := pPhysicalDevices[0:physicalDeviceCount]

     for i in (0 .. physicalDeviceCount) {
         physicalDevice := ?
         physicalDevices[i] = physicalDevice
         if !(physicalDevice in State.PhysicalDevices) {
             State.PhysicalDevices[physicalDevice] = new!PhysicalDeviceObject(instance: instance)
         }
     }

     return ?
 }

 cmd PFN_vkVoidFunction vkGetDeviceProcAddr(
         VkDevice                                    device,
         const char*                                 pName) {
     if device != NULL_HANDLE {
         device := GetDevice(device)
     }

     return ?
 }

 cmd PFN_vkVoidFunction vkGetInstanceProcAddr(
         VkInstance                                  instance,
         const char*                                 pName) {
     if instance != NULL_HANDLE {
         instanceObject := GetInstance(instance)
     }

     return ?
 }

 cmd void vkGetPhysicalDeviceProperties(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceProperties*                 pProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     properties := ?
     pProperties[0] = properties
 }

 cmd void vkGetPhysicalDeviceQueueFamilyProperties(
         VkPhysicalDevice                            physicalDevice,
         u32*                                        pQueueFamilyPropertyCount,
         VkQueueFamilyProperties*                    pQueueFamilyProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     // TODO: Figure out how to express fetch-count-or-properties
     // This version fails 'apic validate' with 'fence not allowed in
     // *semantic.Branch'. Other attempts have failed with the same or other
     // errors.
     // if pQueueFamilyProperties != null {
     //     queuesProperties := pQueueFamilyProperties[0:pCount[0]]
     //     for i in (0 .. pCount[0]) {
     //         queueProperties := as!VkQueueFamilyProperties(?)
     //         queuesProperties[i] = queueProperties
     //    }
     // } else {
     //     count := ?
     //     pCount[0] = count
     // }
 }

 cmd void vkGetPhysicalDeviceMemoryProperties(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceMemoryProperties*           pMemoryProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     memoryProperties := ?
     pMemoryProperties[0] = memoryProperties
 }

 cmd void vkGetPhysicalDeviceFeatures(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceFeatures*                   pFeatures) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     features := ?
     pFeatures[0] = features
 }

 cmd void vkGetPhysicalDeviceFormatProperties(
         VkPhysicalDevice                            physicalDevice,
         VkFormat                                    format,
         VkFormatProperties*                         pFormatProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     formatProperties := ?
     pFormatProperties[0] = formatProperties
 }

 cmd VkResult vkGetPhysicalDeviceImageFormatProperties(
         VkPhysicalDevice                            physicalDevice,
         VkFormat                                    format,
         VkImageType                                 type,
         VkImageTiling                               tiling,
         VkImageUsageFlags                           usage,
         VkImageCreateFlags                          flags,
         VkImageFormatProperties*                    pImageFormatProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     imageFormatProperties := ?
     pImageFormatProperties[0] = imageFormatProperties

     return ?
 }


 // Device functions

 @threadSafety("system")
 cmd VkResult vkCreateDevice(
         VkPhysicalDevice                            physicalDevice,
         const VkDeviceCreateInfo*                   pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkDevice*                                   pDevice) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     device := ?
     pDevice[0] = device
     State.Devices[device] = new!DeviceObject(physicalDevice: physicalDevice)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyDevice(
         VkDevice                                    device,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)

     State.Devices[device] = null
 }


 // Extension discovery functions

 cmd VkResult vkEnumerateInstanceLayerProperties(
         u32*                                        pPropertyCount,
         VkLayerProperties*                          pProperties) {
     count := as!u32(?)
     pPropertyCount[0] = count

     properties := pProperties[0:count]
     for i in (0 .. count) {
         property := ?
         properties[i] = property
     }

     return ?
 }

 cmd VkResult vkEnumerateInstanceExtensionProperties(
         const char*                                 pLayerName,
         u32*                                        pPropertyCount,
         VkExtensionProperties*                      pProperties) {
     count := as!u32(?)
     pPropertyCount[0] = count

     properties := pProperties[0:count]
     for i in (0 .. count) {
         property := ?
         properties[i] = property
     }

     return ?
 }

 cmd VkResult vkEnumerateDeviceLayerProperties(
         VkPhysicalDevice                            physicalDevice,
         u32*                                        pPropertyCount,
         VkLayerProperties*                          pProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     count := as!u32(?)
     pPropertyCount[0] = count

     properties := pProperties[0:count]
     for i in (0 .. count) {
         property := ?
         properties[i] = property
     }

     return ?
 }

 cmd VkResult vkEnumerateDeviceExtensionProperties(
         VkPhysicalDevice                            physicalDevice,
         const char*                                 pLayerName,
         u32*                                        pPropertyCount,
         VkExtensionProperties*                      pProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     count := as!u32(?)
     pPropertyCount[0] = count

     properties := pProperties[0:count]
     for i in (0 .. count) {
         property := ?
         properties[i] = property
     }

     return ?
 }


 // Queue functions

 @threadSafety("system")
 cmd void vkGetDeviceQueue(
         VkDevice                                    device,
         u32                                         queueFamilyIndex,
         u32                                         queueIndex,
         VkQueue*                                    pQueue) {
     deviceObject := GetDevice(device)

     queue := ?
     pQueue[0] = queue

     if !(queue in State.Queues) {
         State.Queues[queue] = new!QueueObject(device: device)
     }
 }

 @threadSafety("app")
 cmd VkResult vkQueueSubmit(
         VkQueue                                     queue,
         u32                                         submitCount,
         const VkSubmitInfo*                         pSubmits,
         VkFence                                     fence) {
     queueObject := GetQueue(queue)

     if fence != NULL_HANDLE {
         fenceObject := GetFence(fence)
         assert(fenceObject.device == queueObject.device)
     }

     // commandBuffers := pcommandBuffers[0:commandBufferCount]
     // for i in (0 .. commandBufferCount) {
     //    commandBuffer := commandBuffers[i]
     //    commandBufferObject := GetCommandBuffer(commandBuffer)
     //    assert(commandBufferObject.device == queueObject.device)
     //
     //    validate("QueueCheck", commandBufferObject.queueFlags in queueObject.flags,
     //        "vkQueueSubmit: enqueued commandBuffer requires missing queue capabilities.")
     // }

     return ?
 }

 @threadSafety("system")
 cmd VkResult vkQueueWaitIdle(
         VkQueue                                     queue) {
     queueObject := GetQueue(queue)

     return ?
 }

 @threadSafety("system")
 cmd VkResult vkDeviceWaitIdle(
         VkDevice                                    device) {
     deviceObject := GetDevice(device)

     return ?
 }


 // Memory functions

 @threadSafety("system")
 cmd VkResult vkAllocateMemory(
         VkDevice                                    device,
         const VkMemoryAllocateInfo*                 pAllocateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkDeviceMemory*                             pMemory) {
     assert(pAllocateInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO)
     deviceObject := GetDevice(device)

     memory := ?
     pMemory[0] = memory
     State.DeviceMemories[memory] = new!DeviceMemoryObject(
         device: device,
         allocationSize: pAllocateInfo[0].allocationSize)

     return ?
 }

 @threadSafety("system")
 cmd void vkFreeMemory(
         VkDevice                                    device,
         VkDeviceMemory                              memory,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     memoryObject := GetDeviceMemory(memory)
     assert(memoryObject.device == device)

     // Check that no objects are still bound before freeing.
     validate("MemoryCheck", len(memoryObject.boundObjects) == 0,
         "vkFreeMemory: objects still bound")
     validate("MemoryCheck", len(memoryObject.boundCommandBuffers) == 0,
         "vkFreeMemory: commandBuffers still bound")
     State.DeviceMemories[memory] = null
 }

 @threadSafety("app")
 cmd VkResult vkMapMemory(
         VkDevice                                    device,
         VkDeviceMemory                              memory,
         VkDeviceSize                                offset,
         VkDeviceSize                                size,
         VkMemoryMapFlags                            flags,
         void**                                      ppData) {
     deviceObject := GetDevice(device)
     memoryObject := GetDeviceMemory(memory)
     assert(memoryObject.device == device)

     assert(flags == as!VkMemoryMapFlags(0))
     assert((offset + size) <= memoryObject.allocationSize)

     return ?
 }

 @threadSafety("app")
 cmd void vkUnmapMemory(
         VkDevice                                    device,
         VkDeviceMemory                              memory) {
     deviceObject := GetDevice(device)
     memoryObject := GetDeviceMemory(memory)
     assert(memoryObject.device == device)
 }

 cmd VkResult vkFlushMappedMemoryRanges(
         VkDevice                                    device,
         u32                                         memoryRangeCount
         const VkMappedMemoryRange*                  pMemoryRanges) {
     deviceObject := GetDevice(device)

     memoryRanges := pMemoryRanges[0:memoryRangeCount]
     for i in (0 .. memoryRangeCount) {
         memoryRange := memoryRanges[i]
         memoryObject := GetDeviceMemory(memoryRange.memory)
         assert(memoryObject.device == device)
         assert((memoryRange.offset + memoryRange.size) <= memoryObject.allocationSize)
     }

     return ?
 }

 cmd VkResult vkInvalidateMappedMemoryRanges(
         VkDevice                                    device,
         u32                                         memoryRangeCount,
         const VkMappedMemoryRange*                  pMemoryRanges) {
     deviceObject := GetDevice(device)

     memoryRanges := pMemoryRanges[0:memoryRangeCount]
     for i in (0 .. memoryRangeCount) {
         memoryRange := memoryRanges[i]
         memoryObject := GetDeviceMemory(memoryRange.memory)
         assert(memoryObject.device == device)
         assert((memoryRange.offset + memoryRange.size) <= memoryObject.allocationSize)
     }

     return ?
 }


 // Memory management API functions

 cmd void vkGetDeviceMemoryCommitment(
         VkDevice                                    device,
         VkDeviceMemory                              memory,
         VkDeviceSize*                               pCommittedMemoryInBytes) {
     deviceObject := GetDevice(device)

     if memory != NULL_HANDLE {
         memoryObject := GetDeviceMemory(memory)
         assert(memoryObject.device == device)
     }

     committedMemoryInBytes := ?
     pCommittedMemoryInBytes[0] = committedMemoryInBytes
 }

 cmd void vkGetBufferMemoryRequirements(
         VkDevice                                    device,
         VkBuffer                                    buffer,
         VkMemoryRequirements*                       pMemoryRequirements) {
     deviceObject := GetDevice(device)
     bufferObject := GetBuffer(buffer)
     assert(bufferObject.device == device)
 }

 cmd VkResult vkBindBufferMemory(
         VkDevice                                    device,
         VkBuffer                                    buffer,
         VkDeviceMemory                              memory,
         VkDeviceSize                                memoryOffset) {
     deviceObject := GetDevice(device)
     bufferObject := GetBuffer(buffer)
     assert(bufferObject.device == device)

     // Unbind buffer from previous memory object, if not VK_NULL_HANDLE.
     if bufferObject.memory != NULL_HANDLE {
         memoryObject := GetDeviceMemory(bufferObject.memory)
         memoryObject.boundObjects[as!u64(buffer)] = null
     }

     // Bind buffer to given memory object, if not VK_NULL_HANDLE.
     if memory != NULL_HANDLE {
         memoryObject := GetDeviceMemory(memory)
         assert(memoryObject.device == device)
         memoryObject.boundObjects[as!u64(buffer)] = memoryOffset
     }
     bufferObject.memory = memory
     bufferObject.memoryOffset = memoryOffset

     return ?
 }

 cmd void vkGetImageMemoryRequirements(
         VkDevice                                    device,
         VkImage                                     image,
         VkMemoryRequirements*                       pMemoryRequirements) {
     deviceObject := GetDevice(device)
     imageObject := GetImage(image)
     assert(imageObject.device == device)
 }

 cmd VkResult vkBindImageMemory(
         VkDevice                                    device,
         VkImage                                     image,
         VkDeviceMemory                              memory,
         VkDeviceSize                                memoryOffset) {
     deviceObject := GetDevice(device)
     imageObject := GetImage(image)
     assert(imageObject.device == device)

     // Unbind image from previous memory object, if not VK_NULL_HANDLE.
     if imageObject.memory != NULL_HANDLE {
         memoryObject := GetDeviceMemory(imageObject.memory)
         memoryObject.boundObjects[as!u64(image)] = null
     }

     // Bind image to given memory object, if not VK_NULL_HANDLE.
     if memory != NULL_HANDLE {
         memoryObject := GetDeviceMemory(memory)
         assert(memoryObject.device == device)
         memoryObject.boundObjects[as!u64(image)] = memoryOffset
     }
     imageObject.memory = memory
     imageObject.memoryOffset = memoryOffset

     return ?
 }

 cmd void vkGetImageSparseMemoryRequirements(
         VkDevice                                    device,
         VkImage                                     image,
         u32*                                        pSparseMemoryRequirementCount,
         VkSparseImageMemoryRequirements*            pSparseMemoryRequirements) {
     deviceObject := GetDevice(device)
     imageObject := GetImage(image)
     assert(imageObject.device == device)
 }

 cmd void vkGetPhysicalDeviceSparseImageFormatProperties(
         VkPhysicalDevice                            physicalDevice,
         VkFormat                                    format,
         VkImageType                                 type,
         VkSampleCountFlagBits                       samples,
         VkImageUsageFlags                           usage,
         VkImageTiling                               tiling,
         u32*                                        pPropertyCount,
         VkSparseImageFormatProperties*              pProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
 }

 cmd VkResult vkQueueBindSparse(
         VkQueue                                     queue,
         u32                                         bindInfoCount,
         const VkBindSparseInfo*                     pBindInfo,
         VkFence                                     fence) {
     queueObject := GetQueue(queue)

     return ?
 }


 // Fence functions

 @threadSafety("system")
 cmd VkResult vkCreateFence(
         VkDevice                                    device,
         const VkFenceCreateInfo*                    pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkFence*                                    pFence) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO)
     deviceObject := GetDevice(device)

     fence := ?
     pFence[0] = fence
     State.Fences[fence] = new!FenceObject(
         device: device, signaled: (pCreateInfo.flags == as!VkFenceCreateFlags(VK_FENCE_CREATE_SIGNALED_BIT)))

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyFence(
         VkDevice                                    device,
         VkFence                                     fence,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     fenceObject := GetFence(fence)
     assert(fenceObject.device == device)

     State.Fences[fence] = null
 }

 @threadSafety("system")
 cmd VkResult vkResetFences(
         VkDevice                                    device,
         u32                                         fenceCount,
         const VkFence*                              pFences) {
     deviceObject := GetDevice(device)

     fences := pFences[0:fenceCount]
     for i in (0 .. fenceCount) {
         fence := fences[i]
         fenceObject := GetFence(fence)
         assert(fenceObject.device == device)
         fenceObject.signaled = false
     }

     return ?
 }

 @threadSafety("system")
 cmd VkResult vkGetFenceStatus(
         VkDevice                                    device,
         VkFence                                     fence) {
     deviceObject := GetDevice(device)
     fenceObject := GetFence(fence)
     assert(fenceObject.device == device)

     return ?
 }

 @threadSafety("system")
 cmd VkResult vkWaitForFences(
         VkDevice                                    device,
         u32                                         fenceCount,
         const VkFence*                              pFences,
         VkBool32                                    waitAll,
         u64                                         timeout) {  /// timeout in nanoseconds
     deviceObject := GetDevice(device)

     fences := pFences[0:fenceCount]
     for i in (0 .. fenceCount) {
         fence := fences[i]
         fenceObject := GetFence(fence)
         assert(fenceObject.device == device)
     }

     return ?
 }


 // Queue semaphore functions

 @threadSafety("system")
 cmd VkResult vkCreateSemaphore(
         VkDevice                                    device,
         const VkSemaphoreCreateInfo*                pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkSemaphore*                                pSemaphore) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO)
     deviceObject := GetDevice(device)

     semaphore := ?
     pSemaphore[0] = semaphore
     State.Semaphores[semaphore] = new!SemaphoreObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroySemaphore(
         VkDevice                                    device,
         VkSemaphore                                 semaphore,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     semaphoreObject := GetSemaphore(semaphore)
     assert(semaphoreObject.device == device)

     State.Semaphores[semaphore] = null
 }


 // Event functions

 @threadSafety("system")
 cmd VkResult vkCreateEvent(
         VkDevice                                    device,
         const VkEventCreateInfo*                    pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkEvent*                                    pEvent) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO)
     deviceObject := GetDevice(device)

     event := ?
     pEvent[0] = event
     State.Events[event] = new!EventObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyEvent(
         VkDevice                                    device,
         VkEvent                                     event,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     eventObject := GetEvent(event)
     assert(eventObject.device == device)

     State.Events[event] = null
 }

 @threadSafety("system")
 cmd VkResult vkGetEventStatus(
         VkDevice                                    device,
         VkEvent                                     event) {
     deviceObject := GetDevice(device)
     eventObject := GetEvent(event)
     assert(eventObject.device == device)

     return ?
 }

 @threadSafety("system")
 cmd VkResult vkSetEvent(
         VkDevice                                    device,
         VkEvent                                     event) {
     deviceObject := GetDevice(device)
     eventObject := GetEvent(event)
     assert(eventObject.device == device)

     return ?
 }

 @threadSafety("system")
 cmd VkResult vkResetEvent(
         VkDevice                                    device,
         VkEvent                                     event) {
     deviceObject := GetDevice(device)
     eventObject := GetEvent(event)
     assert(eventObject.device == device)

     return ?
 }


 // Query functions

 @threadSafety("system")
 cmd VkResult vkCreateQueryPool(
         VkDevice                                    device,
         const VkQueryPoolCreateInfo*                pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkQueryPool*                                pQueryPool) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO)
     deviceObject := GetDevice(device)

     queryPool := ?
     pQueryPool[0] = queryPool
     State.QueryPools[queryPool] = new!QueryPoolObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyQueryPool(
         VkDevice                                    device,
         VkQueryPool                                 queryPool,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     queryPoolObject := GetQueryPool(queryPool)
     assert(queryPoolObject.device == device)

     State.QueryPools[queryPool] = null
 }

 @threadSafety("system")
 cmd VkResult vkGetQueryPoolResults(
         VkDevice                                    device,
         VkQueryPool                                 queryPool,
         u32                                         firstQuery,
         u32                                         queryCount,
         platform.size_t                             dataSize,
         void*                                       pData,
         VkDeviceSize                                stride,
         VkQueryResultFlags                          flags) {
     deviceObject := GetDevice(device)
     queryPoolObject := GetQueryPool(queryPool)
     assert(queryPoolObject.device == device)

     data := pData[0:dataSize]

     return ?
 }

 // Buffer functions

 @threadSafety("system")
 cmd VkResult vkCreateBuffer(
         VkDevice                                    device,
         const VkBufferCreateInfo*                   pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkBuffer*                                   pBuffer) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO)
     deviceObject := GetDevice(device)

     buffer := ?
     pBuffer[0] = buffer
     State.Buffers[buffer] = new!BufferObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyBuffer(
         VkDevice                                    device,
         VkBuffer                                    buffer,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     bufferObject := GetBuffer(buffer)
     assert(bufferObject.device == device)

     assert(bufferObject.memory == 0)
     State.Buffers[buffer] = null
 }


 // Buffer view functions

 @threadSafety("system")
 cmd VkResult vkCreateBufferView(
         VkDevice                                    device,
         const VkBufferViewCreateInfo*               pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkBufferView*                               pView) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO)
     deviceObject := GetDevice(device)

     bufferObject := GetBuffer(pCreateInfo.buffer)
     assert(bufferObject.device == device)

     view := ?
     pView[0] = view
     State.BufferViews[view] = new!BufferViewObject(device: device, buffer: pCreateInfo.buffer)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyBufferView(
         VkDevice                                    device,
         VkBufferView                                bufferView,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     bufferViewObject := GetBufferView(bufferView)
     assert(bufferViewObject.device == device)

     State.BufferViews[bufferView] = null
 }


 // Image functions

 @threadSafety("system")
 cmd VkResult vkCreateImage(
         VkDevice                                    device,
         const VkImageCreateInfo*                    pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkImage*                                    pImage) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
     deviceObject := GetDevice(device)

     image := ?
     pImage[0] = image
     State.Images[image] = new!ImageObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyImage(
         VkDevice                                    device,
         VkImage                                     image,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     imageObject := GetImage(image)
     assert(imageObject.device == device)

     assert(imageObject.memory == 0)
     State.Images[image] = null
 }

 cmd void vkGetImageSubresourceLayout(
         VkDevice                                    device,
         VkImage                                     image,
         const VkImageSubresource*                   pSubresource,
         VkSubresourceLayout*                        pLayout) {
     deviceObject := GetDevice(device)
     imageObject := GetImage(image)
     assert(imageObject.device == device)
 }


 // Image view functions

 @threadSafety("system")
 cmd VkResult vkCreateImageView(
         VkDevice                                    device,
         const VkImageViewCreateInfo*                pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkImageView*                                pView) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO)
     deviceObject := GetDevice(device)

     imageObject := GetImage(pCreateInfo.image)
     assert(imageObject.device == device)

     view := ?
     pView[0] = view
     State.ImageViews[view] = new!ImageViewObject(device: device, image: pCreateInfo.image)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyImageView(
         VkDevice                                    device,
         VkImageView                                 imageView,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     imageViewObject := GetImageView(imageView)
     assert(imageViewObject.device == device)

     State.ImageViews[imageView] = null
 }


 // Shader functions

 cmd VkResult vkCreateShaderModule(
         VkDevice                                    device,
         const VkShaderModuleCreateInfo*             pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkShaderModule*                             pShaderModule) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO)
     deviceObject := GetDevice(device)

     shaderModule := ?
     pShaderModule[0] = shaderModule
     State.ShaderModules[shaderModule] = new!ShaderModuleObject(device: device)

     return ?
 }

 cmd void vkDestroyShaderModule(
         VkDevice                                    device,
         VkShaderModule                              shaderModule,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     shaderModuleObject := GetShaderModule(shaderModule)
     assert(shaderModuleObject.device == device)

     State.ShaderModules[shaderModule] = null
 }


 // Pipeline functions

 cmd VkResult vkCreatePipelineCache(
         VkDevice                                    device,
         const VkPipelineCacheCreateInfo*            pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkPipelineCache*                            pPipelineCache) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO)
     deviceObject := GetDevice(device)

     pipelineCache := ?
     pPipelineCache[0] = pipelineCache
     State.PipelineCaches[pipelineCache] = new!PipelineCacheObject(device: device)

     return ?
 }

 cmd void vkDestroyPipelineCache(
         VkDevice                                    device,
         VkPipelineCache                             pipelineCache,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     pipelineCacheObject := GetPipelineCache(pipelineCache)
     assert(pipelineCacheObject.device == device)

     State.PipelineCaches[pipelineCache] = null
 }

 cmd VkResult vkGetPipelineCacheData(
         VkDevice                                    device,
         VkPipelineCache                             pipelineCache,
         platform.size_t*                            pDataSize,
         void*                                       pData) {
     deviceObject := GetDevice(device)
     pipelineCacheObject := GetPipelineCache(pipelineCache)
     assert(pipelineCacheObject.device == device)

     return ?
 }

 cmd VkResult vkMergePipelineCaches(
         VkDevice                                    device,
         VkPipelineCache                             dstCache,
         u32                                         srcCacheCount,
         const VkPipelineCache*                      pSrcCaches) {
     deviceObject := GetDevice(device)
     dstCacheObject := GetPipelineCache(dstCache)
     assert(dstCacheObject.device == device)

     srcCaches := pSrcCaches[0:srcCacheCount]
     for i in (0 .. srcCacheCount) {
         srcCache := srcCaches[i]
         srcCacheObject := GetPipelineCache(srcCache)
         assert(srcCacheObject.device == device)
     }

     return ?
 }

 cmd VkResult vkCreateGraphicsPipelines(
         VkDevice                                    device,
         VkPipelineCache                             pipelineCache,
         u32                                         createInfoCount,
         const VkGraphicsPipelineCreateInfo*         pCreateInfos,
         const VkAllocationCallbacks*                pAllocator,
         VkPipeline*                                 pPipelines) {
     deviceObject := GetDevice(device)
     if pipelineCache != NULL_HANDLE {
         pipelineCacheObject := GetPipelineCache(pipelineCache)
         assert(pipelineCacheObject.device == device)
     }

     createInfos := pCreateInfos[0:createInfoCount]
     pipelines := pPipelines[0:createInfoCount]
     for i in (0 .. createInfoCount) {
         pipeline := ?
         pipelines[i] = pipeline
         State.Pipelines[pipeline] = new!PipelineObject(device: device)
     }

     return ?
 }

 cmd VkResult vkCreateComputePipelines(
         VkDevice                                    device,
         VkPipelineCache                             pipelineCache,
         u32                                         createInfoCount,
         const VkComputePipelineCreateInfo*          pCreateInfos,
         const VkAllocationCallbacks*                pAllocator,
         VkPipeline*                                 pPipelines) {
     deviceObject := GetDevice(device)
     if pipelineCache != NULL_HANDLE {
         pipelineCacheObject := GetPipelineCache(pipelineCache)
         assert(pipelineCacheObject.device == device)
     }

     createInfos := pCreateInfos[0:createInfoCount]
     pipelines := pPipelines[0:createInfoCount]
     for i in (0 .. createInfoCount) {
         pipeline := ?
         pipelines[i] = pipeline
         State.Pipelines[pipeline] = new!PipelineObject(device: device)
     }

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyPipeline(
         VkDevice                                    device,
         VkPipeline                                  pipeline,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     pipelineObjects := GetPipeline(pipeline)
     assert(pipelineObjects.device == device)

     State.Pipelines[pipeline] = null
 }


 // Pipeline layout functions

 @threadSafety("system")
 cmd VkResult vkCreatePipelineLayout(
         VkDevice                                    device,
         const VkPipelineLayoutCreateInfo*           pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkPipelineLayout*                           pPipelineLayout) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO)
     deviceObject := GetDevice(device)

     pipelineLayout := ?
     pPipelineLayout[0] = pipelineLayout
     State.PipelineLayouts[pipelineLayout] = new!PipelineLayoutObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyPipelineLayout(
         VkDevice                                    device,
         VkPipelineLayout                            pipelineLayout,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     pipelineLayoutObjects := GetPipelineLayout(pipelineLayout)
     assert(pipelineLayoutObjects.device == device)

     State.PipelineLayouts[pipelineLayout] = null
 }


 // Sampler functions

 @threadSafety("system")
 cmd VkResult vkCreateSampler(
         VkDevice                                    device,
         const VkSamplerCreateInfo*                  pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkSampler*                                  pSampler) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO)
     deviceObject := GetDevice(device)

     sampler := ?
     pSampler[0] = sampler
     State.Samplers[sampler] = new!SamplerObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroySampler(
         VkDevice                                    device,
         VkSampler                                   sampler,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     samplerObject := GetSampler(sampler)
     assert(samplerObject.device == device)

     State.Samplers[sampler] = null
 }


 // Descriptor set functions

 @threadSafety("system")
 cmd VkResult vkCreateDescriptorSetLayout(
         VkDevice                                    device,
         const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkDescriptorSetLayout*                      pSetLayout) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)
     deviceObject := GetDevice(device)

     setLayout := ?
     pSetLayout[0] = setLayout
     State.DescriptorSetLayouts[setLayout] = new!DescriptorSetLayoutObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyDescriptorSetLayout(
         VkDevice                                    device,
         VkDescriptorSetLayout                       descriptorSetLayout,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     descriptorSetLayoutObject := GetDescriptorSetLayout(descriptorSetLayout)
     assert(descriptorSetLayoutObject.device == device)

     State.DescriptorSetLayouts[descriptorSetLayout] = null
 }

 @threadSafety("system")
 cmd VkResult vkCreateDescriptorPool(
         VkDevice                                    device,
         const VkDescriptorPoolCreateInfo*           pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkDescriptorPool*                           pDescriptorPool) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO)
     deviceObject := GetDevice(device)

     descriptorPool := ?
     pDescriptorPool[0] = descriptorPool
     State.DescriptorPools[descriptorPool] = new!DescriptorPoolObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyDescriptorPool(
         VkDevice                                    device,
         VkDescriptorPool                            descriptorPool,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     descriptorPoolObject := GetDescriptorPool(descriptorPool)
     assert(descriptorPoolObject.device == device)

     State.DescriptorPools[descriptorPool] = null
 }

 @threadSafety("app")
 cmd VkResult vkResetDescriptorPool(
         VkDevice                                    device,
         VkDescriptorPool                            descriptorPool,
         VkDescriptorPoolResetFlags                  flags) {
     deviceObject := GetDevice(device)
     descriptorPoolObject := GetDescriptorPool(descriptorPool)
     assert(descriptorPoolObject.device == device)

     return ?
 }

 @threadSafety("app")
 cmd VkResult vkAllocateDescriptorSets(
         VkDevice                                    device,
         const VkDescriptorSetAllocateInfo*          pAllocateInfo,
         VkDescriptorSet*                            pDescriptorSets) {
     deviceObject := GetDevice(device)
     allocInfo := pAllocateInfo[0]
     descriptorPoolObject := GetDescriptorPool(allocInfo.descriptorPool)

     setLayouts := allocInfo.pSetLayouts[0:allocInfo.setCount]
     for i in (0 .. allocInfo.setCount) {
         setLayout := setLayouts[i]
         setLayoutObject := GetDescriptorSetLayout(setLayout)
         assert(setLayoutObject.device == device)
     }

     descriptorSets := pDescriptorSets[0:allocInfo.setCount]
     for i in (0 .. allocInfo.setCount) {
         descriptorSet := ?
         descriptorSets[i] = descriptorSet
         State.DescriptorSets[descriptorSet] = new!DescriptorSetObject(device: device)
     }

     return ?
 }

 cmd VkResult vkFreeDescriptorSets(
         VkDevice                                    device,
         VkDescriptorPool                            descriptorPool,
         u32                                         descriptorSetCount,
         const VkDescriptorSet*                      pDescriptorSets) {
     deviceObject := GetDevice(device)
     descriptorPoolObject := GetDescriptorPool(descriptorPool)

     descriptorSets := pDescriptorSets[0:descriptorSetCount]
     for i in (0 .. descriptorSetCount) {
         descriptorSet := descriptorSets[i]
         descriptorSetObject := GetDescriptorSet(descriptorSet)
         assert(descriptorSetObject.device == device)
         State.DescriptorSets[descriptorSet] = null
     }

     return ?
 }

 cmd void vkUpdateDescriptorSets(
         VkDevice                                    device,
         u32                                         descriptorWriteCount,
         const VkWriteDescriptorSet*                 pDescriptorWrites,
         u32                                         descriptorCopyCount,
         const VkCopyDescriptorSet*                  pDescriptorCopies) {
     deviceObject := GetDevice(device)

     descriptorWrites := pDescriptorWrites[0:descriptorWriteCount]
     for i in (0 .. descriptorWriteCount) {
         descriptorWrite := descriptorWrites[i]
         descriptorWriteObject := GetDescriptorSet(descriptorWrite.dstSet)
         assert(descriptorWriteObject.device == device)
     }

     descriptorCopies := pDescriptorCopies[0:descriptorCopyCount]
     for i in (0 .. descriptorCopyCount) {
         descriptorCopy := descriptorCopies[i]
         descriptorCopyObject := GetDescriptorSet(descriptorCopy.dstSet)
         assert(descriptorCopyObject.device == device)
     }
 }


 // Framebuffer functions

 @threadSafety("system")
 cmd VkResult vkCreateFramebuffer(
         VkDevice                                    device,
         const VkFramebufferCreateInfo*              pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkFramebuffer*                              pFramebuffer) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO)
     deviceObject := GetDevice(device)

     framebuffer := ?
     pFramebuffer[0] = framebuffer
     State.Framebuffers[framebuffer] = new!FramebufferObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyFramebuffer(
         VkDevice                                    device,
         VkFramebuffer                               framebuffer,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     framebufferObject := GetFramebuffer(framebuffer)
     assert(framebufferObject.device == device)

     State.Framebuffers[framebuffer] = null
 }


 // Renderpass functions

 @threadSafety("system")
 cmd VkResult vkCreateRenderPass(
         VkDevice                                    device,
         const VkRenderPassCreateInfo*               pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkRenderPass*                               pRenderPass) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
     deviceObject := GetDevice(device)

     renderpass := ?
     pRenderPass[0] = renderpass
     State.RenderPasses[renderpass] = new!RenderPassObject(device: device)

     return ?
 }

 @threadSafety("system")
 cmd void vkDestroyRenderPass(
         VkDevice                                    device,
         VkRenderPass                                renderPass,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     renderPassObject := GetRenderPass(renderPass)
     assert(renderPassObject.device == device)

     State.RenderPasses[renderPass] = null
 }

 cmd void vkGetRenderAreaGranularity(
         VkDevice                                    device,
         VkRenderPass                                renderPass,
         VkExtent2D*                                 pGranularity) {
     deviceObject := GetDevice(device)
     renderPassObject := GetRenderPass(renderPass)

     granularity := ?
     pGranularity[0] = granularity
 }

 // Command pool functions

 cmd VkResult vkCreateCommandPool(
         VkDevice                                    device,
         const VkCommandPoolCreateInfo*              pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkCommandPool*                              pCommandPool) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO)
     deviceObject := GetDevice(device)

     commandPool := ?
     pCommandPool[0] = commandPool
     State.CommandPools[commandPool] = new!CommandPoolObject(device: device)

     return ?
 }

 cmd void vkDestroyCommandPool(
         VkDevice                                    device,
         VkCommandPool                               commandPool,
         const VkAllocationCallbacks*                pAllocator) {
     deviceObject := GetDevice(device)
     commandPoolObject := GetCommandPool(commandPool)
     assert(commandPoolObject.device == device)

     State.CommandPools[commandPool] = null
 }

 cmd VkResult vkResetCommandPool(
         VkDevice                                    device,
         VkCommandPool                               commandPool,
         VkCommandPoolResetFlags                     flags) {
     deviceObject := GetDevice(device)
     commandPoolObject := GetCommandPool(commandPool)
     assert(commandPoolObject.device == device)

     return ?
 }

 // Command buffer functions

 macro void bindCommandBuffer(VkCommandBuffer commandBuffer, any obj, VkDeviceMemory memory) {
     memoryObject := GetDeviceMemory(memory)
     memoryObject.boundCommandBuffers[commandBuffer] = commandBuffer

     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.boundObjects[as!u64(obj)] = memory
 }

 macro void unbindCommandBuffer(VkCommandBuffer commandBuffer, any obj, VkDeviceMemory memory) {
     memoryObject := GetDeviceMemory(memory)
     memoryObject.boundCommandBuffers[commandBuffer] = null

     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.boundObjects[as!u64(obj)] = null
 }

 @threadSafety("system")
 cmd VkResult vkAllocateCommandBuffers(
         VkDevice                                    device,
         const VkCommandBufferAllocateInfo*          pAllocateInfo,
         VkCommandBuffer*                            pCommandBuffers) {
     assert(pAllocateInfo[0].sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO)

     count := pAllocateInfo[0].commandBufferCount
     commandBuffers := pCommandBuffers[0:count]
     for i in (0 .. count) {
         commandBuffer := ?
         commandBuffers[i] = commandBuffer
         State.CommandBuffers[commandBuffer] = new!CommandBufferObject(device: device)
     }

     return ?
 }

 @threadSafety("system")
 cmd void vkFreeCommandBuffers(
         VkDevice                                    device,
         VkCommandPool                               commandPool,
         u32                                         commandBufferCount,
         const VkCommandBuffer*                      pCommandBuffers) {
     deviceObject := GetDevice(device)

     commandBuffers := pCommandBuffers[0:commandBufferCount]
     for i in (0 .. commandBufferCount) {
         commandBufferObject := GetCommandBuffer(commandBuffers[i])
         assert(commandBufferObject.device == device)
         // TODO: iterate over boundObjects and clear memory bindings
         State.CommandBuffers[commandBuffers[i]] = null
     }
 }

 @threadSafety("app")
 cmd VkResult vkBeginCommandBuffer(
         VkCommandBuffer                             commandBuffer,
         const VkCommandBufferBeginInfo*             pBeginInfo) {
     assert(pBeginInfo.sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO)
     commandBufferObject := GetCommandBuffer(commandBuffer)

     // TODO: iterate over boundObjects and clear memory bindings

     return ?
 }

 @threadSafety("app")
 cmd VkResult vkEndCommandBuffer(
         VkCommandBuffer                             commandBuffer) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     return ?
 }

 @threadSafety("app")
 cmd VkResult vkResetCommandBuffer(
         VkCommandBuffer                             commandBuffer,
         VkCommandBufferResetFlags                   flags) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     // TODO: iterate over boundObjects and clear memory bindings

     return ?
 }


 // Command buffer building functions

 @threadSafety("app")
 cmd void vkCmdBindPipeline(
         VkCommandBuffer                             commandBuffer,
         VkPipelineBindPoint                         pipelineBindPoint,
         VkPipeline                                  pipeline) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     pipelineObject := GetPipeline(pipeline)
     assert(commandBufferObject.device == pipelineObject.device)

     queue := switch (pipelineBindPoint) {
         case VK_PIPELINE_BIND_POINT_COMPUTE:  VK_QUEUE_COMPUTE_BIT
         case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
     }
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, queue)
 }

 @threadSafety("app")
 cmd void vkCmdSetViewport(
         VkCommandBuffer                             commandBuffer,
         u32                                         firstViewport,
         u32                                         viewportCount,
         const VkViewport*                           pViewports) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdSetScissor(
         VkCommandBuffer                             commandBuffer,
         u32                                         firstScissor,
         u32                                         scissorCount,
         const VkRect2D*                             pScissors) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdSetLineWidth(
         VkCommandBuffer                             commandBuffer,
         f32                                         lineWidth) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdSetDepthBias(
         VkCommandBuffer                             commandBuffer,
         f32                                         depthBiasConstantFactor,
         f32                                         depthBiasClamp,
         f32                                         depthBiasSlopeFactor) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdSetBlendConstants(
         VkCommandBuffer                             commandBuffer,
         // TODO(jessehall): apic only supports 'const' on pointer types. Using
         // an annotation as a quick hack to pass this to the template without
         // having to modify the AST and semantic model.
         @readonly f32[4]                            blendConstants) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdSetDepthBounds(
         VkCommandBuffer                             commandBuffer,
         f32                                         minDepthBounds,
         f32                                         maxDepthBounds) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdSetStencilCompareMask(
         VkCommandBuffer                             commandBuffer,
         VkStencilFaceFlags                          faceMask,
         u32                                         compareMask) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdSetStencilWriteMask(
         VkCommandBuffer                             commandBuffer,
         VkStencilFaceFlags                          faceMask,
         u32                                         writeMask) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdSetStencilReference(
         VkCommandBuffer                             commandBuffer,
         VkStencilFaceFlags                          faceMask,
         u32                                         reference) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdBindDescriptorSets(
         VkCommandBuffer                             commandBuffer,
         VkPipelineBindPoint                         pipelineBindPoint,
         VkPipelineLayout                            layout,
         u32                                         firstSet,
         u32                                         descriptorSetCount,
         const VkDescriptorSet*                      pDescriptorSets,
         u32                                         dynamicOffsetCount,
         const u32*                                  pDynamicOffsets) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     descriptorSets := pDescriptorSets[0:descriptorSetCount]
     for i in (0 .. descriptorSetCount) {
         descriptorSet := descriptorSets[i]
         descriptorSetObject := GetDescriptorSet(descriptorSet)
         assert(commandBufferObject.device == descriptorSetObject.device)
     }

     dynamicOffsets := pDynamicOffsets[0:dynamicOffsetCount]
     for i in (0 .. dynamicOffsetCount) {
         dynamicOffset := dynamicOffsets[i]
     }

     queue := switch (pipelineBindPoint) {
         case VK_PIPELINE_BIND_POINT_COMPUTE:  VK_QUEUE_COMPUTE_BIT
         case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
     }
     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, queue)
 }

 @threadSafety("app")
 cmd void vkCmdBindIndexBuffer(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    buffer,
         VkDeviceSize                                offset,
         VkIndexType                                 indexType) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     bufferObject := GetBuffer(buffer)
     assert(commandBufferObject.device == bufferObject.device)

     bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdBindVertexBuffers(
         VkCommandBuffer                             commandBuffer,
         u32                                         firstBinding,
         u32                                         bindingCount,
         const VkBuffer*                             pBuffers,
         const VkDeviceSize*                         pOffsets) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     // TODO: check if not [firstBinding:firstBinding+bindingCount]
     buffers := pBuffers[0:bindingCount]
     offsets := pOffsets[0:bindingCount]
     for i in (0 .. bindingCount) {
         buffer := buffers[i]
         offset := offsets[i]
         bufferObject := GetBuffer(buffer)
         assert(commandBufferObject.device == bufferObject.device)

         bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
     }

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdDraw(
         VkCommandBuffer                             commandBuffer,
         u32                                         vertexCount,
         u32                                         instanceCount,
         u32                                         firstVertex,
         u32                                         firstInstance) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdDrawIndexed(
         VkCommandBuffer                             commandBuffer,
         u32                                         indexCount,
         u32                                         instanceCount,
         u32                                         firstIndex,
         s32                                         vertexOffset,
         u32                                         firstInstance) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdDrawIndirect(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    buffer,
         VkDeviceSize                                offset,
         u32                                         drawCount,
         u32                                         stride) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     bufferObject := GetBuffer(buffer)
     assert(commandBufferObject.device == bufferObject.device)

     bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdDrawIndexedIndirect(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    buffer,
         VkDeviceSize                                offset,
         u32                                         drawCount,
         u32                                         stride) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     bufferObject := GetBuffer(buffer)
     assert(commandBufferObject.device == bufferObject.device)

     bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdDispatch(
         VkCommandBuffer                             commandBuffer,
         u32                                         groupCountX,
         u32                                         groupCountY,
         u32                                         groupCountZ) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdDispatchIndirect(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    buffer,
         VkDeviceSize                                offset) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     bufferObject := GetBuffer(buffer)
     assert(commandBufferObject.device == bufferObject.device)

     bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdCopyBuffer(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    srcBuffer,
         VkBuffer                                    dstBuffer,
         u32                                         regionCount,
         const VkBufferCopy*                         pRegions) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     srcBufferObject := GetBuffer(srcBuffer)
     dstBufferObject := GetBuffer(dstBuffer)
     assert(commandBufferObject.device == srcBufferObject.device)
     assert(commandBufferObject.device == dstBufferObject.device)

     regions := pRegions[0:regionCount]
     for i in (0 .. regionCount) {
         region := regions[i]
     }

     bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
     bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdCopyImage(
         VkCommandBuffer                             commandBuffer,
         VkImage                                     srcImage,
         VkImageLayout                               srcImageLayout,
         VkImage                                     dstImage,
         VkImageLayout                               dstImageLayout,
         u32                                         regionCount,
         const VkImageCopy*                          pRegions) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     srcImageObject := GetImage(srcImage)
     dstImageObject := GetImage(dstImage)
     assert(commandBufferObject.device == srcImageObject.device)
     assert(commandBufferObject.device == dstImageObject.device)

     regions := pRegions[0:regionCount]
     for i in (0 .. regionCount) {
         region := regions[i]
     }

     bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
     bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdBlitImage(
         VkCommandBuffer                             commandBuffer,
         VkImage                                     srcImage,
         VkImageLayout                               srcImageLayout,
         VkImage                                     dstImage,
         VkImageLayout                               dstImageLayout,
         u32                                         regionCount,
         const VkImageBlit*                          pRegions,
         VkFilter                                    filter) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     srcImageObject := GetImage(srcImage)
     dstImageObject := GetImage(dstImage)
     assert(commandBufferObject.device == srcImageObject.device)
     assert(commandBufferObject.device == dstImageObject.device)

     regions := pRegions[0:regionCount]
     for i in (0 .. regionCount) {
         region := regions[i]
     }

     bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
     bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdCopyBufferToImage(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    srcBuffer,
         VkImage                                     dstImage,
         VkImageLayout                               dstImageLayout,
         u32                                         regionCount,
         const VkBufferImageCopy*                    pRegions) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     srcBufferObject := GetBuffer(srcBuffer)
     dstImageObject := GetImage(dstImage)
     assert(commandBufferObject.device == srcBufferObject.device)
     assert(commandBufferObject.device == dstImageObject.device)

     regions := pRegions[0:regionCount]
     for i in (0 .. regionCount) {
         region := regions[i]
     }

     bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
     bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdCopyImageToBuffer(
         VkCommandBuffer                             commandBuffer,
         VkImage                                     srcImage,
         VkImageLayout                               srcImageLayout,
         VkBuffer                                    dstBuffer,
         u32                                         regionCount,
         const VkBufferImageCopy*                    pRegions) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     srcImageObject := GetImage(srcImage)
     dstBufferObject := GetBuffer(dstBuffer)
     assert(commandBufferObject.device == srcImageObject.device)
     assert(commandBufferObject.device == dstBufferObject.device)

     regions := pRegions[0:regionCount]
     for i in (0 .. regionCount) {
         region := regions[i]
     }

     bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
     bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdUpdateBuffer(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    dstBuffer,
         VkDeviceSize                                dstOffset,
         VkDeviceSize                                dataSize,
         const void*                                 pData) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     dstBufferObject := GetBuffer(dstBuffer)
     assert(commandBufferObject.device == dstBufferObject.device)

     data := pData[0:dataSize]

     bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdFillBuffer(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    dstBuffer,
         VkDeviceSize                                dstOffset,
         VkDeviceSize                                size,
         u32                                         data) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     dstBufferObject := GetBuffer(dstBuffer)
     assert(commandBufferObject.device == dstBufferObject.device)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdClearColorImage(
         VkCommandBuffer                             commandBuffer,
         VkImage                                     image,
         VkImageLayout                               imageLayout,
         const VkClearColorValue*                    pColor,
         u32                                         rangeCount,
         const VkImageSubresourceRange*              pRanges) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     imageObject := GetImage(image)
     assert(commandBufferObject.device == imageObject.device)

     ranges := pRanges[0:rangeCount]
     for i in (0 .. rangeCount) {
         range := ranges[i]
     }

     bindCommandBuffer(commandBuffer, image, imageObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdClearDepthStencilImage(
         VkCommandBuffer                             commandBuffer,
         VkImage                                     image,
         VkImageLayout                               imageLayout,
         const VkClearDepthStencilValue*             pDepthStencil,
         u32                                         rangeCount,
         const VkImageSubresourceRange*              pRanges) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     imageObject := GetImage(image)
     assert(commandBufferObject.device == imageObject.device)

     ranges := pRanges[0:rangeCount]
     for i in (0 .. rangeCount) {
         range := ranges[i]
     }

     bindCommandBuffer(commandBuffer, image, imageObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdClearAttachments(
         VkCommandBuffer                             commandBuffer,
         u32                                         attachmentCount,
         const VkClearAttachment*                    pAttachments,
         u32                                         rectCount,
         const VkClearRect*                          pRects) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     rects := pRects[0:rectCount]
     for i in (0 .. rectCount) {
         rect := rects[i]
     }

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdResolveImage(
         VkCommandBuffer                             commandBuffer,
         VkImage                                     srcImage,
         VkImageLayout                               srcImageLayout,
         VkImage                                     dstImage,
         VkImageLayout                               dstImageLayout,
         u32                                         regionCount,
         const VkImageResolve*                       pRegions) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     srcImageObject := GetImage(srcImage)
     dstImageObject := GetImage(dstImage)
     assert(commandBufferObject.device == srcImageObject.device)
     assert(commandBufferObject.device == dstImageObject.device)

     regions := pRegions[0:regionCount]
     for i in (0 .. regionCount) {
         region := regions[i]
     }

     bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
     bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 @threadSafety("app")
 cmd void vkCmdSetEvent(
         VkCommandBuffer                             commandBuffer,
         VkEvent                                     event,
         VkPipelineStageFlags                        stageMask) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     eventObject := GetEvent(event)
     assert(commandBufferObject.device == eventObject.device)
 }

 @threadSafety("app")
 cmd void vkCmdResetEvent(
         VkCommandBuffer                             commandBuffer,
         VkEvent                                     event,
         VkPipelineStageFlags                        stageMask) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     eventObject := GetEvent(event)
     assert(commandBufferObject.device == eventObject.device)
 }

 @threadSafety("app")
 cmd void vkCmdWaitEvents(
         VkCommandBuffer                             commandBuffer,
         u32                                         eventCount,
         const VkEvent*                              pEvents,
         VkPipelineStageFlags                        srcStageMask,
         VkPipelineStageFlags                        dstStageMask,
         u32                                         memoryBarrierCount,
         const VkMemoryBarrier*                      pMemoryBarriers,
         u32                                         bufferMemoryBarrierCount,
         const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
         u32                                         imageMemoryBarrierCount,
         const VkImageMemoryBarrier*                 pImageMemoryBarriers) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     events := pEvents[0:eventCount]
     for i in (0 .. eventCount) {
         event := events[i]
         eventObject := GetEvent(event)
         assert(commandBufferObject.device == eventObject.device)
     }

     memoryBarriers := pMemoryBarriers[0:memoryBarrierCount]
     for i in (0 .. memoryBarrierCount) {
         memoryBarrier := memoryBarriers[i]
     }
     bufferMemoryBarriers := pBufferMemoryBarriers[0:bufferMemoryBarrierCount]
     for i in (0 .. bufferMemoryBarrierCount) {
         bufferMemoryBarrier := bufferMemoryBarriers[i]
         bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
         assert(bufferObject.device == commandBufferObject.device)
     }
     imageMemoryBarriers := pImageMemoryBarriers[0:imageMemoryBarrierCount]
     for i in (0 .. imageMemoryBarrierCount) {
         imageMemoryBarrier := imageMemoryBarriers[i]
         imageObject := GetImage(imageMemoryBarrier.image)
         assert(imageObject.device == commandBufferObject.device)
     }
 }

 @threadSafety("app")
 cmd void vkCmdPipelineBarrier(
         VkCommandBuffer                             commandBuffer,
         VkPipelineStageFlags                        srcStageMask,
         VkPipelineStageFlags                        dstStageMask,
         VkDependencyFlags                           dependencyFlags,
         u32                                         memoryBarrierCount,
         const VkMemoryBarrier*                      pMemoryBarriers,
         u32                                         bufferMemoryBarrierCount,
         const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
         u32                                         imageMemoryBarrierCount,
         const VkImageMemoryBarrier*                 pImageMemoryBarriers) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     memoryBarriers := pMemoryBarriers[0:memoryBarrierCount]
     for i in (0 .. memoryBarrierCount) {
         memoryBarrier := memoryBarriers[i]
     }
     bufferMemoryBarriers := pBufferMemoryBarriers[0:bufferMemoryBarrierCount]
     for i in (0 .. bufferMemoryBarrierCount) {
         bufferMemoryBarrier := bufferMemoryBarriers[i]
         bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
         assert(bufferObject.device == commandBufferObject.device)
     }
     imageMemoryBarriers := pImageMemoryBarriers[0:imageMemoryBarrierCount]
     for i in (0 .. imageMemoryBarrierCount) {
         imageMemoryBarrier := imageMemoryBarriers[i]
         imageObject := GetImage(imageMemoryBarrier.image)
         assert(imageObject.device == commandBufferObject.device)
     }
 }

 @threadSafety("app")
 cmd void vkCmdBeginQuery(
         VkCommandBuffer                             commandBuffer,
         VkQueryPool                                 queryPool,
         u32                                         query,
         VkQueryControlFlags                         flags) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     queryPoolObject := GetQueryPool(queryPool)
     assert(commandBufferObject.device == queryPoolObject.device)
 }

 @threadSafety("app")
 cmd void vkCmdEndQuery(
         VkCommandBuffer                             commandBuffer,
         VkQueryPool                                 queryPool,
         u32                                         query) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     queryPoolObject := GetQueryPool(queryPool)
     assert(commandBufferObject.device == queryPoolObject.device)
 }

 @threadSafety("app")
 cmd void vkCmdResetQueryPool(
         VkCommandBuffer                             commandBuffer,
         VkQueryPool                                 queryPool,
         u32                                         firstQuery,
         u32                                         queryCount) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     queryPoolObject := GetQueryPool(queryPool)
     assert(commandBufferObject.device == queryPoolObject.device)
 }

 @threadSafety("app")
 cmd void vkCmdWriteTimestamp(
         VkCommandBuffer                             commandBuffer,
         VkPipelineStageFlagBits                     pipelineStage,
         VkQueryPool                                 queryPool,
         u32                                         query) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     queryPoolObject := GetQueryPool(queryPool)
     assert(commandBufferObject.device == queryPoolObject.device)
 }

 @threadSafety("app")
 cmd void vkCmdCopyQueryPoolResults(
         VkCommandBuffer                             commandBuffer,
         VkQueryPool                                 queryPool,
         u32                                         firstQuery,
         u32                                         queryCount,
         VkBuffer                                    dstBuffer,
         VkDeviceSize                                dstOffset,
         VkDeviceSize                                stride,
         VkQueryResultFlags                          flags) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     queryPoolObject := GetQueryPool(queryPool)
     dstBufferObject := GetBuffer(dstBuffer)
     assert(commandBufferObject.device == queryPoolObject.device)
     assert(commandBufferObject.device == dstBufferObject.device)
 }

 cmd void vkCmdPushConstants(
         VkCommandBuffer                             commandBuffer,
         VkPipelineLayout                            layout,
         VkShaderStageFlags                          stageFlags,
         u32                                         offset,
         u32                                         size,
         const void*                                 pValues) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     layoutObject := GetPipelineLayout(layout)
     assert(commandBufferObject.device == layoutObject.device)
 }

 @threadSafety("app")
 cmd void vkCmdBeginRenderPass(
         VkCommandBuffer                             commandBuffer,
         const VkRenderPassBeginInfo*                pRenderPassBegin,
         VkSubpassContents                           contents) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
     renderPassObject := GetRenderPass(pRenderPassBegin.renderPass)
     framebufferObject := GetFramebuffer(pRenderPassBegin.framebuffer)
     assert(commandBufferObject.device == renderPassObject.device)
     assert(commandBufferObject.device == framebufferObject.device)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 cmd void vkCmdNextSubpass(
         VkCommandBuffer                             commandBuffer,
         VkSubpassContents                           contents) {
     commandBufferObject := GetCommandBuffer(commandBuffer)
 }

 @threadSafety("app")
 cmd void vkCmdEndRenderPass(
         VkCommandBuffer                             commandBuffer) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
 }

 cmd void vkCmdExecuteCommands(
         VkCommandBuffer                             commandBuffer,
         u32                                         commandBufferCount,
         const VkCommandBuffer*                      pCommandBuffers) {
     commandBufferObject := GetCommandBuffer(commandBuffer)

     commandBuffers := pCommandBuffers[0:commandBufferCount]
     for i in (0 .. commandBufferCount) {
         secondaryCommandBuffer := commandBuffers[i]
         secondaryCommandBufferObject := GetCommandBuffer(secondaryCommandBuffer)
         assert(commandBufferObject.device == secondaryCommandBufferObject.device)
     }
 }

 //@vulkan1_1 functions

 @vulkan1_1
 cmd VkResult vkEnumerateInstanceVersion(
         u32*                                            pApiVersion) {
     return ?
 }

 @vulkan1_1
 cmd VkResult vkBindBufferMemory2(
         VkDevice                                        device,
         u32                                             bindInfoCount,
         const VkBindBufferMemoryInfo*                   pBindInfos) {
     return ?
 }

 @vulkan1_1
 cmd VkResult vkBindImageMemory2(
         VkDevice                                        device,
         u32                                             bindInfoCount,
         const VkBindImageMemoryInfo*                    pBindInfos) {
     return ?
 }

 @vulkan1_1
 cmd void vkGetDeviceGroupPeerMemoryFeatures(
         VkDevice                                    device,
         u32                                         heapIndex,
         u32                                         localDeviceIndex,
         u32                                         remoteDeviceIndex,
         VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures) {
 }

 @vulkan1_1
 cmd void vkCmdSetDeviceMask(
         VkCommandBuffer                             commandBuffer,
         u32                                         deviceMask) {
 }

 @vulkan1_1
 cmd void vkCmdDispatchBase(
         VkCommandBuffer                             commandBuffer,
         u32                                         baseGroupX,
         u32                                         baseGroupY,
         u32                                         baseGroupZ,
         u32                                         groupCountX,
         u32                                         groupCountY,
         u32                                         groupCountZ) {
 }

 @threadSafety("system")
 @vulkan1_1
 cmd VkResult vkEnumeratePhysicalDeviceGroups(
         VkInstance                                  instance,
         u32*                                        pPhysicalDeviceGroupCount,
         VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties) {
     instanceObject := GetInstance(instance)

     physicalDeviceGroupCount := as!u32(?)
     pPhysicalDeviceGroupCount[0] = physicalDeviceGroupCount
     physicalDevices := pPhysicalDeviceGroupProperties[0:physicalDeviceGroupCount]

     for i in (0 .. physicalDeviceGroupCount) {
         physicalDevice := ?
         physicalDevices[i] = physicalDevice
         if !(physicalDevice in State.PhysicalDevices) {
             State.PhysicalDevices[physicalDevice] = new!PhysicalDeviceObject(instance: instance)
         }
     }

     return ?
 }

 @vulkan1_1
 cmd void vkGetImageMemoryRequirements2(
         VkDevice                                    device,
         const VkImageMemoryRequirementsInfo2*       pInfo,
         VkMemoryRequirements2*                      pMemoryRequirements) {
 }

 @vulkan1_1
 cmd void vkGetBufferMemoryRequirements2(
         VkDevice                                    device,
         const VkBufferMemoryRequirementsInfo2*      pInfo,
         VkMemoryRequirements2*                      pMemoryRequirements) {
 }

 @vulkan1_1
 cmd void vkGetImageSparseMemoryRequirements2(
         VkDevice                                        device,
         const VkImageSparseMemoryRequirementsInfo2*     pInfo,
         u32*                                            pSparseMemoryRequirementCount,
         VkSparseImageMemoryRequirements2*               pSparseMemoryRequirements) {
 }

 @vulkan1_1
 cmd void vkGetPhysicalDeviceFeatures2(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceFeatures2*                  pFeatures) {
 }

 @vulkan1_1
 cmd void vkGetPhysicalDeviceProperties2(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceProperties2*                pProperties) {
 }

 @vulkan1_1
 cmd void vkGetPhysicalDeviceFormatProperties2(
         VkPhysicalDevice                            physicalDevice,
         VkFormat                                    format,
         VkFormatProperties2*                        pFormatProperties) {
 }

 @vulkan1_1
 cmd VkResult vkGetPhysicalDeviceImageFormatProperties2(
         VkPhysicalDevice                            physicalDevice,
         const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
         VkImageFormatProperties2*                   pImageFormatProperties) {
     return ?
 }

 @vulkan1_1
 cmd void vkGetPhysicalDeviceQueueFamilyProperties2(
         VkPhysicalDevice                            physicalDevice,
         u32*                                        pQueueFamilyPropertyCount,
         VkQueueFamilyProperties2*                   pQueueFamilyProperties) {
 }

 @vulkan1_1
 cmd void vkGetPhysicalDeviceMemoryProperties2(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceMemoryProperties2*          pMemoryProperties) {
 }

 @vulkan1_1
 cmd void vkGetPhysicalDeviceSparseImageFormatProperties2(
         VkPhysicalDevice                                    physicalDevice,
         const VkPhysicalDeviceSparseImageFormatInfo2*       pFormatInfo,
         u32*                                                pPropertyCount,
         VkSparseImageFormatProperties2*                     pProperties) {
 }

 @vulkan1_1
 cmd void vkTrimCommandPool(
         VkDevice                                    device,
         VkCommandPool                               commandPool,
         VkCommandPoolTrimFlags                      flags) {
 }


 @vulkan1_1
 cmd void vkGetDeviceQueue2(
         VkDevice                                    device,
         const VkDeviceQueueInfo2*                   pQueueInfo,
         VkQueue*                                    pQueue) {
     deviceObject := GetDevice(device)

     queue := ?
     pQueue[0] = queue

     if !(queue in State.Queues) {
         State.Queues[queue] = new!QueueObject(device: device)
     }
 }

 @vulkan1_1
 cmd VkResult vkCreateSamplerYcbcrConversion(
         VkDevice                                        device,
         const VkSamplerYcbcrConversionCreateInfo*       pCreateInfo,
         const VkAllocationCallbacks*                    pAllocator,
         VkSamplerYcbcrConversion*                       pYcbcrConversion) {
     return ?
 }

 @vulkan1_1
 cmd void vkDestroySamplerYcbcrConversion(
         VkDevice                                        device,
         VkSamplerYcbcrConversion                        ycbcrConversion,
         const VkAllocationCallbacks*                    pAllocator) {
 }

 @vulkan1_1
 cmd VkResult vkCreateDescriptorUpdateTemplate(
         VkDevice                                    device,
         const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate) {
     return ?
 }

 @vulkan1_1
 cmd void vkDestroyDescriptorUpdateTemplate(
         VkDevice                                    device,
         VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
         const VkAllocationCallbacks*                pAllocator) {
 }

 @vulkan1_1
 cmd void vkUpdateDescriptorSetWithTemplate(
         VkDevice                                    device,
         VkDescriptorSet                             descriptorSet,
         VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
         const void*                                 pData) {
 }

 @vulkan1_1
 cmd void vkGetPhysicalDeviceExternalBufferProperties(
         VkPhysicalDevice                                physicalDevice,
         const VkPhysicalDeviceExternalBufferInfo*       pExternalBufferInfo,
         VkExternalBufferProperties*                     pExternalBufferProperties) {
 }

 @vulkan1_1
 cmd void vkGetPhysicalDeviceExternalFenceProperties(
         VkPhysicalDevice                            physicalDevice,
         const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
         VkExternalFenceProperties*                  pExternalFenceProperties) {
 }

 @vulkan1_1
 cmd void vkGetPhysicalDeviceExternalSemaphoreProperties(
         VkPhysicalDevice                                physicalDevice,
         const VkPhysicalDeviceExternalSemaphoreInfo*    pExternalSemaphoreInfo,
         VkExternalSemaphoreProperties*                  pExternalSemaphoreProperties) {
 }

 @vulkan1_1
 cmd void vkGetDescriptorSetLayoutSupport(
         VkDevice                                    device,
         const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
         VkDescriptorSetLayoutSupport*               pSupport) {
 }


 @extension("VK_KHR_surface") // 1
 cmd void vkDestroySurfaceKHR(
         VkInstance                                  instance,
         VkSurfaceKHR                                surface,
         const VkAllocationCallbacks*                pAllocator) {
     instanceObject := GetInstance(instance)
     surfaceObject := GetSurface(surface)
     assert(surfaceObject.instance == instance)

     State.Surfaces[surface] = null
 }

 @extension("VK_KHR_surface") // 1
 cmd VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
         VkPhysicalDevice                            physicalDevice,
         u32                                         queueFamilyIndex,
         VkSurfaceKHR                                surface,
         VkBool32*                                   pSupported) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     return ?
 }

 @extension("VK_KHR_surface") // 1
 cmd VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
         VkPhysicalDevice                            physicalDevice,
         VkSurfaceKHR                                surface,
         VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     surfaceCapabilities := ?
     pSurfaceCapabilities[0] = surfaceCapabilities

     return ?
 }

 @extension("VK_KHR_surface") // 1
 cmd VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
         VkPhysicalDevice                            physicalDevice,
         VkSurfaceKHR                                surface,
         u32*                                        pSurfaceFormatCount,
         VkSurfaceFormatKHR*                         pSurfaceFormats) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     count := as!u32(?)
     pSurfaceFormatCount[0] = count
     surfaceFormats := pSurfaceFormats[0:count]

     for i in (0 .. count) {
         surfaceFormat := ?
         surfaceFormats[i] = surfaceFormat
     }

     return ?
 }

 @extension("VK_KHR_surface") // 1
 cmd VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
         VkPhysicalDevice                            physicalDevice,
         VkSurfaceKHR                                surface,
         u32*                                        pPresentModeCount,
         VkPresentModeKHR*                           pPresentModes) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)

     count := as!u32(?)
     pPresentModeCount[0] = count
     presentModes := pPresentModes[0:count]

     for i in (0 .. count) {
         presentMode := ?
         presentModes[i] = presentMode
     }

     return ?
 }

 @extension("VK_KHR_swapchain") // 2
 cmd VkResult vkCreateSwapchainKHR(
         VkDevice                                 device,
         const VkSwapchainCreateInfoKHR*          pCreateInfo,
         const VkAllocationCallbacks*             pAllocator,
         VkSwapchainKHR*                          pSwapchain) {
     assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR)
     deviceObject := GetDevice(device)

     swapchain := ?
     pSwapchain[0] = swapchain
     State.Swapchains[swapchain] = new!SwapchainObject(device: device)

     return ?
 }

 @extension("VK_KHR_swapchain") // 2
 cmd void vkDestroySwapchainKHR(
         VkDevice                                 device,
         VkSwapchainKHR                           swapchain,
         const VkAllocationCallbacks*             pAllocator) {
     deviceObject := GetDevice(device)
     swapchainObject := GetSwapchain(swapchain)
     assert(swapchainObject.device == device)

     State.Swapchains[swapchain] = null
 }

 @extension("VK_KHR_swapchain") // 2
 cmd VkResult vkGetSwapchainImagesKHR(
         VkDevice                                 device,
         VkSwapchainKHR                           swapchain,
         u32*                                     pSwapchainImageCount,
         VkImage*                                 pSwapchainImages) {
     deviceObject := GetDevice(device)

     count := as!u32(?)
     pSwapchainImageCount[0] = count
     swapchainImages := pSwapchainImages[0:count]

     for i in (0 .. count) {
         swapchainImage := ?
         swapchainImages[i] = swapchainImage
         State.Images[swapchainImage] = new!ImageObject(device: device)
     }

     return ?
 }

 @extension("VK_KHR_swapchain") // 2
 cmd VkResult vkAcquireNextImageKHR(
         VkDevice                                 device,
         VkSwapchainKHR                           swapchain,
         u64                                      timeout,
         VkSemaphore                              semaphore,
         VkFence                                  fence,
         u32*                                     pImageIndex) {
     deviceObject := GetDevice(device)
     swapchainObject := GetSwapchain(swapchain)

     imageIndex := ?
     pImageIndex[0] = imageIndex

     return ?
 }

 @extension("VK_KHR_swapchain") // 2
 cmd VkResult vkQueuePresentKHR(
         VkQueue                                  queue,
         const VkPresentInfoKHR*                  pPresentInfo) {
     queueObject := GetQueue(queue)

     presentInfo := ?
     pPresentInfo[0] = presentInfo

     return ?
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 cmd VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
         VkDevice                                    device,
         VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities) {
     return ?
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 cmd VkResult vkGetDeviceGroupSurfacePresentModesKHR(
         VkDevice                                    device,
         VkSurfaceKHR                                surface,
         VkDeviceGroupPresentModeFlagsKHR*           pModes) {
     return ?
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 cmd VkResult vkGetPhysicalDevicePresentRectanglesKHR(
         VkPhysicalDevice                            physicalDevice,
         VkSurfaceKHR                                surface,
         u32*                                        pRectCount,
         VkRect2D*                                   pRects) {
     return ?
 }

 @vulkan1_1
 @extension("VK_KHR_swapchain") // 2
 cmd VkResult vkAcquireNextImage2KHR(
         VkDevice                                    device,
         const VkAcquireNextImageInfoKHR*            pAcquireInfo,
         u32*                                        pImageIndex) {
     return ?
 }

 @extension("VK_KHR_display") // 3
 cmd VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
         VkPhysicalDevice                        physicalDevice,
         u32*                                    pPropertyCount,
         VkDisplayPropertiesKHR*                 pProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_KHR_display") // 3
 cmd VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
         VkPhysicalDevice                        physicalDevice,
         u32*                                    pPropertyCount,
         VkDisplayPlanePropertiesKHR*            pProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_KHR_display") // 3
 cmd VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
         VkPhysicalDevice                        physicalDevice,
         u32                                     planeIndex,
         u32*                                    pDisplayCount,
         VkDisplayKHR*                           pDisplays) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_KHR_display") // 3
 cmd VkResult vkGetDisplayModePropertiesKHR(
         VkPhysicalDevice                        physicalDevice,
         VkDisplayKHR                            display,
         u32*                                    pPropertyCount,
         VkDisplayModePropertiesKHR*             pProperties) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_KHR_display") // 3
 cmd VkResult vkCreateDisplayModeKHR(
         VkPhysicalDevice                        physicalDevice,
         VkDisplayKHR                            display,
         const VkDisplayModeCreateInfoKHR*       pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkDisplayModeKHR*                       pMode) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_KHR_display") // 3
 cmd VkResult vkGetDisplayPlaneCapabilitiesKHR(
         VkPhysicalDevice                        physicalDevice,
         VkDisplayModeKHR                        mode,
         u32                                     planeIndex,
         VkDisplayPlaneCapabilitiesKHR*          pCapabilities) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_KHR_display") // 3
 cmd VkResult vkCreateDisplayPlaneSurfaceKHR(
         VkInstance                              instance,
         const VkDisplaySurfaceCreateInfoKHR*    pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     return ?
 }

 @extension("VK_KHR_display_swapchain") // 4
 cmd VkResult vkCreateSharedSwapchainsKHR(
         VkDevice                                device,
         u32                                     swapchainCount,
         const VkSwapchainCreateInfoKHR*         pCreateInfos,
         const VkAllocationCallbacks*            pAllocator,
         VkSwapchainKHR*                         pSwapchains) {
     return ?
 }

 @extension("VK_KHR_xlib_surface") // 5
 cmd VkResult vkCreateXlibSurfaceKHR(
         VkInstance                              instance,
         const VkXlibSurfaceCreateInfoKHR*       pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
     return ?
 }

 @extension("VK_KHR_xlib_surface") // 5
 cmd VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
         VkPhysicalDevice                        physicalDevice,
         u32                                     queueFamilyIndex,
         platform.Display*                       dpy,
         platform.VisualID                       visualID) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_KHR_xcb_surface") // 6
 cmd VkResult vkCreateXcbSurfaceKHR(
         VkInstance                              instance,
         const VkXcbSurfaceCreateInfoKHR*        pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
     return ?
 }

 @extension("VK_KHR_xcb_surface") // 6
 cmd VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(
         VkPhysicalDevice                        physicalDevice,
         u32                                     queueFamilyIndex,
         platform.xcb_connection_t*              connection,
         platform.xcb_visualid_t                 visual_id) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_KHR_wayland_surface") // 7
 cmd VkResult vkCreateWaylandSurfaceKHR(
         VkInstance                              instance,
         const VkWaylandSurfaceCreateInfoKHR*    pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
     return ?
 }

 @extension("VK_KHR_wayland_surface") // 7
 cmd VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(
         VkPhysicalDevice                        physicalDevice,
         u32                                     queueFamilyIndex,
         platform.wl_display*                    display) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_KHR_mir_surface") // 8
 cmd VkResult vkCreateMirSurfaceKHR(
         VkInstance                              instance,
         const VkMirSurfaceCreateInfoKHR*        pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
     return ?
 }

 @extension("VK_KHR_mir_surface") // 8
 cmd VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR(
         VkPhysicalDevice                        physicalDevice,
         u32                                     queueFamilyIndex,
         platform.MirConnection*                 connection) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_KHR_android_surface") // 9
 cmd VkResult vkCreateAndroidSurfaceKHR(
         VkInstance                              instance,
         const VkAndroidSurfaceCreateInfoKHR*    pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
     return ?
 }

 @extension("VK_KHR_win32_surface") // 10
 cmd VkResult vkCreateWin32SurfaceKHR(
         VkInstance                              instance,
         const VkWin32SurfaceCreateInfoKHR*      pCreateInfo,
         const VkAllocationCallbacks*            pAllocator,
         VkSurfaceKHR*                           pSurface) {
     instanceObject := GetInstance(instance)
     return ?
 }

 @extension("VK_KHR_win32_surface") // 10
 cmd VkResult vkGetPhysicalDeviceWin32PresentationSupportKHR(
         VkPhysicalDevice                        physicalDevice,
         u32                                     queueFamilyIndex) {
     physicalDeviceObject := GetPhysicalDevice(physicalDevice)
     return ?
 }

 @extension("VK_ANDROID_native_buffer") // 11
 @optional
 cmd VkResult vkGetSwapchainGrallocUsageANDROID(
         VkDevice                                device,
         VkFormat                                format,
         VkImageUsageFlags                       imageUsage,
         s32*                                    grallocUsage) {
     return ?
 }

 @extension("VK_ANDROID_native_buffer") // 11
 @optional
 cmd VkResult vkGetSwapchainGrallocUsage2ANDROID(
         VkDevice                                device,
         VkFormat                                format,
         VkImageUsageFlags                       imageUsage,
         VkSwapchainImageUsageFlagsANDROID       swapchainImageUsage,
         u64*                                    grallocConsumerUsage,
         u64*                                    grallocProducerUsage) {
     return ?
 }

 @extension("VK_ANDROID_native_buffer") // 11
 cmd VkResult vkAcquireImageANDROID(
         VkDevice                                device,
         VkImage                                 image,
         int                                     nativeFenceFd,
         VkSemaphore                             semaphore,
         VkFence                                 fence) {
     return ?
 }

 @extension("VK_ANDROID_native_buffer") // 11
 cmd VkResult vkQueueSignalReleaseImageANDROID(
         VkQueue                                 queue,
         u32                                     waitSemaphoreCount,
         const VkSemaphore*                      pWaitSemaphores,
         VkImage                                 image,
         int*                                    pNativeFenceFd) {
     return ?
 }

 @extension("VK_EXT_debug_report") // 12
 @external type void* PFN_vkDebugReportCallbackEXT
 @extension("VK_EXT_debug_report") // 12
 @pfn cmd VkBool32 vkDebugReportCallbackEXT(
         VkDebugReportFlagsEXT                   flags,
         VkDebugReportObjectTypeEXT              objectType,
         u64                                     object,
         platform.size_t                         location,
         s32                                     messageCode,
         const char*                             pLayerPrefix,
         const char*                             pMessage,
         void*                                   pUserData) {
     return ?
 }

 @extension("VK_EXT_debug_report") // 12
 cmd VkResult vkCreateDebugReportCallbackEXT(
         VkInstance                                  instance,
         const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkDebugReportCallbackEXT*                   pCallback) {
     return ?
 }

 @extension("VK_EXT_debug_report") // 12
 cmd void vkDestroyDebugReportCallbackEXT(
         VkInstance                                  instance,
         VkDebugReportCallbackEXT                    callback,
         const VkAllocationCallbacks*                pAllocator) {
 }

 @extension("VK_EXT_debug_report") // 12
 cmd void vkDebugReportMessageEXT(
         VkInstance                                  instance,
         VkDebugReportFlagsEXT                       flags,
         VkDebugReportObjectTypeEXT                  objectType,
         u64                                         object,
         platform.size_t                             location,
         s32                                         messageCode,
         const char*                                 pLayerPrefix,
         const char*                                 pMessage) {
 }

 @extension("VK_EXT_debug_marker") // 23
 cmd VkResult vkDebugMarkerSetObjectTagEXT(
         VkDevice                                    device,
         const VkDebugMarkerObjectTagInfoEXT*        pTagInfo) {
     return ?
 }

 @extension("VK_EXT_debug_marker") // 23
 cmd VkResult vkDebugMarkerSetObjectNameEXT(
         VkDevice                                    device,
         const VkDebugMarkerObjectNameInfoEXT*       pNameInfo) {
     return ?
 }

 @extension("VK_EXT_debug_marker") // 23
 cmd void vkCmdDebugMarkerBeginEXT(
         VkCommandBuffer                             commandBuffer,
         const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo) {
 }

 @extension("VK_EXT_debug_marker") // 23
 cmd void vkCmdDebugMarkerEndEXT(
         VkCommandBuffer                             commandBuffer) {
 }

 @extension("VK_EXT_debug_marker") // 23
 cmd void vkCmdDebugMarkerInsertEXT(
         VkCommandBuffer                             commandBuffer,
         const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo) {
 }

 @extension("VK_AMD_draw_indirect_count") // 34
 cmd void vkCmdDrawIndirectCountAMD(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    buffer,
         VkDeviceSize                                offset,
         VkBuffer                                    countBuffer,
         VkDeviceSize                                countBufferOffset,
         u32                                         maxDrawCount,
         u32                                         stride) {
 }

 @extension("VK_AMD_draw_indirect_count") // 34
 cmd void vkCmdDrawIndexedIndirectCountAMD(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    buffer,
         VkDeviceSize                                offset,
         VkBuffer                                    countBuffer,
         VkDeviceSize                                countBufferOffset,
         u32                                         maxDrawCount,
         u32                                         stride) {
 }

 @extension("VK_AMD_shader_info") // 43
 cmd VkResult vkGetShaderInfoAMD(
         VkDevice                                    device,
         VkPipeline                                  pipeline,
         VkShaderStageFlagBits                       shaderStage,
         VkShaderInfoTypeAMD                         infoType,
         platform.size_t*                            pInfoSize,
         void*                                       pInfo) {
     return ?
 }

 @extension("VK_NV_external_memory_capabilities") // 56
 cmd VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
         VkPhysicalDevice                            physicalDevice,
         VkFormat                                    format,
         VkImageType                                 type,
         VkImageTiling                               tiling,
         VkImageUsageFlags                           usage,
         VkImageCreateFlags                          flags,
         VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
         VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties) {
     return ?
 }

 @extension("VK_NV_external_memory_win32") // 58
 cmd VkResult vkGetMemoryWin32HandleNV(
         VkDevice                                    device,
         VkDeviceMemory                              memory,
         VkExternalMemoryHandleTypeFlagsNV           handleType,
         platform.HANDLE*                            pHandle) {
     return ?
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 cmd void vkGetPhysicalDeviceFeatures2KHR(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceFeatures2KHR*               pFeatures) {
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 cmd void vkGetPhysicalDeviceProperties2KHR(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceProperties2KHR*             pProperties) {
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 cmd void vkGetPhysicalDeviceFormatProperties2KHR(
         VkPhysicalDevice                            physicalDevice,
         VkFormat                                    format,
         VkFormatProperties2KHR*                     pFormatProperties) {
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 cmd VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
         VkPhysicalDevice                            physicalDevice,
         const VkPhysicalDeviceImageFormatInfo2KHR*  pImageFormatInfo,
         VkImageFormatProperties2KHR*                pImageFormatProperties) {
     return ?
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 cmd void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
         VkPhysicalDevice                            physicalDevice,
         u32*                                        pQueueFamilyPropertyCount,
         VkQueueFamilyProperties2KHR*                pQueueFamilyProperties) {
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 cmd void vkGetPhysicalDeviceMemoryProperties2KHR(
         VkPhysicalDevice                            physicalDevice,
         VkPhysicalDeviceMemoryProperties2KHR*       pMemoryProperties) {
 }

 @extension("VK_KHR_get_physical_device_properties2") // 60
 cmd void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
         VkPhysicalDevice                                    physicalDevice,
         const VkPhysicalDeviceSparseImageFormatInfo2KHR*    pFormatInfo,
         u32*                                                pPropertyCount,
         VkSparseImageFormatProperties2KHR*                  pProperties) {
 }

 @extension("VK_KHR_device_group") // 61
 cmd void vkGetDeviceGroupPeerMemoryFeaturesKHR(
         VkDevice                                    device,
         u32                                         heapIndex,
         u32                                         localDeviceIndex,
         u32                                         remoteDeviceIndex,
         VkPeerMemoryFeatureFlagsKHR*                pPeerMemoryFeatures) {
 }

 @extension("VK_KHR_device_group") // 61
 cmd void vkCmdSetDeviceMaskKHR(
         VkCommandBuffer                             commandBuffer,
         u32                                         deviceMask) {
 }


 @extension("VK_KHR_device_group") // 61
 cmd void vkCmdDispatchBaseKHR(
         VkCommandBuffer                             commandBuffer,
         u32                                         baseGroupX,
         u32                                         baseGroupY,
         u32                                         baseGroupZ,
         u32                                         groupCountX,
         u32                                         groupCountY,
         u32                                         groupCountZ) {
 }

 @extension("VK_NN_vi_surface") // 63
 cmd VkResult vkCreateViSurfaceNN(
         VkInstance                                  instance,
         const VkViSurfaceCreateInfoNN*              pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkSurfaceKHR*                               pSurface) {
     return ?
 }

 @extension("VK_KHR_maintenance1") // 70
 cmd void vkTrimCommandPoolKHR(
         VkDevice                                    device,
         VkCommandPool                               commandPool,
         VkCommandPoolTrimFlagsKHR                   flags) {
 }

 @extension("VK_KHR_device_group_creation") // 71
 @threadSafety("system")
 cmd VkResult vkEnumeratePhysicalDeviceGroupsKHR(
         VkInstance                                  instance,
         u32*                                        pPhysicalDeviceGroupCount,
         VkPhysicalDeviceGroupPropertiesKHR*         pPhysicalDeviceGroupProperties) {
     instanceObject := GetInstance(instance)

     physicalDeviceGroupCount := as!u32(?)
     pPhysicalDeviceGroupCount[0] = physicalDeviceGroupCount
     physicalDevices := pPhysicalDeviceGroupProperties[0:physicalDeviceGroupCount]

     for i in (0 .. physicalDeviceGroupCount) {
         physicalDevice := ?
         physicalDevices[i] = physicalDevice
         if !(physicalDevice in State.PhysicalDevices) {
             State.PhysicalDevices[physicalDevice] = new!PhysicalDeviceObject(instance: instance)
         }
     }

     return ?
 }

 @extension("VK_KHR_external_memory_capabilities") // 72
 cmd void vkGetPhysicalDeviceExternalBufferPropertiesKHR(
         VkPhysicalDevice                                physicalDevice,
         const VkPhysicalDeviceExternalBufferInfoKHR*    pExternalBufferInfo,
         VkExternalBufferPropertiesKHR*                  pExternalBufferProperties) {
 }

 @extension("VK_KHR_external_memory_win32") // 74
 cmd VkResult vkGetMemoryWin32HandleKHR(
         VkDevice                                    device,
         const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
         platform.HANDLE*                            pHandle) {
     return ?
 }

 @extension("VK_KHR_external_memory_win32") // 74
 cmd VkResult vkGetMemoryWin32HandlePropertiesKHR(
         VkDevice                                    device,
         VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
         platform.HANDLE                             handle,
         VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties) {
     return ?
 }

 @extension("VK_KHR_external_memory_fd") // 75
 cmd VkResult vkGetMemoryFdKHR(
         VkDevice                                    device,
         const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
         s32*                                        pFd) {
     return ?
 }

 @extension("VK_KHR_external_memory_fd") // 75
 cmd VkResult vkGetMemoryFdPropertiesKHR(
         VkDevice                                    device,
         VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
         s32                                         fd,
         VkMemoryFdPropertiesKHR*                    pMemoryFdProperties) {
     return ?
 }

 @extension("VK_KHR_external_semaphore_capabilities") // 77
 cmd void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
         VkPhysicalDevice                            physicalDevice,
         const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
         VkExternalSemaphorePropertiesKHR*           pExternalSemaphoreProperties) {
 }

 @extension("VK_KHR_external_semaphore_win32") // 79
 cmd VkResult vkImportSemaphoreWin32HandleKHR(
         VkDevice                                    device,
         const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo) {
     return ?
 }

 @extension("VK_KHR_external_semaphore_win32") // 79
 cmd VkResult vkGetSemaphoreWin32HandleKHR(
         VkDevice                                    device,
         const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
         platform.HANDLE*                            pHandle) {
     return ?
 }

 @extension("VK_KHR_external_semaphore_fd") // 80
 cmd VkResult vkImportSemaphoreFdKHR(
         VkDevice                                    device,
         const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo) {
     return ?
 }

 @extension("VK_KHR_external_semaphore_fd") // 80
 cmd VkResult vkGetSemaphoreFdKHR(
         VkDevice                                    device,
         const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
         s32*                                        pFd) {
     return ?
 }

 @extension("VK_KHR_push_descriptor") // 81
 cmd void vkCmdPushDescriptorSetKHR(
         VkCommandBuffer                             commandBuffer,
         VkPipelineBindPoint                         pipelineBindPoint,
         VkPipelineLayout                            layout,
         u32                                         set,
         u32                                         descriptorWriteCount,
         const VkWriteDescriptorSet*                 pDescriptorWrites) {
 }

 @extension("VK_EXT_conditional_rendering") // 82
 cmd void vkCmdBeginConditionalRenderingEXT(
         VkCommandBuffer                             commandBuffer,
         const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin) {
 }

 @extension("VK_EXT_conditional_rendering") // 82
 cmd void vkCmdEndConditionalRenderingEXT(
         VkCommandBuffer                             commandBuffer) {
 }

 @extension("VK_KHR_descriptor_update_template") // 86
 cmd VkResult vkCreateDescriptorUpdateTemplateKHR(
         VkDevice                                    device,
         const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkDescriptorUpdateTemplateKHR*              pDescriptorUpdateTemplate) {
     return ?
 }

 @extension("VK_KHR_descriptor_update_template") // 86
 cmd void vkDestroyDescriptorUpdateTemplateKHR(
         VkDevice                                    device,
         VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
         const VkAllocationCallbacks*                pAllocator) {
 }

 @extension("VK_KHR_descriptor_update_template") // 86
 cmd void vkUpdateDescriptorSetWithTemplateKHR(
         VkDevice                                    device,
         VkDescriptorSet                             descriptorSet,
         VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
         const void*                                 pData) {
 }

 @extension("VK_KHR_descriptor_update_template") // 86
 cmd void vkCmdPushDescriptorSetWithTemplateKHR(
         VkCommandBuffer                             commandBuffer,
         VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
         VkPipelineLayout                            layout,
         u32                                         set,
         const void*                                 pData) {
 }

 @extension("VK_NVX_device_generated_commands") // 87
 cmd void vkCmdProcessCommandsNVX(
         VkCommandBuffer                             commandBuffer,
         const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo) {
 }

 @extension("VK_NVX_device_generated_commands") // 87
 cmd void vkCmdReserveSpaceForCommandsNVX(
         VkCommandBuffer                             commandBuffer,
         const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo) {
 }

 @extension("VK_NVX_device_generated_commands") // 87
 cmd VkResult vkCreateIndirectCommandsLayoutNVX(
         VkDevice                                    device,
         const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout) {
     return ?
 }

 @extension("VK_NVX_device_generated_commands") // 87
 cmd void vkDestroyIndirectCommandsLayoutNVX(
         VkDevice                                    device,
         VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
         const VkAllocationCallbacks*                pAllocator) {
 }

 @extension("VK_NVX_device_generated_commands") // 87
 cmd VkResult vkCreateObjectTableNVX(
         VkDevice                                    device,
         const VkObjectTableCreateInfoNVX*           pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkObjectTableNVX*                           pObjectTable) {
     return ?
 }

 @extension("VK_NVX_device_generated_commands") // 87
 cmd void vkDestroyObjectTableNVX(
         VkDevice                                    device,
         VkObjectTableNVX                            objectTable,
         const VkAllocationCallbacks*                pAllocator) {
 }

 @extension("VK_NVX_device_generated_commands") // 87
 cmd VkResult vkRegisterObjectsNVX(
         VkDevice                                    device,
         VkObjectTableNVX                            objectTable,
         u32                                         objectCount,
         const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
         const u32*                                  pObjectIndices) {
     return ?
 }

 @extension("VK_NVX_device_generated_commands") // 87
 cmd VkResult vkUnregisterObjectsNVX(
         VkDevice                                    device,
         VkObjectTableNVX                            objectTable,
         u32                                         objectCount,
         const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
         const u32*                                  pObjectIndices) {
     return ?
 }

 @extension("VK_NVX_device_generated_commands") // 87
 cmd void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
         VkPhysicalDevice                            physicalDevice,
         VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
         VkDeviceGeneratedCommandsLimitsNVX*         pLimits) {
 }

 @extension("VK_NV_clip_space_w_scaling") // 88
 cmd void vkCmdSetViewportWScalingNV(
         VkCommandBuffer                             commandBuffer,
         u32                                         firstViewport,
         u32                                         viewportCount,
         const VkViewportWScalingNV*                 pViewportWScalings) {
 }

 @extension("VK_EXT_direct_mode_display") // 89
 cmd VkResult vkReleaseDisplayEXT(
         VkPhysicalDevice                            physicalDevice,
         VkDisplayKHR                                display) {
     return ?
 }

 @extension("VK_EXT_acquire_xlib_display") // 90
 cmd VkResult vkAcquireXlibDisplayEXT(
         VkPhysicalDevice                            physicalDevice,
         platform.Display*                           dpy,
         VkDisplayKHR                                display) {
     return ?
 }

 @extension("VK_EXT_acquire_xlib_display") // 90
 cmd VkResult vkGetRandROutputDisplayEXT(
         VkPhysicalDevice                            physicalDevice,
         platform.Display*                           dpy,
         platform.RROutput                           rrOutput,
         VkDisplayKHR*                               pDisplay) {
     return ?
 }

 @extension("VK_EXT_display_surface_counter") // 91
 cmd VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(
         VkPhysicalDevice                            physicalDevice,
         VkSurfaceKHR                                surface,
         VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities) {
     return ?
 }

 @extension("VK_EXT_display_control") // 92
 cmd VkResult vkDisplayPowerControlEXT(
         VkDevice                                    device,
         VkDisplayKHR                                display,
         const VkDisplayPowerInfoEXT*                pDisplayPowerInfo) {
     return ?
 }

 @extension("VK_EXT_display_control") // 92
 cmd VkResult vkRegisterDeviceEventEXT(
         VkDevice                                    device,
         const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkFence*                                    pFence) {
     return ?
 }

 @extension("VK_EXT_display_control") // 92
 cmd VkResult vkRegisterDisplayEventEXT(
         VkDevice                                    device,
         VkDisplayKHR                                display,
         const VkDisplayEventInfoEXT*                pDisplayEventInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkFence*                                    pFence) {
     return ?
 }

 @extension("VK_EXT_display_control") // 92
 cmd VkResult vkGetSwapchainCounterEXT(
         VkDevice                                    device,
         VkSwapchainKHR                              swapchain,
         VkSurfaceCounterFlagBitsEXT                 counter,
         u64*                                        pCounterValue) {
     return ?
 }

 @extension("VK_GOOGLE_display_timing") // 93
 cmd VkResult vkGetRefreshCycleDurationGOOGLE(
         VkDevice                                    device,
         VkSwapchainKHR                              swapchain,
         VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties) {
     deviceObject := GetDevice(device)
     swapchainObject := GetSwapchain(swapchain)

     displayTimingProperties := ?
     pDisplayTimingProperties[0] = displayTimingProperties

     return ?
 }

 @extension("VK_GOOGLE_display_timing") // 93
 cmd VkResult vkGetPastPresentationTimingGOOGLE(
         VkDevice                                    device,
         VkSwapchainKHR                              swapchain,
         u32*                                        pPresentationTimingCount,
         VkPastPresentationTimingGOOGLE*             pPresentationTimings) {
     return ?
 }

 @extension("VK_EXT_discard_rectangles") // 100
 cmd void vkCmdSetDiscardRectangleEXT(
         VkCommandBuffer                             commandBuffer,
         u32                                         firstDiscardRectangle,
         u32                                         discardRectangleCount,
         const VkRect2D*                             pDiscardRectangles) {
 }

 @extension("VK_EXT_hdr_metadata") // 106
 cmd void vkSetHdrMetadataEXT(
         VkDevice                                    device,
         u32                                         swapchainCount,
         const VkSwapchainKHR*                       pSwapchains,
         const VkHdrMetadataEXT*                     pMetadata) {
 }

 @extension("VK_KHR_create_renderpass2") // 110
 cmd VkResult vkCreateRenderPass2KHR(
         VkDevice                                    device,
         const VkRenderPassCreateInfo2KHR*           pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkRenderPass*                               pRenderPass) {
     return ?
 }

 @extension("VK_KHR_create_renderpass2") // 110
 cmd void vkCmdBeginRenderPass2KHR(
         VkCommandBuffer                             commandBuffer,
         const VkRenderPassBeginInfo*                pRenderPassBegin,
         const VkSubpassBeginInfoKHR*                pSubpassBeginInfo) {
 }

 @extension("VK_KHR_create_renderpass2") // 110
 cmd void vkCmdNextSubpass2KHR(
         VkCommandBuffer                             commandBuffer,
         const VkSubpassBeginInfoKHR*                pSubpassBeginInfo,
         const VkSubpassEndInfoKHR*                  pSubpassEndInfo) {
 }

 @extension("VK_KHR_create_renderpass2") // 110
 cmd void vkCmdEndRenderPass2KHR(
         VkCommandBuffer                             commandBuffer,
         const VkSubpassEndInfoKHR*                  pSubpassEndInfo) {
 }

 @extension("VK_KHR_shared_presentable_image") // 112
 cmd VkResult vkGetSwapchainStatusKHR(
         VkDevice                                    device,
         VkSwapchainKHR                              swapchain) {
     return ?
 }

 @extension("VK_KHR_external_fence_capabilities") // 113
 cmd void vkGetPhysicalDeviceExternalFencePropertiesKHR(
         VkPhysicalDevice                            physicalDevice,
         const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
         VkExternalFencePropertiesKHR*               pExternalFenceProperties) {
 }

 @extension("VK_KHR_external_fence_win32") // 115
 cmd VkResult vkImportFenceWin32HandleKHR(
         VkDevice                                    device,
         const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo) {
     return ?
 }

 @extension("VK_KHR_external_fence_win32") // 115
 cmd VkResult vkGetFenceWin32HandleKHR(
         VkDevice                                    device,
         const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
         platform.HANDLE*                            pHandle) {
     return ?
 }

 @extension("VK_KHR_external_fence_fd") // 116
 cmd VkResult vkImportFenceFdKHR(
         VkDevice                                    device,
         const VkImportFenceFdInfoKHR*               pImportFenceFdInfo) {
     return ?
 }

 @extension("VK_KHR_external_fence_fd") // 116
 cmd VkResult vkGetFenceFdKHR(
         VkDevice                                    device,
         const VkFenceGetFdInfoKHR*                  pGetFdInfo,
         int*                                        pFd) {
     return ?
 }

 @extension("VK_KHR_get_surface_capabilities2") // 120
 cmd VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
         VkPhysicalDevice                            physicalDevice,
         const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
         VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities) {
     return ?
 }

 @extension("VK_KHR_get_surface_capabilities2") // 120
 cmd VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
         VkPhysicalDevice                            physicalDevice,
         const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
         u32*                                        pSurfaceFormatCount,
         VkSurfaceFormat2KHR*                        pSurfaceFormats) {
     return ?
 }

 @extension("VK_KHR_display_properties2") // 122
 cmd VkResult vkGetPhysicalDeviceDisplayProperties2KHR(
         VkPhysicalDevice                            physicalDevice,
         u32*                                        pPropertyCount,
         VkDisplayProperties2KHR*                    pProperties) {
     return ?
 }

 @extension("VK_KHR_display_properties2") // 122
 cmd VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
         VkPhysicalDevice                            physicalDevice,
         u32*                                        pPropertyCount,
         VkDisplayPlaneProperties2KHR*               pProperties) {
     return ?
 }

 @extension("VK_KHR_display_properties2") // 122
 cmd VkResult vkGetDisplayModeProperties2KHR(
         VkPhysicalDevice                            physicalDevice,
         VkDisplayKHR                                display,
         u32*                                        pPropertyCount,
         VkDisplayModeProperties2KHR*                pProperties) {
     return ?
 }

 @extension("VK_KHR_display_properties2") // 122
 cmd VkResult vkGetDisplayPlaneCapabilities2KHR(
         VkPhysicalDevice                            physicalDevice,
         const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
         VkDisplayPlaneCapabilities2KHR*             pCapabilities) {
     return ?
 }

 @extension("VK_MVK_ios_surface") // 123
 cmd VkResult vkCreateIOSSurfaceMVK(
         VkInstance                                  instance,
         const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkSurfaceKHR*                               pSurface) {
     return ?
 }

 @extension("VK_MVK_macos_surface") // 124
 cmd VkResult vkCreateMacOSSurfaceMVK(
         VkInstance                                  instance,
         const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkSurfaceKHR*                               pSurface) {
     return ?
 }

 @extension("VK_EXT_debug_utils") // 129
 @external type void* PFN_vkDebugUtilsMessengerCallbackEXT
 @extension("VK_EXT_debug_utils") // 129
 @pfn cmd VkBool32 vkDebugUtilsMessengerCallbackEXT(
         VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
         VkDebugUtilsMessageTypeFlagsEXT             messageType,
         const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
         void*                                       pUserData) {
     return ?
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd VkResult vkSetDebugUtilsObjectNameEXT(
         VkDevice                                    device,
         const VkDebugUtilsObjectNameInfoEXT*        pNameInfo) {
     return ?
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd VkResult vkSetDebugUtilsObjectTagEXT(
         VkDevice                                    device,
         const VkDebugUtilsObjectTagInfoEXT*         pTagInfo) {
     return ?
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd void vkQueueBeginDebugUtilsLabelEXT(
         VkQueue                                     queue,
         const VkDebugUtilsLabelEXT*                 pLabelInfo) {
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd void vkQueueEndDebugUtilsLabelEXT(VkQueue       queue) {
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd void vkQueueInsertDebugUtilsLabelEXT(
         VkQueue                                     queue,
         const VkDebugUtilsLabelEXT*                 pLabelInfo) {
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd void vkCmdBeginDebugUtilsLabelEXT(
         VkCommandBuffer                             commandBuffer,
         const VkDebugUtilsLabelEXT*                 pLabelInfo) {
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd void vkCmdInsertDebugUtilsLabelEXT(
         VkCommandBuffer                             commandBuffer,
         const VkDebugUtilsLabelEXT*                 pLabelInfo) {
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd VkResult vkCreateDebugUtilsMessengerEXT(
         VkInstance                                  instance,
         const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkDebugUtilsMessengerEXT*                   pMessenger) {
     return ?
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd void vkDestroyDebugUtilsMessengerEXT(
         VkInstance                                  instance,
         VkDebugUtilsMessengerEXT                    messenger,
         const VkAllocationCallbacks*                pAllocator) {
 }

 @extension("VK_EXT_debug_utils") // 129
 cmd void vkSubmitDebugUtilsMessageEXT(
         VkInstance                                  instance,
         VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
         VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
         const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
 }

 @extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
 @vulkan1_1 // extension requires 1.1, and should become non-optional when 1.1 does
 cmd VkResult vkGetAndroidHardwareBufferPropertiesANDROID(
         VkDevice                                    device,
         const platform.AHardwareBuffer*             buffer,
         VkAndroidHardwareBufferPropertiesANDROID*   pProperties) {
     return ?
 }

 @extension("VK_ANDROID_external_memory_android_hardware_buffer") // 130
 @vulkan1_1 // extension requires 1.1, and should become non-optional when 1.1 does
 cmd VkResult vkGetMemoryAndroidHardwareBufferANDROID(
         VkDevice                                            device,
         const VkMemoryGetAndroidHardwareBufferInfoANDROID*  pInfo,
         platform.AHardwareBuffer**                          pBuffer) {
     return ?
 }

 @extension("VK_EXT_sample_locations") // 144
 cmd void vkCmdSetSampleLocationsEXT(
         VkCommandBuffer                             commandBuffer,
         const VkSampleLocationsInfoEXT*             pSampleLocationsInfo) {
 }

 @extension("VK_EXT_sample_locations") // 144
 cmd void vkGetPhysicalDeviceMultisamplePropertiesEXT(
         VkPhysicalDevice                            physicalDevice,
         VkSampleCountFlagBits                       samples,
         VkMultisamplePropertiesEXT*                 pMultisampleProperties) {
 }

 @extension("VK_KHR_get_memory_requirements2") // 147
 cmd void vkGetImageMemoryRequirements2KHR(
         VkDevice                                    device,
         const VkImageMemoryRequirementsInfo2KHR*    pInfo,
         VkMemoryRequirements2KHR*                   pMemoryRequirements) {
 }

 @extension("VK_KHR_get_memory_requirements2") // 147
 cmd void vkGetBufferMemoryRequirements2KHR(
         VkDevice                                    device,
         const VkBufferMemoryRequirementsInfo2KHR*   pInfo,
         VkMemoryRequirements2KHR*                   pMemoryRequirements) {
 }

 @extension("VK_KHR_get_memory_requirements2") // 147
 cmd void vkGetImageSparseMemoryRequirements2KHR(
         VkDevice                                        device,
         const VkImageSparseMemoryRequirementsInfo2KHR*  pInfo,
         u32*                                            pSparseMemoryRequirementCount,
         VkSparseImageMemoryRequirements2KHR*            pSparseMemoryRequirements) {
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 cmd VkResult vkCreateSamplerYcbcrConversionKHR(
         VkDevice                                        device,
         const VkSamplerYcbcrConversionCreateInfoKHR*    pCreateInfo,
         const VkAllocationCallbacks*                    pAllocator,
         VkSamplerYcbcrConversionKHR*                    pYcbcrConversion) {
     return ?
 }

 @extension("VK_KHR_sampler_ycbcr_conversion") // 157
 cmd void vkDestroySamplerYcbcrConversionKHR(
         VkDevice                                        device,
         VkSamplerYcbcrConversionKHR                     ycbcrConversion,
         const VkAllocationCallbacks*                    pAllocator) {
 }

 @extension("VK_KHR_bind_memory2") // 158
 cmd VkResult vkBindBufferMemory2KHR(
         VkDevice                                        device,
         u32                                             bindInfoCount,
         const VkBindBufferMemoryInfoKHR*                pBindInfos) {
     return ?
 }

 @extension("VK_KHR_bind_memory2") // 158
 cmd VkResult vkBindImageMemory2KHR(
         VkDevice                                        device,
         u32                                             bindInfoCount,
         const VkBindImageMemoryInfoKHR*                 pBindInfos) {
     return ?
 }

 @extension("VK_EXT_validation_cache") // 161
 cmd VkResult vkCreateValidationCacheEXT(
         VkDevice                                    device,
         const VkValidationCacheCreateInfoEXT*       pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkValidationCacheEXT*                       pValidationCache) {
     return ?
 }

 @extension("VK_EXT_validation_cache") // 161
 cmd void vkDestroyValidationCacheEXT(
         VkDevice                                    device,
         VkValidationCacheEXT                        validationCache,
         const VkAllocationCallbacks*                pAllocator) {
 }

 @extension("VK_EXT_validation_cache") // 161
 cmd VkResult vkMergeValidationCachesEXT(
         VkDevice                                    device,
         VkValidationCacheEXT                        dstCache,
         u32                                         srcCacheCount,
         const VkValidationCacheEXT*                 pSrcCaches) {
     return ?
 }

 @extension("VK_EXT_validation_cache") // 161
 cmd VkResult vkGetValidationCacheDataEXT(
         VkDevice                                    device,
         VkValidationCacheEXT                        validationCache,
         platform.size_t*                            pDataSize,
         void*                                       pData) {
     return ?
 }

 @extension("VK_NV_shading_rate_image") // 165
 cmd void vkCmdBindShadingRateImageNV(
         VkCommandBuffer                             commandBuffer,
         VkImageView                                 imageView,
         VkImageLayout                               imageLayout) {
 }

 @extension("VK_NV_shading_rate_image") // 165
 cmd void vkCmdSetViewportShadingRatePaletteNV(
         VkCommandBuffer                             commandBuffer,
         u32                                         firstViewport,
         u32                                         viewportCount,
         const VkShadingRatePaletteNV*               pShadingRatePalettes) {
 }

 @extension("VK_NV_shading_rate_image") // 165
 cmd void vkCmdSetCoarseSampleOrderNV(
         VkCommandBuffer                             commandBuffer,
         VkCoarseSampleOrderTypeNV                   sampleOrderType,
         u32                                         customSampleOrderCount,
         const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders) {
 }

 @extension("VK_NVX_raytracing") // 166
 cmd VkResult vkCreateAccelerationStructureNVX(
         VkDevice                                    device,
         const VkAccelerationStructureCreateInfoNVX* pCreateInfo,
         const VkAllocationCallbacks*                pAllocator,
         VkAccelerationStructureNVX*                 pAccelerationStructure) {
     return ?
 }

 @extension("VK_NVX_raytracing") // 166
 cmd void vkDestroyAccelerationStructureNVX(
         VkDevice                                    device,
         VkAccelerationStructureNVX                  accelerationStructure,
         const VkAllocationCallbacks*                pAllocator) {
 }

 @extension("VK_NVX_raytracing") // 166
 cmd void vkGetAccelerationStructureMemoryRequirementsNVX(
         VkDevice                                                device,
         const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo,
         VkMemoryRequirements2KHR*                               pMemoryRequirements) {
 }

 @extension("VK_NVX_raytracing") // 166
 cmd void vkGetAccelerationStructureScratchMemoryRequirementsNVX(
         VkDevice                                                device,
         const VkAccelerationStructureMemoryRequirementsInfoNVX* pInfo,
         VkMemoryRequirements2KHR*                               pMemoryRequirements) {
 }

 @extension("VK_NVX_raytracing") // 166
 cmd VkResult vkBindAccelerationStructureMemoryNVX(
         VkDevice                                        device,
         u32                                             bindInfoCount,
         const VkBindAccelerationStructureMemoryInfoNVX* pBindInfos) {
     return ?
 }

 @extension("VK_NVX_raytracing") // 166
 cmd void vkCmdBuildAccelerationStructureNVX(
         VkCommandBuffer                             commandBuffer,
         VkAccelerationStructureTypeNVX              type,
         u32                                         instanceCount,
         VkBuffer                                    instanceData,
         VkDeviceSize                                instanceOffset,
         u32                                         geometryCount,
         const VkGeometryNVX*                        pGeometries,
         VkBuildAccelerationStructureFlagsNVX        flags,
         VkBool32                                    update,
         VkAccelerationStructureNVX                  dst,
         VkAccelerationStructureNVX                  src,
         VkBuffer                                    scratch,
         VkDeviceSize                                scratchOffset) {
 }

 @extension("VK_NVX_raytracing") // 166
 cmd void vkCmdCopyAccelerationStructureNVX(
         VkCommandBuffer                             commandBuffer,
         VkAccelerationStructureNVX                  dst,
         VkAccelerationStructureNVX                  src,
         VkCopyAccelerationStructureModeNVX          mode) {
 }

 @extension("VK_NVX_raytracing") // 166
 cmd void vkCmdTraceRaysNVX(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    raygenShaderBindingTableBuffer,
         VkDeviceSize                                raygenShaderBindingOffset,
         VkBuffer                                    missShaderBindingTableBuffer,
         VkDeviceSize                                missShaderBindingOffset,
         VkDeviceSize                                missShaderBindingStride,
         VkBuffer                                    hitShaderBindingTableBuffer,
         VkDeviceSize                                hitShaderBindingOffset,
         VkDeviceSize                                hitShaderBindingStride,
         u32                                         width,
         u32                                         height) {
 }

 @extension("VK_NVX_raytracing") // 166
 cmd VkResult vkCreateRaytracingPipelinesNVX(
         VkDevice                                    device,
         VkPipelineCache                             pipelineCache,
         u32                                         createInfoCount,
         const VkRaytracingPipelineCreateInfoNVX*    pCreateInfos,
         const VkAllocationCallbacks*                pAllocator,
         VkPipeline*                                 pPipelines) {
     return ?
 }

 @extension("VK_NVX_raytracing") // 166
 cmd VkResult vkGetRaytracingShaderHandlesNVX(
         VkDevice                                    device,
         VkPipeline                                  pipeline,
         u32                                         firstGroup,
         u32                                         groupCount,
         platform.size_t                             dataSize,
         void*                                       pData) {
     return ?
 }

 @extension("VK_NVX_raytracing") // 166
 cmd VkResult vkGetAccelerationStructureHandleNVX(
         VkDevice                                    device,
         VkAccelerationStructureNVX                  accelerationStructure,
         platform.size_t                             dataSize,
         void*                                       pData) {
     return ?
 }

 @extension("VK_NVX_raytracing") // 166
 cmd void vkCmdWriteAccelerationStructurePropertiesNVX(
         VkCommandBuffer                             commandBuffer,
         VkAccelerationStructureNVX                  accelerationStructure,
         VkQueryType                                 queryType,
         VkQueryPool                                 queryPool,
         u32                                         query) {
 }

 @extension("VK_NVX_raytracing") // 166
 cmd VkResult vkCompileDeferredNVX(
         VkDevice                                    device,
         VkPipeline                                  pipeline,
         u32                                         shader) {
     return ?
 }

 @extension("VK_KHR_maintenance3") // 169
 cmd void vkGetDescriptorSetLayoutSupportKHR(
         VkDevice                                    device,
         const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
         VkDescriptorSetLayoutSupportKHR*            pSupport) {
 }

 @extension("VK_KHR_draw_indirect_count") // 170
 cmd void vkCmdDrawIndirectCountKHR(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    buffer,
         VkDeviceSize                                offset,
         VkBuffer                                    countBuffer,
         VkDeviceSize                                countBufferOffset,
         u32                                         maxDrawCount,
         u32                                         stride) {
 }

 @extension("VK_KHR_draw_indirect_count") // 170
 cmd void vkCmdDrawIndexedIndirectCountKHR(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    buffer,
         VkDeviceSize                                offset,
         VkBuffer                                    countBuffer,
         VkDeviceSize                                countBufferOffset,
         u32                                         maxDrawCount,
         u32                                         stride) {
 }

 @extension("VK_EXT_external_memory_host") // 179
 cmd VkResult vkGetMemoryHostPointerPropertiesEXT(
         VkDevice                                    device,
         VkExternalMemoryHandleTypeFlagBits          handleType,
         const void*                                 pHostPointer,
         VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties) {
     return ?
 }

 @extension("VK_AMD_buffer_marker") // 180
 cmd void vkCmdWriteBufferMarkerAMD(
         VkCommandBuffer                             commandBuffer,
         VkPipelineStageFlagBits                     pipelineStage,
         VkBuffer                                    dstBuffer,
         VkDeviceSize                                dstOffset,
         u32                                         marker) {
 }

 @extension("VK_NV_mesh_shader") // 203
 cmd void vkCmdDrawMeshTasksNV(
         VkCommandBuffer                             commandBuffer,
         u32                                         taskCount,
         u32                                         firstTask) {
 }

 @extension("VK_NV_mesh_shader") // 203
 cmd void vkCmdDrawMeshTasksIndirectNV(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    buffer,
         VkDeviceSize                                offset,
         u32                                         drawCount,
         u32                                         stride) {
 }

 @extension("VK_NV_mesh_shader") // 203
 cmd void vkCmdDrawMeshTasksIndirectCountNV(
         VkCommandBuffer                             commandBuffer,
         VkBuffer                                    buffer,
         VkDeviceSize                                offset,
         VkBuffer                                    countBuffer,
         VkDeviceSize                                countBufferOffset,
         u32                                         maxDrawCount,
         u32                                         stride) {
 }

 @extension("VK_NV_scissor_exclusive") // 206
 cmd void vkCmdSetExclusiveScissorNV(
         VkCommandBuffer                             commandBuffer,
         u32                                         firstExclusiveScissor,
         u32                                         exclusiveScissorCount,
         const VkRect2D*                             pExclusiveScissors) {
 }

 @extension("VK_NV_device_diagnostic_checkpoints") // 207
 cmd void vkCmdSetCheckpointNV(
         VkCommandBuffer                             commandBuffer,
         const void*                                 pCheckpointMarker) {
 }

 @extension("VK_NV_device_diagnostic_checkpoints") // 207
 cmd void vkGetQueueCheckpointDataNV(
         VkQueue                                     queue,
         u32*                                        pCheckpointDataCount,
         VkCheckpointDataNV*                         pCheckpointData) {
 }


 ////////////////
 // Validation //
 ////////////////

 extern void validate(string layerName, bool condition, string message)


 /////////////////////////////
 // Internal State Tracking //
 /////////////////////////////

 StateObject State

 @internal class StateObject {
     // Dispatchable objects.
     map!(VkInstance,       ref!InstanceObject)       Instances
     map!(VkPhysicalDevice, ref!PhysicalDeviceObject) PhysicalDevices
     map!(VkDevice,         ref!DeviceObject)         Devices
     map!(VkQueue,          ref!QueueObject)          Queues
     map!(VkCommandBuffer,  ref!CommandBufferObject)  CommandBuffers

     // Non-dispatchable objects.
     map!(VkDeviceMemory,             ref!DeviceMemoryObject)             DeviceMemories
     map!(VkBuffer,                   ref!BufferObject)                   Buffers
     map!(VkBufferView,               ref!BufferViewObject)               BufferViews
     map!(VkImage,                    ref!ImageObject)                    Images
     map!(VkImageView,                ref!ImageViewObject)                ImageViews
     map!(VkShaderModule,             ref!ShaderModuleObject)             ShaderModules
     map!(VkPipeline,                 ref!PipelineObject)                 Pipelines
     map!(VkPipelineLayout,           ref!PipelineLayoutObject)           PipelineLayouts
     map!(VkSampler,                  ref!SamplerObject)                  Samplers
     map!(VkDescriptorSet,            ref!DescriptorSetObject)            DescriptorSets
     map!(VkDescriptorSetLayout,      ref!DescriptorSetLayoutObject)      DescriptorSetLayouts
     map!(VkDescriptorPool,           ref!DescriptorPoolObject)           DescriptorPools
     map!(VkFence,                    ref!FenceObject)                    Fences
     map!(VkSemaphore,                ref!SemaphoreObject)                Semaphores
     map!(VkEvent,                    ref!EventObject)                    Events
     map!(VkQueryPool,                ref!QueryPoolObject)                QueryPools
     map!(VkFramebuffer,              ref!FramebufferObject)              Framebuffers
     map!(VkRenderPass,               ref!RenderPassObject)               RenderPasses
     map!(VkPipelineCache,            ref!PipelineCacheObject)            PipelineCaches
     map!(VkCommandPool,              ref!CommandPoolObject)              CommandPools
     map!(VkSurfaceKHR,               ref!SurfaceObject)                  Surfaces
     map!(VkSwapchainKHR,             ref!SwapchainObject)                Swapchains
 }

 @internal class InstanceObject {
 }

 @internal class PhysicalDeviceObject {
     VkInstance instance
 }

 @internal class DeviceObject {
     VkPhysicalDevice physicalDevice
 }

 @internal class QueueObject {
     VkDevice      device
     VkQueueFlags  flags
 }

 @internal class CommandBufferObject {
     VkDevice                  device
     map!(u64, VkDeviceMemory) boundObjects
     VkQueueFlags              queueFlags
 }

 @internal class DeviceMemoryObject {
     VkDevice                                device
     VkDeviceSize                            allocationSize
     map!(u64, VkDeviceSize)                 boundObjects
     map!(VkCommandBuffer, VkCommandBuffer)  boundCommandBuffers
 }

 @internal class BufferObject {
     VkDevice              device
     VkDeviceMemory        memory
     VkDeviceSize          memoryOffset
 }

 @internal class BufferViewObject {
     VkDevice      device
     VkBuffer      buffer
 }

 @internal class ImageObject {
     VkDevice              device
     VkDeviceMemory        memory
     VkDeviceSize          memoryOffset
 }

 @internal class ImageViewObject {
     VkDevice      device
     VkImage       image
 }

 @internal class ShaderObject {
     VkDevice      device
 }

 @internal class ShaderModuleObject {
     VkDevice      device
 }

 @internal class PipelineObject {
     VkDevice      device
 }

 @internal class PipelineLayoutObject {
     VkDevice      device
 }

 @internal class SamplerObject {
     VkDevice      device
 }

 @internal class DescriptorSetObject {
     VkDevice      device
 }

 @internal class DescriptorSetLayoutObject {
     VkDevice      device
 }

 @internal class DescriptorPoolObject {
     VkDevice      device
 }

 @internal class FenceObject {
     VkDevice      device
     bool          signaled
 }

 @internal class SemaphoreObject {
     VkDevice      device
 }

 @internal class EventObject {
     VkDevice      device
 }

 @internal class QueryPoolObject {
     VkDevice      device
 }

 @internal class FramebufferObject {
     VkDevice      device
 }

 @internal class RenderPassObject {
     VkDevice      device
 }

 @internal class PipelineCacheObject {
     VkDevice      device
 }

 @internal class CommandPoolObject {
     VkDevice      device
 }

 @internal class SurfaceObject {
     VkInstance    instance
 }

 @internal class SwapchainObject {
     VkDevice      device
 }

 macro ref!InstanceObject GetInstance(VkInstance instance) {
     assert(instance in State.Instances)
     return State.Instances[instance]
 }

 macro ref!PhysicalDeviceObject GetPhysicalDevice(VkPhysicalDevice physicalDevice) {
     assert(physicalDevice in State.PhysicalDevices)
     return State.PhysicalDevices[physicalDevice]
 }

 macro ref!DeviceObject GetDevice(VkDevice device) {
     assert(device in State.Devices)
     return State.Devices[device]
 }

 macro ref!QueueObject GetQueue(VkQueue queue) {
     assert(queue in State.Queues)
     return State.Queues[queue]
 }

 macro ref!CommandBufferObject GetCommandBuffer(VkCommandBuffer commandBuffer) {
     assert(commandBuffer in State.CommandBuffers)
     return State.CommandBuffers[commandBuffer]
 }

 macro ref!DeviceMemoryObject GetDeviceMemory(VkDeviceMemory memory) {
     assert(memory in State.DeviceMemories)
     return State.DeviceMemories[memory]
 }

 macro ref!BufferObject GetBuffer(VkBuffer buffer) {
     assert(buffer in State.Buffers)
     return State.Buffers[buffer]
 }

 macro ref!BufferViewObject GetBufferView(VkBufferView bufferView) {
     assert(bufferView in State.BufferViews)
     return State.BufferViews[bufferView]
 }

 macro ref!ImageObject GetImage(VkImage image) {
     assert(image in State.Images)
     return State.Images[image]
 }

 macro ref!ImageViewObject GetImageView(VkImageView imageView) {
     assert(imageView in State.ImageViews)
     return State.ImageViews[imageView]
 }

 macro ref!ShaderModuleObject GetShaderModule(VkShaderModule shaderModule) {
     assert(shaderModule in State.ShaderModules)
     return State.ShaderModules[shaderModule]
 }

 macro ref!PipelineObject GetPipeline(VkPipeline pipeline) {
     assert(pipeline in State.Pipelines)
     return State.Pipelines[pipeline]
 }

 macro ref!PipelineLayoutObject GetPipelineLayout(VkPipelineLayout pipelineLayout) {
     assert(pipelineLayout in State.PipelineLayouts)
     return State.PipelineLayouts[pipelineLayout]
 }

 macro ref!SamplerObject GetSampler(VkSampler sampler) {
     assert(sampler in State.Samplers)
     return State.Samplers[sampler]
 }

 macro ref!DescriptorSetObject GetDescriptorSet(VkDescriptorSet descriptorSet) {
     assert(descriptorSet in State.DescriptorSets)
     return State.DescriptorSets[descriptorSet]
 }

 macro ref!DescriptorSetLayoutObject GetDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) {
     assert(descriptorSetLayout in State.DescriptorSetLayouts)
     return State.DescriptorSetLayouts[descriptorSetLayout]
 }

 macro ref!DescriptorPoolObject GetDescriptorPool(VkDescriptorPool descriptorPool) {
     assert(descriptorPool in State.DescriptorPools)
     return State.DescriptorPools[descriptorPool]
 }

 macro ref!FenceObject GetFence(VkFence fence) {
     assert(fence in State.Fences)
     return State.Fences[fence]
 }

 macro ref!SemaphoreObject GetSemaphore(VkSemaphore semaphore) {
     assert(semaphore in State.Semaphores)
     return State.Semaphores[semaphore]
 }

 macro ref!EventObject GetEvent(VkEvent event) {
     assert(event in State.Events)
     return State.Events[event]
 }

 macro ref!QueryPoolObject GetQueryPool(VkQueryPool queryPool) {
     assert(queryPool in State.QueryPools)
     return State.QueryPools[queryPool]
 }

 macro ref!FramebufferObject GetFramebuffer(VkFramebuffer framebuffer) {
     assert(framebuffer in State.Framebuffers)
     return State.Framebuffers[framebuffer]
 }

 macro ref!RenderPassObject GetRenderPass(VkRenderPass renderPass) {
     assert(renderPass in State.RenderPasses)
     return State.RenderPasses[renderPass]
 }

 macro ref!PipelineCacheObject GetPipelineCache(VkPipelineCache pipelineCache) {
     assert(pipelineCache in State.PipelineCaches)
     return State.PipelineCaches[pipelineCache]
 }

 macro ref!CommandPoolObject GetCommandPool(VkCommandPool commandPool) {
     assert(commandPool in State.CommandPools)
     return State.CommandPools[commandPool]
 }

 macro ref!SurfaceObject GetSurface(VkSurfaceKHR surface) {
     assert(surface in State.Surfaces)
     return State.Surfaces[surface]
 }

 macro ref!SwapchainObject GetSwapchain(VkSwapchainKHR swapchain) {
     assert(swapchain in State.Swapchains)
     return State.Swapchains[swapchain]
 }

 macro VkQueueFlags AddQueueFlag(VkQueueFlags flags, VkQueueFlagBits bit) {
     return as!VkQueueFlags(as!u32(flags) | as!u32(bit))
 }