1 module erupted.types; 2 3 alias uint8_t = ubyte; 4 alias uint16_t = ushort; 5 alias uint32_t = uint; 6 alias uint64_t = ulong; 7 alias int8_t = byte; 8 alias int16_t = short; 9 alias int32_t = int; 10 alias int64_t = long; 11 12 @nogc nothrow: 13 pure { 14 uint VK_MAKE_VERSION( uint major, uint minor, uint patch ) { 15 return ( major << 22 ) | ( minor << 12 ) | ( patch ); 16 } 17 18 // Vulkan 1.0 version number 19 uint VK_API_VERSION_1_0() { return VK_MAKE_VERSION( 1, 0, 0 ); } 20 21 uint VK_VERSION_MAJOR( uint ver ) { return ver >> 22; } 22 uint VK_VERSION_MINOR( uint ver ) { return ( ver >> 12 ) & 0x3ff; } 23 uint VK_VERSION_PATCH( uint ver ) { return ver & 0xfff; } 24 } 25 26 // Linkage of debug and allocation callbacks 27 extern( System ): 28 29 // Version of corresponding c header file 30 enum VK_HEADER_VERSION = 43; 31 32 enum VK_NULL_HANDLE = null; 33 34 enum VK_DEFINE_HANDLE( string name ) = "struct "~name~"_handle; alias "~name~" = "~name~"_handle*;"; 35 36 version( X86_64 ) { 37 alias VK_DEFINE_NON_DISPATCHABLE_HANDLE( string name ) = VK_DEFINE_HANDLE!name; 38 enum VK_NULL_ND_HANDLE = null; 39 } else { 40 enum VK_DEFINE_NON_DISPATCHABLE_HANDLE( string name ) = "alias "~name~" = ulong;"; 41 enum VK_NULL_ND_HANDLE = 0uL; 42 } 43 44 // VK_VERSION_1_0 45 alias VkFlags = uint32_t; 46 alias VkBool32 = uint32_t; 47 alias VkDeviceSize = uint64_t; 48 alias VkSampleMask = uint32_t; 49 50 mixin( VK_DEFINE_HANDLE!q{VkInstance} ); 51 mixin( VK_DEFINE_HANDLE!q{VkPhysicalDevice} ); 52 mixin( VK_DEFINE_HANDLE!q{VkDevice} ); 53 mixin( VK_DEFINE_HANDLE!q{VkQueue} ); 54 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSemaphore} ); 55 mixin( VK_DEFINE_HANDLE!q{VkCommandBuffer} ); 56 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkFence} ); 57 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDeviceMemory} ); 58 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkBuffer} ); 59 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkImage} ); 60 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkEvent} ); 61 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkQueryPool} ); 62 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkBufferView} ); 63 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkImageView} ); 64 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkShaderModule} ); 65 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkPipelineCache} ); 66 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkPipelineLayout} ); 67 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkRenderPass} ); 68 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkPipeline} ); 69 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDescriptorSetLayout} ); 70 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSampler} ); 71 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDescriptorPool} ); 72 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDescriptorSet} ); 73 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkFramebuffer} ); 74 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkCommandPool} ); 75 76 enum VK_LOD_CLAMP_NONE = 1000.0f; 77 enum VK_REMAINING_MIP_LEVELS = (~0U); 78 enum VK_REMAINING_ARRAY_LAYERS = (~0U); 79 enum VK_WHOLE_SIZE = (~0UL); 80 enum VK_ATTACHMENT_UNUSED = (~0U); 81 enum VK_TRUE = 1; 82 enum VK_FALSE = 0; 83 enum VK_QUEUE_FAMILY_IGNORED = (~0U); 84 enum VK_SUBPASS_EXTERNAL = (~0U); 85 enum VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256; 86 enum VK_UUID_SIZE = 16; 87 enum VK_MAX_MEMORY_TYPES = 32; 88 enum VK_MAX_MEMORY_HEAPS = 16; 89 enum VK_MAX_EXTENSION_NAME_SIZE = 256; 90 enum VK_MAX_DESCRIPTION_SIZE = 256; 91 92 93 enum VkPipelineCacheHeaderVersion { 94 VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, 95 VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 96 VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 97 VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = ( VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1 ), 98 VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF 99 } 100 101 // VkPipelineCacheHeaderVersion global enums 102 enum VK_PIPELINE_CACHE_HEADER_VERSION_ONE = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_ONE; 103 enum VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE; 104 enum VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE; 105 enum VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE; 106 enum VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM; 107 108 enum VkResult { 109 VK_SUCCESS = 0, 110 VK_NOT_READY = 1, 111 VK_TIMEOUT = 2, 112 VK_EVENT_SET = 3, 113 VK_EVENT_RESET = 4, 114 VK_INCOMPLETE = 5, 115 VK_ERROR_OUT_OF_HOST_MEMORY = -1, 116 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, 117 VK_ERROR_INITIALIZATION_FAILED = -3, 118 VK_ERROR_DEVICE_LOST = -4, 119 VK_ERROR_MEMORY_MAP_FAILED = -5, 120 VK_ERROR_LAYER_NOT_PRESENT = -6, 121 VK_ERROR_EXTENSION_NOT_PRESENT = -7, 122 VK_ERROR_FEATURE_NOT_PRESENT = -8, 123 VK_ERROR_INCOMPATIBLE_DRIVER = -9, 124 VK_ERROR_TOO_MANY_OBJECTS = -10, 125 VK_ERROR_FORMAT_NOT_SUPPORTED = -11, 126 VK_ERROR_FRAGMENTED_POOL = -12, 127 VK_ERROR_SURFACE_LOST_KHR = -1000000000, 128 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, 129 VK_SUBOPTIMAL_KHR = 1000001003, 130 VK_ERROR_OUT_OF_DATE_KHR = -1000001004, 131 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, 132 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, 133 VK_ERROR_INVALID_SHADER_NV = -1000012000, 134 VK_NV_EXTENSION_1_ERROR = -1000013000, 135 VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000, 136 VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX = -1000072003, 137 VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, 138 VK_RESULT_END_RANGE = VK_INCOMPLETE, 139 VK_RESULT_RANGE_SIZE = ( VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1 ), 140 VK_RESULT_MAX_ENUM = 0x7FFFFFFF 141 } 142 143 // VkResult global enums 144 enum VK_SUCCESS = VkResult.VK_SUCCESS; 145 enum VK_NOT_READY = VkResult.VK_NOT_READY; 146 enum VK_TIMEOUT = VkResult.VK_TIMEOUT; 147 enum VK_EVENT_SET = VkResult.VK_EVENT_SET; 148 enum VK_EVENT_RESET = VkResult.VK_EVENT_RESET; 149 enum VK_INCOMPLETE = VkResult.VK_INCOMPLETE; 150 enum VK_ERROR_OUT_OF_HOST_MEMORY = VkResult.VK_ERROR_OUT_OF_HOST_MEMORY; 151 enum VK_ERROR_OUT_OF_DEVICE_MEMORY = VkResult.VK_ERROR_OUT_OF_DEVICE_MEMORY; 152 enum VK_ERROR_INITIALIZATION_FAILED = VkResult.VK_ERROR_INITIALIZATION_FAILED; 153 enum VK_ERROR_DEVICE_LOST = VkResult.VK_ERROR_DEVICE_LOST; 154 enum VK_ERROR_MEMORY_MAP_FAILED = VkResult.VK_ERROR_MEMORY_MAP_FAILED; 155 enum VK_ERROR_LAYER_NOT_PRESENT = VkResult.VK_ERROR_LAYER_NOT_PRESENT; 156 enum VK_ERROR_EXTENSION_NOT_PRESENT = VkResult.VK_ERROR_EXTENSION_NOT_PRESENT; 157 enum VK_ERROR_FEATURE_NOT_PRESENT = VkResult.VK_ERROR_FEATURE_NOT_PRESENT; 158 enum VK_ERROR_INCOMPATIBLE_DRIVER = VkResult.VK_ERROR_INCOMPATIBLE_DRIVER; 159 enum VK_ERROR_TOO_MANY_OBJECTS = VkResult.VK_ERROR_TOO_MANY_OBJECTS; 160 enum VK_ERROR_FORMAT_NOT_SUPPORTED = VkResult.VK_ERROR_FORMAT_NOT_SUPPORTED; 161 enum VK_ERROR_FRAGMENTED_POOL = VkResult.VK_ERROR_FRAGMENTED_POOL; 162 enum VK_ERROR_SURFACE_LOST_KHR = VkResult.VK_ERROR_SURFACE_LOST_KHR; 163 enum VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = VkResult.VK_ERROR_NATIVE_WINDOW_IN_USE_KHR; 164 enum VK_SUBOPTIMAL_KHR = VkResult.VK_SUBOPTIMAL_KHR; 165 enum VK_ERROR_OUT_OF_DATE_KHR = VkResult.VK_ERROR_OUT_OF_DATE_KHR; 166 enum VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = VkResult.VK_ERROR_INCOMPATIBLE_DISPLAY_KHR; 167 enum VK_ERROR_VALIDATION_FAILED_EXT = VkResult.VK_ERROR_VALIDATION_FAILED_EXT; 168 enum VK_ERROR_INVALID_SHADER_NV = VkResult.VK_ERROR_INVALID_SHADER_NV; 169 enum VK_NV_EXTENSION_1_ERROR = VkResult.VK_NV_EXTENSION_1_ERROR; 170 enum VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VkResult.VK_ERROR_OUT_OF_POOL_MEMORY_KHR; 171 enum VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX = VkResult.VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX; 172 enum VK_RESULT_BEGIN_RANGE = VkResult.VK_RESULT_BEGIN_RANGE; 173 enum VK_RESULT_END_RANGE = VkResult.VK_RESULT_END_RANGE; 174 enum VK_RESULT_RANGE_SIZE = VkResult.VK_RESULT_RANGE_SIZE; 175 enum VK_RESULT_MAX_ENUM = VkResult.VK_RESULT_MAX_ENUM; 176 177 enum VkStructureType { 178 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, 179 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, 180 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, 181 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, 182 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, 183 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, 184 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, 185 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, 186 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, 187 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, 188 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, 189 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, 190 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, 191 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, 192 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, 193 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, 194 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, 195 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, 196 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, 197 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, 198 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, 199 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, 200 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, 201 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, 202 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, 203 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, 204 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, 205 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, 206 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, 207 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, 208 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, 209 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, 210 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, 211 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, 212 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, 213 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, 214 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, 215 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, 216 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, 217 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, 218 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, 219 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, 220 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, 221 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, 222 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, 223 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, 224 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, 225 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, 226 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, 227 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, 228 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, 229 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, 230 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, 231 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, 232 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, 233 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, 234 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, 235 VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, 236 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, 237 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, 238 VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, 239 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, 240 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, 241 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, 242 VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, 243 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, 244 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, 245 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, 246 VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000, 247 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001, 248 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002, 249 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, 250 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, 251 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, 252 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, 253 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, 254 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000, 255 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001, 256 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002, 257 VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003, 258 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004, 259 VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005, 260 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006, 261 VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007, 262 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008, 263 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = 1000060000, 264 VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX = 1000060001, 265 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX = 1000060002, 266 VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = 1000060003, 267 VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = 1000060004, 268 VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = 1000060005, 269 VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = 1000060006, 270 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = 1000060007, 271 VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = 1000060008, 272 VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = 1000060009, 273 VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = 1000060010, 274 VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = 1000060011, 275 VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = 1000060012, 276 VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, 277 VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, 278 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = 1000070000, 279 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = 1000070001, 280 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX = 1000071000, 281 VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX = 1000071001, 282 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX = 1000071002, 283 VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX = 1000071003, 284 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX = 1000071004, 285 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX = 1000071005, 286 VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX = 1000071006, 287 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX = 1000071007, 288 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX = 1000072000, 289 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX = 1000072001, 290 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX = 1000072002, 291 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073000, 292 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073001, 293 VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX = 1000073002, 294 VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX = 1000074000, 295 VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX = 1000074001, 296 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX = 1000075000, 297 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX = 1000076000, 298 VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX = 1000076001, 299 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX = 1000077000, 300 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078000, 301 VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078001, 302 VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = 1000078002, 303 VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = 1000079000, 304 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, 305 VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000, 306 VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, 307 VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001, 308 VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002, 309 VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003, 310 VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004, 311 VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005, 312 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, 313 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = 1000090000, 314 VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, 315 VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, 316 VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, 317 VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, 318 VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, 319 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, 320 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, 321 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, 322 VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, 323 VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, 324 VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, 325 VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, 326 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, 327 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, 328 VK_STRUCTURE_TYPE_RANGE_SIZE = ( VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1 ), 329 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF 330 } 331 332 // VkStructureType global enums 333 enum VK_STRUCTURE_TYPE_APPLICATION_INFO = VkStructureType.VK_STRUCTURE_TYPE_APPLICATION_INFO; 334 enum VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; 335 enum VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; 336 enum VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; 337 enum VK_STRUCTURE_TYPE_SUBMIT_INFO = VkStructureType.VK_STRUCTURE_TYPE_SUBMIT_INFO; 338 enum VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; 339 enum VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = VkStructureType.VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; 340 enum VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = VkStructureType.VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; 341 enum VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; 342 enum VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; 343 enum VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; 344 enum VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; 345 enum VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; 346 enum VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; 347 enum VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; 348 enum VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; 349 enum VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; 350 enum VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; 351 enum VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; 352 enum VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; 353 enum VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; 354 enum VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; 355 enum VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; 356 enum VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; 357 enum VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; 358 enum VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; 359 enum VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; 360 enum VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; 361 enum VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; 362 enum VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; 363 enum VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; 364 enum VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; 365 enum VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; 366 enum VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; 367 enum VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; 368 enum VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = VkStructureType.VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; 369 enum VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = VkStructureType.VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; 370 enum VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; 371 enum VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; 372 enum VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; 373 enum VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; 374 enum VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; 375 enum VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; 376 enum VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; 377 enum VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; 378 enum VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; 379 enum VK_STRUCTURE_TYPE_MEMORY_BARRIER = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_BARRIER; 380 enum VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO; 381 enum VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO; 382 enum VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; 383 enum VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; 384 enum VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR; 385 enum VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR; 386 enum VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR; 387 enum VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; 388 enum VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; 389 enum VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; 390 enum VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR; 391 enum VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; 392 enum VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; 393 enum VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; 394 enum VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; 395 enum VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; 396 enum VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT; 397 enum VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; 398 enum VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; 399 enum VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; 400 enum VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; 401 enum VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX; 402 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX; 403 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX; 404 enum VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; 405 enum VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV; 406 enum VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; 407 enum VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; 408 enum VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; 409 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR; 410 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR; 411 enum VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VkStructureType.VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR; 412 enum VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR; 413 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR; 414 enum VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VkStructureType.VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR; 415 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR; 416 enum VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VkStructureType.VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR; 417 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR; 418 enum VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX; 419 enum VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX; 420 enum VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX; 421 enum VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX; 422 enum VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX; 423 enum VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX; 424 enum VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX; 425 enum VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX; 426 enum VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX; 427 enum VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX; 428 enum VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX; 429 enum VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX; 430 enum VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX; 431 enum VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = VkStructureType.VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; 432 enum VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = VkStructureType.VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN; 433 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX; 434 enum VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX; 435 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX; 436 enum VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX = VkStructureType.VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX; 437 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX; 438 enum VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX = VkStructureType.VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX; 439 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX; 440 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX; 441 enum VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX; 442 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX; 443 enum VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX; 444 enum VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX; 445 enum VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX; 446 enum VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX; 447 enum VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX; 448 enum VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX; 449 enum VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX; 450 enum VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX; 451 enum VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX; 452 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX; 453 enum VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX = VkStructureType.VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX; 454 enum VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX; 455 enum VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX; 456 enum VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX; 457 enum VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX; 458 enum VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = VkStructureType.VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX; 459 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR; 460 enum VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR; 461 enum VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = VkStructureType.VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX; 462 enum VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = VkStructureType.VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX; 463 enum VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = VkStructureType.VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX; 464 enum VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = VkStructureType.VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX; 465 enum VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX; 466 enum VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX; 467 enum VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; 468 enum VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VkStructureType.VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT; 469 enum VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT; 470 enum VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT; 471 enum VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT; 472 enum VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT; 473 enum VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = VkStructureType.VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE; 474 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; 475 enum VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; 476 enum VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; 477 enum VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; 478 enum VK_STRUCTURE_TYPE_HDR_METADATA_EXT = VkStructureType.VK_STRUCTURE_TYPE_HDR_METADATA_EXT; 479 enum VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = VkStructureType.VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; 480 enum VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = VkStructureType.VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; 481 enum VK_STRUCTURE_TYPE_BEGIN_RANGE = VkStructureType.VK_STRUCTURE_TYPE_BEGIN_RANGE; 482 enum VK_STRUCTURE_TYPE_END_RANGE = VkStructureType.VK_STRUCTURE_TYPE_END_RANGE; 483 enum VK_STRUCTURE_TYPE_RANGE_SIZE = VkStructureType.VK_STRUCTURE_TYPE_RANGE_SIZE; 484 enum VK_STRUCTURE_TYPE_MAX_ENUM = VkStructureType.VK_STRUCTURE_TYPE_MAX_ENUM; 485 486 enum VkSystemAllocationScope { 487 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, 488 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, 489 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, 490 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, 491 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, 492 VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, 493 VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, 494 VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = ( VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1 ), 495 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF 496 } 497 498 // VkSystemAllocationScope global enums 499 enum VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_COMMAND; 500 enum VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_OBJECT; 501 enum VK_SYSTEM_ALLOCATION_SCOPE_CACHE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_CACHE; 502 enum VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_DEVICE; 503 enum VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE; 504 enum VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE; 505 enum VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE; 506 enum VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE; 507 enum VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM; 508 509 enum VkInternalAllocationType { 510 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, 511 VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 512 VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 513 VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = ( VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1 ), 514 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF 515 } 516 517 // VkInternalAllocationType global enums 518 enum VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE; 519 enum VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE; 520 enum VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_END_RANGE; 521 enum VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE; 522 enum VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM; 523 524 enum VkFormat { 525 VK_FORMAT_UNDEFINED = 0, 526 VK_FORMAT_R4G4_UNORM_PACK8 = 1, 527 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, 528 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, 529 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, 530 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, 531 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, 532 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, 533 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, 534 VK_FORMAT_R8_UNORM = 9, 535 VK_FORMAT_R8_SNORM = 10, 536 VK_FORMAT_R8_USCALED = 11, 537 VK_FORMAT_R8_SSCALED = 12, 538 VK_FORMAT_R8_UINT = 13, 539 VK_FORMAT_R8_SINT = 14, 540 VK_FORMAT_R8_SRGB = 15, 541 VK_FORMAT_R8G8_UNORM = 16, 542 VK_FORMAT_R8G8_SNORM = 17, 543 VK_FORMAT_R8G8_USCALED = 18, 544 VK_FORMAT_R8G8_SSCALED = 19, 545 VK_FORMAT_R8G8_UINT = 20, 546 VK_FORMAT_R8G8_SINT = 21, 547 VK_FORMAT_R8G8_SRGB = 22, 548 VK_FORMAT_R8G8B8_UNORM = 23, 549 VK_FORMAT_R8G8B8_SNORM = 24, 550 VK_FORMAT_R8G8B8_USCALED = 25, 551 VK_FORMAT_R8G8B8_SSCALED = 26, 552 VK_FORMAT_R8G8B8_UINT = 27, 553 VK_FORMAT_R8G8B8_SINT = 28, 554 VK_FORMAT_R8G8B8_SRGB = 29, 555 VK_FORMAT_B8G8R8_UNORM = 30, 556 VK_FORMAT_B8G8R8_SNORM = 31, 557 VK_FORMAT_B8G8R8_USCALED = 32, 558 VK_FORMAT_B8G8R8_SSCALED = 33, 559 VK_FORMAT_B8G8R8_UINT = 34, 560 VK_FORMAT_B8G8R8_SINT = 35, 561 VK_FORMAT_B8G8R8_SRGB = 36, 562 VK_FORMAT_R8G8B8A8_UNORM = 37, 563 VK_FORMAT_R8G8B8A8_SNORM = 38, 564 VK_FORMAT_R8G8B8A8_USCALED = 39, 565 VK_FORMAT_R8G8B8A8_SSCALED = 40, 566 VK_FORMAT_R8G8B8A8_UINT = 41, 567 VK_FORMAT_R8G8B8A8_SINT = 42, 568 VK_FORMAT_R8G8B8A8_SRGB = 43, 569 VK_FORMAT_B8G8R8A8_UNORM = 44, 570 VK_FORMAT_B8G8R8A8_SNORM = 45, 571 VK_FORMAT_B8G8R8A8_USCALED = 46, 572 VK_FORMAT_B8G8R8A8_SSCALED = 47, 573 VK_FORMAT_B8G8R8A8_UINT = 48, 574 VK_FORMAT_B8G8R8A8_SINT = 49, 575 VK_FORMAT_B8G8R8A8_SRGB = 50, 576 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, 577 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, 578 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, 579 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, 580 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, 581 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, 582 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, 583 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, 584 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, 585 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, 586 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, 587 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, 588 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, 589 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, 590 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, 591 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, 592 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, 593 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, 594 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, 595 VK_FORMAT_R16_UNORM = 70, 596 VK_FORMAT_R16_SNORM = 71, 597 VK_FORMAT_R16_USCALED = 72, 598 VK_FORMAT_R16_SSCALED = 73, 599 VK_FORMAT_R16_UINT = 74, 600 VK_FORMAT_R16_SINT = 75, 601 VK_FORMAT_R16_SFLOAT = 76, 602 VK_FORMAT_R16G16_UNORM = 77, 603 VK_FORMAT_R16G16_SNORM = 78, 604 VK_FORMAT_R16G16_USCALED = 79, 605 VK_FORMAT_R16G16_SSCALED = 80, 606 VK_FORMAT_R16G16_UINT = 81, 607 VK_FORMAT_R16G16_SINT = 82, 608 VK_FORMAT_R16G16_SFLOAT = 83, 609 VK_FORMAT_R16G16B16_UNORM = 84, 610 VK_FORMAT_R16G16B16_SNORM = 85, 611 VK_FORMAT_R16G16B16_USCALED = 86, 612 VK_FORMAT_R16G16B16_SSCALED = 87, 613 VK_FORMAT_R16G16B16_UINT = 88, 614 VK_FORMAT_R16G16B16_SINT = 89, 615 VK_FORMAT_R16G16B16_SFLOAT = 90, 616 VK_FORMAT_R16G16B16A16_UNORM = 91, 617 VK_FORMAT_R16G16B16A16_SNORM = 92, 618 VK_FORMAT_R16G16B16A16_USCALED = 93, 619 VK_FORMAT_R16G16B16A16_SSCALED = 94, 620 VK_FORMAT_R16G16B16A16_UINT = 95, 621 VK_FORMAT_R16G16B16A16_SINT = 96, 622 VK_FORMAT_R16G16B16A16_SFLOAT = 97, 623 VK_FORMAT_R32_UINT = 98, 624 VK_FORMAT_R32_SINT = 99, 625 VK_FORMAT_R32_SFLOAT = 100, 626 VK_FORMAT_R32G32_UINT = 101, 627 VK_FORMAT_R32G32_SINT = 102, 628 VK_FORMAT_R32G32_SFLOAT = 103, 629 VK_FORMAT_R32G32B32_UINT = 104, 630 VK_FORMAT_R32G32B32_SINT = 105, 631 VK_FORMAT_R32G32B32_SFLOAT = 106, 632 VK_FORMAT_R32G32B32A32_UINT = 107, 633 VK_FORMAT_R32G32B32A32_SINT = 108, 634 VK_FORMAT_R32G32B32A32_SFLOAT = 109, 635 VK_FORMAT_R64_UINT = 110, 636 VK_FORMAT_R64_SINT = 111, 637 VK_FORMAT_R64_SFLOAT = 112, 638 VK_FORMAT_R64G64_UINT = 113, 639 VK_FORMAT_R64G64_SINT = 114, 640 VK_FORMAT_R64G64_SFLOAT = 115, 641 VK_FORMAT_R64G64B64_UINT = 116, 642 VK_FORMAT_R64G64B64_SINT = 117, 643 VK_FORMAT_R64G64B64_SFLOAT = 118, 644 VK_FORMAT_R64G64B64A64_UINT = 119, 645 VK_FORMAT_R64G64B64A64_SINT = 120, 646 VK_FORMAT_R64G64B64A64_SFLOAT = 121, 647 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, 648 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, 649 VK_FORMAT_D16_UNORM = 124, 650 VK_FORMAT_X8_D24_UNORM_PACK32 = 125, 651 VK_FORMAT_D32_SFLOAT = 126, 652 VK_FORMAT_S8_UINT = 127, 653 VK_FORMAT_D16_UNORM_S8_UINT = 128, 654 VK_FORMAT_D24_UNORM_S8_UINT = 129, 655 VK_FORMAT_D32_SFLOAT_S8_UINT = 130, 656 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, 657 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, 658 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, 659 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, 660 VK_FORMAT_BC2_UNORM_BLOCK = 135, 661 VK_FORMAT_BC2_SRGB_BLOCK = 136, 662 VK_FORMAT_BC3_UNORM_BLOCK = 137, 663 VK_FORMAT_BC3_SRGB_BLOCK = 138, 664 VK_FORMAT_BC4_UNORM_BLOCK = 139, 665 VK_FORMAT_BC4_SNORM_BLOCK = 140, 666 VK_FORMAT_BC5_UNORM_BLOCK = 141, 667 VK_FORMAT_BC5_SNORM_BLOCK = 142, 668 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, 669 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, 670 VK_FORMAT_BC7_UNORM_BLOCK = 145, 671 VK_FORMAT_BC7_SRGB_BLOCK = 146, 672 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, 673 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, 674 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, 675 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, 676 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, 677 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, 678 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, 679 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, 680 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, 681 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, 682 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, 683 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, 684 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, 685 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, 686 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, 687 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, 688 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, 689 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, 690 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, 691 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, 692 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, 693 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, 694 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, 695 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, 696 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, 697 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, 698 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, 699 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, 700 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, 701 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, 702 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, 703 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, 704 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, 705 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, 706 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, 707 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, 708 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, 709 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, 710 VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, 711 VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, 712 VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, 713 VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, 714 VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, 715 VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, 716 VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, 717 VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, 718 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, 719 VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 720 VK_FORMAT_RANGE_SIZE = ( VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1 ), 721 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF 722 } 723 724 // VkFormat global enums 725 enum VK_FORMAT_UNDEFINED = VkFormat.VK_FORMAT_UNDEFINED; 726 enum VK_FORMAT_R4G4_UNORM_PACK8 = VkFormat.VK_FORMAT_R4G4_UNORM_PACK8; 727 enum VK_FORMAT_R4G4B4A4_UNORM_PACK16 = VkFormat.VK_FORMAT_R4G4B4A4_UNORM_PACK16; 728 enum VK_FORMAT_B4G4R4A4_UNORM_PACK16 = VkFormat.VK_FORMAT_B4G4R4A4_UNORM_PACK16; 729 enum VK_FORMAT_R5G6B5_UNORM_PACK16 = VkFormat.VK_FORMAT_R5G6B5_UNORM_PACK16; 730 enum VK_FORMAT_B5G6R5_UNORM_PACK16 = VkFormat.VK_FORMAT_B5G6R5_UNORM_PACK16; 731 enum VK_FORMAT_R5G5B5A1_UNORM_PACK16 = VkFormat.VK_FORMAT_R5G5B5A1_UNORM_PACK16; 732 enum VK_FORMAT_B5G5R5A1_UNORM_PACK16 = VkFormat.VK_FORMAT_B5G5R5A1_UNORM_PACK16; 733 enum VK_FORMAT_A1R5G5B5_UNORM_PACK16 = VkFormat.VK_FORMAT_A1R5G5B5_UNORM_PACK16; 734 enum VK_FORMAT_R8_UNORM = VkFormat.VK_FORMAT_R8_UNORM; 735 enum VK_FORMAT_R8_SNORM = VkFormat.VK_FORMAT_R8_SNORM; 736 enum VK_FORMAT_R8_USCALED = VkFormat.VK_FORMAT_R8_USCALED; 737 enum VK_FORMAT_R8_SSCALED = VkFormat.VK_FORMAT_R8_SSCALED; 738 enum VK_FORMAT_R8_UINT = VkFormat.VK_FORMAT_R8_UINT; 739 enum VK_FORMAT_R8_SINT = VkFormat.VK_FORMAT_R8_SINT; 740 enum VK_FORMAT_R8_SRGB = VkFormat.VK_FORMAT_R8_SRGB; 741 enum VK_FORMAT_R8G8_UNORM = VkFormat.VK_FORMAT_R8G8_UNORM; 742 enum VK_FORMAT_R8G8_SNORM = VkFormat.VK_FORMAT_R8G8_SNORM; 743 enum VK_FORMAT_R8G8_USCALED = VkFormat.VK_FORMAT_R8G8_USCALED; 744 enum VK_FORMAT_R8G8_SSCALED = VkFormat.VK_FORMAT_R8G8_SSCALED; 745 enum VK_FORMAT_R8G8_UINT = VkFormat.VK_FORMAT_R8G8_UINT; 746 enum VK_FORMAT_R8G8_SINT = VkFormat.VK_FORMAT_R8G8_SINT; 747 enum VK_FORMAT_R8G8_SRGB = VkFormat.VK_FORMAT_R8G8_SRGB; 748 enum VK_FORMAT_R8G8B8_UNORM = VkFormat.VK_FORMAT_R8G8B8_UNORM; 749 enum VK_FORMAT_R8G8B8_SNORM = VkFormat.VK_FORMAT_R8G8B8_SNORM; 750 enum VK_FORMAT_R8G8B8_USCALED = VkFormat.VK_FORMAT_R8G8B8_USCALED; 751 enum VK_FORMAT_R8G8B8_SSCALED = VkFormat.VK_FORMAT_R8G8B8_SSCALED; 752 enum VK_FORMAT_R8G8B8_UINT = VkFormat.VK_FORMAT_R8G8B8_UINT; 753 enum VK_FORMAT_R8G8B8_SINT = VkFormat.VK_FORMAT_R8G8B8_SINT; 754 enum VK_FORMAT_R8G8B8_SRGB = VkFormat.VK_FORMAT_R8G8B8_SRGB; 755 enum VK_FORMAT_B8G8R8_UNORM = VkFormat.VK_FORMAT_B8G8R8_UNORM; 756 enum VK_FORMAT_B8G8R8_SNORM = VkFormat.VK_FORMAT_B8G8R8_SNORM; 757 enum VK_FORMAT_B8G8R8_USCALED = VkFormat.VK_FORMAT_B8G8R8_USCALED; 758 enum VK_FORMAT_B8G8R8_SSCALED = VkFormat.VK_FORMAT_B8G8R8_SSCALED; 759 enum VK_FORMAT_B8G8R8_UINT = VkFormat.VK_FORMAT_B8G8R8_UINT; 760 enum VK_FORMAT_B8G8R8_SINT = VkFormat.VK_FORMAT_B8G8R8_SINT; 761 enum VK_FORMAT_B8G8R8_SRGB = VkFormat.VK_FORMAT_B8G8R8_SRGB; 762 enum VK_FORMAT_R8G8B8A8_UNORM = VkFormat.VK_FORMAT_R8G8B8A8_UNORM; 763 enum VK_FORMAT_R8G8B8A8_SNORM = VkFormat.VK_FORMAT_R8G8B8A8_SNORM; 764 enum VK_FORMAT_R8G8B8A8_USCALED = VkFormat.VK_FORMAT_R8G8B8A8_USCALED; 765 enum VK_FORMAT_R8G8B8A8_SSCALED = VkFormat.VK_FORMAT_R8G8B8A8_SSCALED; 766 enum VK_FORMAT_R8G8B8A8_UINT = VkFormat.VK_FORMAT_R8G8B8A8_UINT; 767 enum VK_FORMAT_R8G8B8A8_SINT = VkFormat.VK_FORMAT_R8G8B8A8_SINT; 768 enum VK_FORMAT_R8G8B8A8_SRGB = VkFormat.VK_FORMAT_R8G8B8A8_SRGB; 769 enum VK_FORMAT_B8G8R8A8_UNORM = VkFormat.VK_FORMAT_B8G8R8A8_UNORM; 770 enum VK_FORMAT_B8G8R8A8_SNORM = VkFormat.VK_FORMAT_B8G8R8A8_SNORM; 771 enum VK_FORMAT_B8G8R8A8_USCALED = VkFormat.VK_FORMAT_B8G8R8A8_USCALED; 772 enum VK_FORMAT_B8G8R8A8_SSCALED = VkFormat.VK_FORMAT_B8G8R8A8_SSCALED; 773 enum VK_FORMAT_B8G8R8A8_UINT = VkFormat.VK_FORMAT_B8G8R8A8_UINT; 774 enum VK_FORMAT_B8G8R8A8_SINT = VkFormat.VK_FORMAT_B8G8R8A8_SINT; 775 enum VK_FORMAT_B8G8R8A8_SRGB = VkFormat.VK_FORMAT_B8G8R8A8_SRGB; 776 enum VK_FORMAT_A8B8G8R8_UNORM_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_UNORM_PACK32; 777 enum VK_FORMAT_A8B8G8R8_SNORM_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SNORM_PACK32; 778 enum VK_FORMAT_A8B8G8R8_USCALED_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_USCALED_PACK32; 779 enum VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SSCALED_PACK32; 780 enum VK_FORMAT_A8B8G8R8_UINT_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_UINT_PACK32; 781 enum VK_FORMAT_A8B8G8R8_SINT_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SINT_PACK32; 782 enum VK_FORMAT_A8B8G8R8_SRGB_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SRGB_PACK32; 783 enum VK_FORMAT_A2R10G10B10_UNORM_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_UNORM_PACK32; 784 enum VK_FORMAT_A2R10G10B10_SNORM_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_SNORM_PACK32; 785 enum VK_FORMAT_A2R10G10B10_USCALED_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_USCALED_PACK32; 786 enum VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_SSCALED_PACK32; 787 enum VK_FORMAT_A2R10G10B10_UINT_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_UINT_PACK32; 788 enum VK_FORMAT_A2R10G10B10_SINT_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_SINT_PACK32; 789 enum VK_FORMAT_A2B10G10R10_UNORM_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_UNORM_PACK32; 790 enum VK_FORMAT_A2B10G10R10_SNORM_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_SNORM_PACK32; 791 enum VK_FORMAT_A2B10G10R10_USCALED_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_USCALED_PACK32; 792 enum VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_SSCALED_PACK32; 793 enum VK_FORMAT_A2B10G10R10_UINT_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_UINT_PACK32; 794 enum VK_FORMAT_A2B10G10R10_SINT_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_SINT_PACK32; 795 enum VK_FORMAT_R16_UNORM = VkFormat.VK_FORMAT_R16_UNORM; 796 enum VK_FORMAT_R16_SNORM = VkFormat.VK_FORMAT_R16_SNORM; 797 enum VK_FORMAT_R16_USCALED = VkFormat.VK_FORMAT_R16_USCALED; 798 enum VK_FORMAT_R16_SSCALED = VkFormat.VK_FORMAT_R16_SSCALED; 799 enum VK_FORMAT_R16_UINT = VkFormat.VK_FORMAT_R16_UINT; 800 enum VK_FORMAT_R16_SINT = VkFormat.VK_FORMAT_R16_SINT; 801 enum VK_FORMAT_R16_SFLOAT = VkFormat.VK_FORMAT_R16_SFLOAT; 802 enum VK_FORMAT_R16G16_UNORM = VkFormat.VK_FORMAT_R16G16_UNORM; 803 enum VK_FORMAT_R16G16_SNORM = VkFormat.VK_FORMAT_R16G16_SNORM; 804 enum VK_FORMAT_R16G16_USCALED = VkFormat.VK_FORMAT_R16G16_USCALED; 805 enum VK_FORMAT_R16G16_SSCALED = VkFormat.VK_FORMAT_R16G16_SSCALED; 806 enum VK_FORMAT_R16G16_UINT = VkFormat.VK_FORMAT_R16G16_UINT; 807 enum VK_FORMAT_R16G16_SINT = VkFormat.VK_FORMAT_R16G16_SINT; 808 enum VK_FORMAT_R16G16_SFLOAT = VkFormat.VK_FORMAT_R16G16_SFLOAT; 809 enum VK_FORMAT_R16G16B16_UNORM = VkFormat.VK_FORMAT_R16G16B16_UNORM; 810 enum VK_FORMAT_R16G16B16_SNORM = VkFormat.VK_FORMAT_R16G16B16_SNORM; 811 enum VK_FORMAT_R16G16B16_USCALED = VkFormat.VK_FORMAT_R16G16B16_USCALED; 812 enum VK_FORMAT_R16G16B16_SSCALED = VkFormat.VK_FORMAT_R16G16B16_SSCALED; 813 enum VK_FORMAT_R16G16B16_UINT = VkFormat.VK_FORMAT_R16G16B16_UINT; 814 enum VK_FORMAT_R16G16B16_SINT = VkFormat.VK_FORMAT_R16G16B16_SINT; 815 enum VK_FORMAT_R16G16B16_SFLOAT = VkFormat.VK_FORMAT_R16G16B16_SFLOAT; 816 enum VK_FORMAT_R16G16B16A16_UNORM = VkFormat.VK_FORMAT_R16G16B16A16_UNORM; 817 enum VK_FORMAT_R16G16B16A16_SNORM = VkFormat.VK_FORMAT_R16G16B16A16_SNORM; 818 enum VK_FORMAT_R16G16B16A16_USCALED = VkFormat.VK_FORMAT_R16G16B16A16_USCALED; 819 enum VK_FORMAT_R16G16B16A16_SSCALED = VkFormat.VK_FORMAT_R16G16B16A16_SSCALED; 820 enum VK_FORMAT_R16G16B16A16_UINT = VkFormat.VK_FORMAT_R16G16B16A16_UINT; 821 enum VK_FORMAT_R16G16B16A16_SINT = VkFormat.VK_FORMAT_R16G16B16A16_SINT; 822 enum VK_FORMAT_R16G16B16A16_SFLOAT = VkFormat.VK_FORMAT_R16G16B16A16_SFLOAT; 823 enum VK_FORMAT_R32_UINT = VkFormat.VK_FORMAT_R32_UINT; 824 enum VK_FORMAT_R32_SINT = VkFormat.VK_FORMAT_R32_SINT; 825 enum VK_FORMAT_R32_SFLOAT = VkFormat.VK_FORMAT_R32_SFLOAT; 826 enum VK_FORMAT_R32G32_UINT = VkFormat.VK_FORMAT_R32G32_UINT; 827 enum VK_FORMAT_R32G32_SINT = VkFormat.VK_FORMAT_R32G32_SINT; 828 enum VK_FORMAT_R32G32_SFLOAT = VkFormat.VK_FORMAT_R32G32_SFLOAT; 829 enum VK_FORMAT_R32G32B32_UINT = VkFormat.VK_FORMAT_R32G32B32_UINT; 830 enum VK_FORMAT_R32G32B32_SINT = VkFormat.VK_FORMAT_R32G32B32_SINT; 831 enum VK_FORMAT_R32G32B32_SFLOAT = VkFormat.VK_FORMAT_R32G32B32_SFLOAT; 832 enum VK_FORMAT_R32G32B32A32_UINT = VkFormat.VK_FORMAT_R32G32B32A32_UINT; 833 enum VK_FORMAT_R32G32B32A32_SINT = VkFormat.VK_FORMAT_R32G32B32A32_SINT; 834 enum VK_FORMAT_R32G32B32A32_SFLOAT = VkFormat.VK_FORMAT_R32G32B32A32_SFLOAT; 835 enum VK_FORMAT_R64_UINT = VkFormat.VK_FORMAT_R64_UINT; 836 enum VK_FORMAT_R64_SINT = VkFormat.VK_FORMAT_R64_SINT; 837 enum VK_FORMAT_R64_SFLOAT = VkFormat.VK_FORMAT_R64_SFLOAT; 838 enum VK_FORMAT_R64G64_UINT = VkFormat.VK_FORMAT_R64G64_UINT; 839 enum VK_FORMAT_R64G64_SINT = VkFormat.VK_FORMAT_R64G64_SINT; 840 enum VK_FORMAT_R64G64_SFLOAT = VkFormat.VK_FORMAT_R64G64_SFLOAT; 841 enum VK_FORMAT_R64G64B64_UINT = VkFormat.VK_FORMAT_R64G64B64_UINT; 842 enum VK_FORMAT_R64G64B64_SINT = VkFormat.VK_FORMAT_R64G64B64_SINT; 843 enum VK_FORMAT_R64G64B64_SFLOAT = VkFormat.VK_FORMAT_R64G64B64_SFLOAT; 844 enum VK_FORMAT_R64G64B64A64_UINT = VkFormat.VK_FORMAT_R64G64B64A64_UINT; 845 enum VK_FORMAT_R64G64B64A64_SINT = VkFormat.VK_FORMAT_R64G64B64A64_SINT; 846 enum VK_FORMAT_R64G64B64A64_SFLOAT = VkFormat.VK_FORMAT_R64G64B64A64_SFLOAT; 847 enum VK_FORMAT_B10G11R11_UFLOAT_PACK32 = VkFormat.VK_FORMAT_B10G11R11_UFLOAT_PACK32; 848 enum VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = VkFormat.VK_FORMAT_E5B9G9R9_UFLOAT_PACK32; 849 enum VK_FORMAT_D16_UNORM = VkFormat.VK_FORMAT_D16_UNORM; 850 enum VK_FORMAT_X8_D24_UNORM_PACK32 = VkFormat.VK_FORMAT_X8_D24_UNORM_PACK32; 851 enum VK_FORMAT_D32_SFLOAT = VkFormat.VK_FORMAT_D32_SFLOAT; 852 enum VK_FORMAT_S8_UINT = VkFormat.VK_FORMAT_S8_UINT; 853 enum VK_FORMAT_D16_UNORM_S8_UINT = VkFormat.VK_FORMAT_D16_UNORM_S8_UINT; 854 enum VK_FORMAT_D24_UNORM_S8_UINT = VkFormat.VK_FORMAT_D24_UNORM_S8_UINT; 855 enum VK_FORMAT_D32_SFLOAT_S8_UINT = VkFormat.VK_FORMAT_D32_SFLOAT_S8_UINT; 856 enum VK_FORMAT_BC1_RGB_UNORM_BLOCK = VkFormat.VK_FORMAT_BC1_RGB_UNORM_BLOCK; 857 enum VK_FORMAT_BC1_RGB_SRGB_BLOCK = VkFormat.VK_FORMAT_BC1_RGB_SRGB_BLOCK; 858 enum VK_FORMAT_BC1_RGBA_UNORM_BLOCK = VkFormat.VK_FORMAT_BC1_RGBA_UNORM_BLOCK; 859 enum VK_FORMAT_BC1_RGBA_SRGB_BLOCK = VkFormat.VK_FORMAT_BC1_RGBA_SRGB_BLOCK; 860 enum VK_FORMAT_BC2_UNORM_BLOCK = VkFormat.VK_FORMAT_BC2_UNORM_BLOCK; 861 enum VK_FORMAT_BC2_SRGB_BLOCK = VkFormat.VK_FORMAT_BC2_SRGB_BLOCK; 862 enum VK_FORMAT_BC3_UNORM_BLOCK = VkFormat.VK_FORMAT_BC3_UNORM_BLOCK; 863 enum VK_FORMAT_BC3_SRGB_BLOCK = VkFormat.VK_FORMAT_BC3_SRGB_BLOCK; 864 enum VK_FORMAT_BC4_UNORM_BLOCK = VkFormat.VK_FORMAT_BC4_UNORM_BLOCK; 865 enum VK_FORMAT_BC4_SNORM_BLOCK = VkFormat.VK_FORMAT_BC4_SNORM_BLOCK; 866 enum VK_FORMAT_BC5_UNORM_BLOCK = VkFormat.VK_FORMAT_BC5_UNORM_BLOCK; 867 enum VK_FORMAT_BC5_SNORM_BLOCK = VkFormat.VK_FORMAT_BC5_SNORM_BLOCK; 868 enum VK_FORMAT_BC6H_UFLOAT_BLOCK = VkFormat.VK_FORMAT_BC6H_UFLOAT_BLOCK; 869 enum VK_FORMAT_BC6H_SFLOAT_BLOCK = VkFormat.VK_FORMAT_BC6H_SFLOAT_BLOCK; 870 enum VK_FORMAT_BC7_UNORM_BLOCK = VkFormat.VK_FORMAT_BC7_UNORM_BLOCK; 871 enum VK_FORMAT_BC7_SRGB_BLOCK = VkFormat.VK_FORMAT_BC7_SRGB_BLOCK; 872 enum VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; 873 enum VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK; 874 enum VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK; 875 enum VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK; 876 enum VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; 877 enum VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK; 878 enum VK_FORMAT_EAC_R11_UNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11_UNORM_BLOCK; 879 enum VK_FORMAT_EAC_R11_SNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11_SNORM_BLOCK; 880 enum VK_FORMAT_EAC_R11G11_UNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11G11_UNORM_BLOCK; 881 enum VK_FORMAT_EAC_R11G11_SNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11G11_SNORM_BLOCK; 882 enum VK_FORMAT_ASTC_4x4_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_4x4_UNORM_BLOCK; 883 enum VK_FORMAT_ASTC_4x4_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_4x4_SRGB_BLOCK; 884 enum VK_FORMAT_ASTC_5x4_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_5x4_UNORM_BLOCK; 885 enum VK_FORMAT_ASTC_5x4_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_5x4_SRGB_BLOCK; 886 enum VK_FORMAT_ASTC_5x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_5x5_UNORM_BLOCK; 887 enum VK_FORMAT_ASTC_5x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_5x5_SRGB_BLOCK; 888 enum VK_FORMAT_ASTC_6x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_6x5_UNORM_BLOCK; 889 enum VK_FORMAT_ASTC_6x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_6x5_SRGB_BLOCK; 890 enum VK_FORMAT_ASTC_6x6_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_6x6_UNORM_BLOCK; 891 enum VK_FORMAT_ASTC_6x6_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_6x6_SRGB_BLOCK; 892 enum VK_FORMAT_ASTC_8x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_8x5_UNORM_BLOCK; 893 enum VK_FORMAT_ASTC_8x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_8x5_SRGB_BLOCK; 894 enum VK_FORMAT_ASTC_8x6_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_8x6_UNORM_BLOCK; 895 enum VK_FORMAT_ASTC_8x6_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_8x6_SRGB_BLOCK; 896 enum VK_FORMAT_ASTC_8x8_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_8x8_UNORM_BLOCK; 897 enum VK_FORMAT_ASTC_8x8_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_8x8_SRGB_BLOCK; 898 enum VK_FORMAT_ASTC_10x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x5_UNORM_BLOCK; 899 enum VK_FORMAT_ASTC_10x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x5_SRGB_BLOCK; 900 enum VK_FORMAT_ASTC_10x6_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x6_UNORM_BLOCK; 901 enum VK_FORMAT_ASTC_10x6_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x6_SRGB_BLOCK; 902 enum VK_FORMAT_ASTC_10x8_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x8_UNORM_BLOCK; 903 enum VK_FORMAT_ASTC_10x8_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x8_SRGB_BLOCK; 904 enum VK_FORMAT_ASTC_10x10_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x10_UNORM_BLOCK; 905 enum VK_FORMAT_ASTC_10x10_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x10_SRGB_BLOCK; 906 enum VK_FORMAT_ASTC_12x10_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_12x10_UNORM_BLOCK; 907 enum VK_FORMAT_ASTC_12x10_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_12x10_SRGB_BLOCK; 908 enum VK_FORMAT_ASTC_12x12_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_12x12_UNORM_BLOCK; 909 enum VK_FORMAT_ASTC_12x12_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_12x12_SRGB_BLOCK; 910 enum VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG; 911 enum VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG; 912 enum VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG; 913 enum VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG; 914 enum VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG; 915 enum VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG; 916 enum VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG; 917 enum VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG; 918 enum VK_FORMAT_BEGIN_RANGE = VkFormat.VK_FORMAT_BEGIN_RANGE; 919 enum VK_FORMAT_END_RANGE = VkFormat.VK_FORMAT_END_RANGE; 920 enum VK_FORMAT_RANGE_SIZE = VkFormat.VK_FORMAT_RANGE_SIZE; 921 enum VK_FORMAT_MAX_ENUM = VkFormat.VK_FORMAT_MAX_ENUM; 922 923 enum VkImageType { 924 VK_IMAGE_TYPE_1D = 0, 925 VK_IMAGE_TYPE_2D = 1, 926 VK_IMAGE_TYPE_3D = 2, 927 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, 928 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, 929 VK_IMAGE_TYPE_RANGE_SIZE = ( VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1 ), 930 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF 931 } 932 933 // VkImageType global enums 934 enum VK_IMAGE_TYPE_1D = VkImageType.VK_IMAGE_TYPE_1D; 935 enum VK_IMAGE_TYPE_2D = VkImageType.VK_IMAGE_TYPE_2D; 936 enum VK_IMAGE_TYPE_3D = VkImageType.VK_IMAGE_TYPE_3D; 937 enum VK_IMAGE_TYPE_BEGIN_RANGE = VkImageType.VK_IMAGE_TYPE_BEGIN_RANGE; 938 enum VK_IMAGE_TYPE_END_RANGE = VkImageType.VK_IMAGE_TYPE_END_RANGE; 939 enum VK_IMAGE_TYPE_RANGE_SIZE = VkImageType.VK_IMAGE_TYPE_RANGE_SIZE; 940 enum VK_IMAGE_TYPE_MAX_ENUM = VkImageType.VK_IMAGE_TYPE_MAX_ENUM; 941 942 enum VkImageTiling { 943 VK_IMAGE_TILING_OPTIMAL = 0, 944 VK_IMAGE_TILING_LINEAR = 1, 945 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, 946 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, 947 VK_IMAGE_TILING_RANGE_SIZE = ( VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1 ), 948 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF 949 } 950 951 // VkImageTiling global enums 952 enum VK_IMAGE_TILING_OPTIMAL = VkImageTiling.VK_IMAGE_TILING_OPTIMAL; 953 enum VK_IMAGE_TILING_LINEAR = VkImageTiling.VK_IMAGE_TILING_LINEAR; 954 enum VK_IMAGE_TILING_BEGIN_RANGE = VkImageTiling.VK_IMAGE_TILING_BEGIN_RANGE; 955 enum VK_IMAGE_TILING_END_RANGE = VkImageTiling.VK_IMAGE_TILING_END_RANGE; 956 enum VK_IMAGE_TILING_RANGE_SIZE = VkImageTiling.VK_IMAGE_TILING_RANGE_SIZE; 957 enum VK_IMAGE_TILING_MAX_ENUM = VkImageTiling.VK_IMAGE_TILING_MAX_ENUM; 958 959 enum VkPhysicalDeviceType { 960 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, 961 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, 962 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, 963 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, 964 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, 965 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, 966 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, 967 VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = ( VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1 ), 968 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF 969 } 970 971 // VkPhysicalDeviceType global enums 972 enum VK_PHYSICAL_DEVICE_TYPE_OTHER = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_OTHER; 973 enum VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU; 974 enum VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 975 enum VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU; 976 enum VK_PHYSICAL_DEVICE_TYPE_CPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_CPU; 977 enum VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE; 978 enum VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_END_RANGE; 979 enum VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE; 980 enum VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM; 981 982 enum VkQueryType { 983 VK_QUERY_TYPE_OCCLUSION = 0, 984 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, 985 VK_QUERY_TYPE_TIMESTAMP = 2, 986 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, 987 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, 988 VK_QUERY_TYPE_RANGE_SIZE = ( VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1 ), 989 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF 990 } 991 992 // VkQueryType global enums 993 enum VK_QUERY_TYPE_OCCLUSION = VkQueryType.VK_QUERY_TYPE_OCCLUSION; 994 enum VK_QUERY_TYPE_PIPELINE_STATISTICS = VkQueryType.VK_QUERY_TYPE_PIPELINE_STATISTICS; 995 enum VK_QUERY_TYPE_TIMESTAMP = VkQueryType.VK_QUERY_TYPE_TIMESTAMP; 996 enum VK_QUERY_TYPE_BEGIN_RANGE = VkQueryType.VK_QUERY_TYPE_BEGIN_RANGE; 997 enum VK_QUERY_TYPE_END_RANGE = VkQueryType.VK_QUERY_TYPE_END_RANGE; 998 enum VK_QUERY_TYPE_RANGE_SIZE = VkQueryType.VK_QUERY_TYPE_RANGE_SIZE; 999 enum VK_QUERY_TYPE_MAX_ENUM = VkQueryType.VK_QUERY_TYPE_MAX_ENUM; 1000 1001 enum VkSharingMode { 1002 VK_SHARING_MODE_EXCLUSIVE = 0, 1003 VK_SHARING_MODE_CONCURRENT = 1, 1004 VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, 1005 VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, 1006 VK_SHARING_MODE_RANGE_SIZE = ( VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1 ), 1007 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF 1008 } 1009 1010 // VkSharingMode global enums 1011 enum VK_SHARING_MODE_EXCLUSIVE = VkSharingMode.VK_SHARING_MODE_EXCLUSIVE; 1012 enum VK_SHARING_MODE_CONCURRENT = VkSharingMode.VK_SHARING_MODE_CONCURRENT; 1013 enum VK_SHARING_MODE_BEGIN_RANGE = VkSharingMode.VK_SHARING_MODE_BEGIN_RANGE; 1014 enum VK_SHARING_MODE_END_RANGE = VkSharingMode.VK_SHARING_MODE_END_RANGE; 1015 enum VK_SHARING_MODE_RANGE_SIZE = VkSharingMode.VK_SHARING_MODE_RANGE_SIZE; 1016 enum VK_SHARING_MODE_MAX_ENUM = VkSharingMode.VK_SHARING_MODE_MAX_ENUM; 1017 1018 enum VkImageLayout { 1019 VK_IMAGE_LAYOUT_UNDEFINED = 0, 1020 VK_IMAGE_LAYOUT_GENERAL = 1, 1021 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, 1022 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, 1023 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, 1024 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, 1025 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, 1026 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, 1027 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, 1028 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, 1029 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, 1030 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, 1031 VK_IMAGE_LAYOUT_RANGE_SIZE = ( VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1 ), 1032 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF 1033 } 1034 1035 // VkImageLayout global enums 1036 enum VK_IMAGE_LAYOUT_UNDEFINED = VkImageLayout.VK_IMAGE_LAYOUT_UNDEFINED; 1037 enum VK_IMAGE_LAYOUT_GENERAL = VkImageLayout.VK_IMAGE_LAYOUT_GENERAL; 1038 enum VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; 1039 enum VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; 1040 enum VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; 1041 enum VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; 1042 enum VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; 1043 enum VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; 1044 enum VK_IMAGE_LAYOUT_PREINITIALIZED = VkImageLayout.VK_IMAGE_LAYOUT_PREINITIALIZED; 1045 enum VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = VkImageLayout.VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; 1046 enum VK_IMAGE_LAYOUT_BEGIN_RANGE = VkImageLayout.VK_IMAGE_LAYOUT_BEGIN_RANGE; 1047 enum VK_IMAGE_LAYOUT_END_RANGE = VkImageLayout.VK_IMAGE_LAYOUT_END_RANGE; 1048 enum VK_IMAGE_LAYOUT_RANGE_SIZE = VkImageLayout.VK_IMAGE_LAYOUT_RANGE_SIZE; 1049 enum VK_IMAGE_LAYOUT_MAX_ENUM = VkImageLayout.VK_IMAGE_LAYOUT_MAX_ENUM; 1050 1051 enum VkImageViewType { 1052 VK_IMAGE_VIEW_TYPE_1D = 0, 1053 VK_IMAGE_VIEW_TYPE_2D = 1, 1054 VK_IMAGE_VIEW_TYPE_3D = 2, 1055 VK_IMAGE_VIEW_TYPE_CUBE = 3, 1056 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, 1057 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, 1058 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, 1059 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, 1060 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, 1061 VK_IMAGE_VIEW_TYPE_RANGE_SIZE = ( VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1 ), 1062 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF 1063 } 1064 1065 // VkImageViewType global enums 1066 enum VK_IMAGE_VIEW_TYPE_1D = VkImageViewType.VK_IMAGE_VIEW_TYPE_1D; 1067 enum VK_IMAGE_VIEW_TYPE_2D = VkImageViewType.VK_IMAGE_VIEW_TYPE_2D; 1068 enum VK_IMAGE_VIEW_TYPE_3D = VkImageViewType.VK_IMAGE_VIEW_TYPE_3D; 1069 enum VK_IMAGE_VIEW_TYPE_CUBE = VkImageViewType.VK_IMAGE_VIEW_TYPE_CUBE; 1070 enum VK_IMAGE_VIEW_TYPE_1D_ARRAY = VkImageViewType.VK_IMAGE_VIEW_TYPE_1D_ARRAY; 1071 enum VK_IMAGE_VIEW_TYPE_2D_ARRAY = VkImageViewType.VK_IMAGE_VIEW_TYPE_2D_ARRAY; 1072 enum VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = VkImageViewType.VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; 1073 enum VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VkImageViewType.VK_IMAGE_VIEW_TYPE_BEGIN_RANGE; 1074 enum VK_IMAGE_VIEW_TYPE_END_RANGE = VkImageViewType.VK_IMAGE_VIEW_TYPE_END_RANGE; 1075 enum VK_IMAGE_VIEW_TYPE_RANGE_SIZE = VkImageViewType.VK_IMAGE_VIEW_TYPE_RANGE_SIZE; 1076 enum VK_IMAGE_VIEW_TYPE_MAX_ENUM = VkImageViewType.VK_IMAGE_VIEW_TYPE_MAX_ENUM; 1077 1078 enum VkComponentSwizzle { 1079 VK_COMPONENT_SWIZZLE_IDENTITY = 0, 1080 VK_COMPONENT_SWIZZLE_ZERO = 1, 1081 VK_COMPONENT_SWIZZLE_ONE = 2, 1082 VK_COMPONENT_SWIZZLE_R = 3, 1083 VK_COMPONENT_SWIZZLE_G = 4, 1084 VK_COMPONENT_SWIZZLE_B = 5, 1085 VK_COMPONENT_SWIZZLE_A = 6, 1086 VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, 1087 VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, 1088 VK_COMPONENT_SWIZZLE_RANGE_SIZE = ( VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1 ), 1089 VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF 1090 } 1091 1092 // VkComponentSwizzle global enums 1093 enum VK_COMPONENT_SWIZZLE_IDENTITY = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_IDENTITY; 1094 enum VK_COMPONENT_SWIZZLE_ZERO = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_ZERO; 1095 enum VK_COMPONENT_SWIZZLE_ONE = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_ONE; 1096 enum VK_COMPONENT_SWIZZLE_R = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_R; 1097 enum VK_COMPONENT_SWIZZLE_G = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_G; 1098 enum VK_COMPONENT_SWIZZLE_B = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_B; 1099 enum VK_COMPONENT_SWIZZLE_A = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_A; 1100 enum VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_BEGIN_RANGE; 1101 enum VK_COMPONENT_SWIZZLE_END_RANGE = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_END_RANGE; 1102 enum VK_COMPONENT_SWIZZLE_RANGE_SIZE = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_RANGE_SIZE; 1103 enum VK_COMPONENT_SWIZZLE_MAX_ENUM = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_MAX_ENUM; 1104 1105 enum VkVertexInputRate { 1106 VK_VERTEX_INPUT_RATE_VERTEX = 0, 1107 VK_VERTEX_INPUT_RATE_INSTANCE = 1, 1108 VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, 1109 VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, 1110 VK_VERTEX_INPUT_RATE_RANGE_SIZE = ( VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1 ), 1111 VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF 1112 } 1113 1114 // VkVertexInputRate global enums 1115 enum VK_VERTEX_INPUT_RATE_VERTEX = VkVertexInputRate.VK_VERTEX_INPUT_RATE_VERTEX; 1116 enum VK_VERTEX_INPUT_RATE_INSTANCE = VkVertexInputRate.VK_VERTEX_INPUT_RATE_INSTANCE; 1117 enum VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VkVertexInputRate.VK_VERTEX_INPUT_RATE_BEGIN_RANGE; 1118 enum VK_VERTEX_INPUT_RATE_END_RANGE = VkVertexInputRate.VK_VERTEX_INPUT_RATE_END_RANGE; 1119 enum VK_VERTEX_INPUT_RATE_RANGE_SIZE = VkVertexInputRate.VK_VERTEX_INPUT_RATE_RANGE_SIZE; 1120 enum VK_VERTEX_INPUT_RATE_MAX_ENUM = VkVertexInputRate.VK_VERTEX_INPUT_RATE_MAX_ENUM; 1121 1122 enum VkPrimitiveTopology { 1123 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, 1124 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, 1125 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, 1126 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, 1127 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, 1128 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, 1129 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, 1130 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, 1131 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, 1132 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, 1133 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, 1134 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 1135 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, 1136 VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = ( VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1 ), 1137 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF 1138 } 1139 1140 // VkPrimitiveTopology global enums 1141 enum VK_PRIMITIVE_TOPOLOGY_POINT_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_POINT_LIST; 1142 enum VK_PRIMITIVE_TOPOLOGY_LINE_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_LIST; 1143 enum VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_STRIP; 1144 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; 1145 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; 1146 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN; 1147 enum VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY; 1148 enum VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY; 1149 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY; 1150 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY; 1151 enum VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; 1152 enum VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE; 1153 enum VK_PRIMITIVE_TOPOLOGY_END_RANGE = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_END_RANGE; 1154 enum VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE; 1155 enum VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_MAX_ENUM; 1156 1157 enum VkPolygonMode { 1158 VK_POLYGON_MODE_FILL = 0, 1159 VK_POLYGON_MODE_LINE = 1, 1160 VK_POLYGON_MODE_POINT = 2, 1161 VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, 1162 VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, 1163 VK_POLYGON_MODE_RANGE_SIZE = ( VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1 ), 1164 VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF 1165 } 1166 1167 // VkPolygonMode global enums 1168 enum VK_POLYGON_MODE_FILL = VkPolygonMode.VK_POLYGON_MODE_FILL; 1169 enum VK_POLYGON_MODE_LINE = VkPolygonMode.VK_POLYGON_MODE_LINE; 1170 enum VK_POLYGON_MODE_POINT = VkPolygonMode.VK_POLYGON_MODE_POINT; 1171 enum VK_POLYGON_MODE_BEGIN_RANGE = VkPolygonMode.VK_POLYGON_MODE_BEGIN_RANGE; 1172 enum VK_POLYGON_MODE_END_RANGE = VkPolygonMode.VK_POLYGON_MODE_END_RANGE; 1173 enum VK_POLYGON_MODE_RANGE_SIZE = VkPolygonMode.VK_POLYGON_MODE_RANGE_SIZE; 1174 enum VK_POLYGON_MODE_MAX_ENUM = VkPolygonMode.VK_POLYGON_MODE_MAX_ENUM; 1175 1176 enum VkFrontFace { 1177 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, 1178 VK_FRONT_FACE_CLOCKWISE = 1, 1179 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, 1180 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, 1181 VK_FRONT_FACE_RANGE_SIZE = ( VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1 ), 1182 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF 1183 } 1184 1185 // VkFrontFace global enums 1186 enum VK_FRONT_FACE_COUNTER_CLOCKWISE = VkFrontFace.VK_FRONT_FACE_COUNTER_CLOCKWISE; 1187 enum VK_FRONT_FACE_CLOCKWISE = VkFrontFace.VK_FRONT_FACE_CLOCKWISE; 1188 enum VK_FRONT_FACE_BEGIN_RANGE = VkFrontFace.VK_FRONT_FACE_BEGIN_RANGE; 1189 enum VK_FRONT_FACE_END_RANGE = VkFrontFace.VK_FRONT_FACE_END_RANGE; 1190 enum VK_FRONT_FACE_RANGE_SIZE = VkFrontFace.VK_FRONT_FACE_RANGE_SIZE; 1191 enum VK_FRONT_FACE_MAX_ENUM = VkFrontFace.VK_FRONT_FACE_MAX_ENUM; 1192 1193 enum VkCompareOp { 1194 VK_COMPARE_OP_NEVER = 0, 1195 VK_COMPARE_OP_LESS = 1, 1196 VK_COMPARE_OP_EQUAL = 2, 1197 VK_COMPARE_OP_LESS_OR_EQUAL = 3, 1198 VK_COMPARE_OP_GREATER = 4, 1199 VK_COMPARE_OP_NOT_EQUAL = 5, 1200 VK_COMPARE_OP_GREATER_OR_EQUAL = 6, 1201 VK_COMPARE_OP_ALWAYS = 7, 1202 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, 1203 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, 1204 VK_COMPARE_OP_RANGE_SIZE = ( VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1 ), 1205 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF 1206 } 1207 1208 // VkCompareOp global enums 1209 enum VK_COMPARE_OP_NEVER = VkCompareOp.VK_COMPARE_OP_NEVER; 1210 enum VK_COMPARE_OP_LESS = VkCompareOp.VK_COMPARE_OP_LESS; 1211 enum VK_COMPARE_OP_EQUAL = VkCompareOp.VK_COMPARE_OP_EQUAL; 1212 enum VK_COMPARE_OP_LESS_OR_EQUAL = VkCompareOp.VK_COMPARE_OP_LESS_OR_EQUAL; 1213 enum VK_COMPARE_OP_GREATER = VkCompareOp.VK_COMPARE_OP_GREATER; 1214 enum VK_COMPARE_OP_NOT_EQUAL = VkCompareOp.VK_COMPARE_OP_NOT_EQUAL; 1215 enum VK_COMPARE_OP_GREATER_OR_EQUAL = VkCompareOp.VK_COMPARE_OP_GREATER_OR_EQUAL; 1216 enum VK_COMPARE_OP_ALWAYS = VkCompareOp.VK_COMPARE_OP_ALWAYS; 1217 enum VK_COMPARE_OP_BEGIN_RANGE = VkCompareOp.VK_COMPARE_OP_BEGIN_RANGE; 1218 enum VK_COMPARE_OP_END_RANGE = VkCompareOp.VK_COMPARE_OP_END_RANGE; 1219 enum VK_COMPARE_OP_RANGE_SIZE = VkCompareOp.VK_COMPARE_OP_RANGE_SIZE; 1220 enum VK_COMPARE_OP_MAX_ENUM = VkCompareOp.VK_COMPARE_OP_MAX_ENUM; 1221 1222 enum VkStencilOp { 1223 VK_STENCIL_OP_KEEP = 0, 1224 VK_STENCIL_OP_ZERO = 1, 1225 VK_STENCIL_OP_REPLACE = 2, 1226 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, 1227 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, 1228 VK_STENCIL_OP_INVERT = 5, 1229 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, 1230 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, 1231 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, 1232 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, 1233 VK_STENCIL_OP_RANGE_SIZE = ( VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1 ), 1234 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF 1235 } 1236 1237 // VkStencilOp global enums 1238 enum VK_STENCIL_OP_KEEP = VkStencilOp.VK_STENCIL_OP_KEEP; 1239 enum VK_STENCIL_OP_ZERO = VkStencilOp.VK_STENCIL_OP_ZERO; 1240 enum VK_STENCIL_OP_REPLACE = VkStencilOp.VK_STENCIL_OP_REPLACE; 1241 enum VK_STENCIL_OP_INCREMENT_AND_CLAMP = VkStencilOp.VK_STENCIL_OP_INCREMENT_AND_CLAMP; 1242 enum VK_STENCIL_OP_DECREMENT_AND_CLAMP = VkStencilOp.VK_STENCIL_OP_DECREMENT_AND_CLAMP; 1243 enum VK_STENCIL_OP_INVERT = VkStencilOp.VK_STENCIL_OP_INVERT; 1244 enum VK_STENCIL_OP_INCREMENT_AND_WRAP = VkStencilOp.VK_STENCIL_OP_INCREMENT_AND_WRAP; 1245 enum VK_STENCIL_OP_DECREMENT_AND_WRAP = VkStencilOp.VK_STENCIL_OP_DECREMENT_AND_WRAP; 1246 enum VK_STENCIL_OP_BEGIN_RANGE = VkStencilOp.VK_STENCIL_OP_BEGIN_RANGE; 1247 enum VK_STENCIL_OP_END_RANGE = VkStencilOp.VK_STENCIL_OP_END_RANGE; 1248 enum VK_STENCIL_OP_RANGE_SIZE = VkStencilOp.VK_STENCIL_OP_RANGE_SIZE; 1249 enum VK_STENCIL_OP_MAX_ENUM = VkStencilOp.VK_STENCIL_OP_MAX_ENUM; 1250 1251 enum VkLogicOp { 1252 VK_LOGIC_OP_CLEAR = 0, 1253 VK_LOGIC_OP_AND = 1, 1254 VK_LOGIC_OP_AND_REVERSE = 2, 1255 VK_LOGIC_OP_COPY = 3, 1256 VK_LOGIC_OP_AND_INVERTED = 4, 1257 VK_LOGIC_OP_NO_OP = 5, 1258 VK_LOGIC_OP_XOR = 6, 1259 VK_LOGIC_OP_OR = 7, 1260 VK_LOGIC_OP_NOR = 8, 1261 VK_LOGIC_OP_EQUIVALENT = 9, 1262 VK_LOGIC_OP_INVERT = 10, 1263 VK_LOGIC_OP_OR_REVERSE = 11, 1264 VK_LOGIC_OP_COPY_INVERTED = 12, 1265 VK_LOGIC_OP_OR_INVERTED = 13, 1266 VK_LOGIC_OP_NAND = 14, 1267 VK_LOGIC_OP_SET = 15, 1268 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, 1269 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, 1270 VK_LOGIC_OP_RANGE_SIZE = ( VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1 ), 1271 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF 1272 } 1273 1274 // VkLogicOp global enums 1275 enum VK_LOGIC_OP_CLEAR = VkLogicOp.VK_LOGIC_OP_CLEAR; 1276 enum VK_LOGIC_OP_AND = VkLogicOp.VK_LOGIC_OP_AND; 1277 enum VK_LOGIC_OP_AND_REVERSE = VkLogicOp.VK_LOGIC_OP_AND_REVERSE; 1278 enum VK_LOGIC_OP_COPY = VkLogicOp.VK_LOGIC_OP_COPY; 1279 enum VK_LOGIC_OP_AND_INVERTED = VkLogicOp.VK_LOGIC_OP_AND_INVERTED; 1280 enum VK_LOGIC_OP_NO_OP = VkLogicOp.VK_LOGIC_OP_NO_OP; 1281 enum VK_LOGIC_OP_XOR = VkLogicOp.VK_LOGIC_OP_XOR; 1282 enum VK_LOGIC_OP_OR = VkLogicOp.VK_LOGIC_OP_OR; 1283 enum VK_LOGIC_OP_NOR = VkLogicOp.VK_LOGIC_OP_NOR; 1284 enum VK_LOGIC_OP_EQUIVALENT = VkLogicOp.VK_LOGIC_OP_EQUIVALENT; 1285 enum VK_LOGIC_OP_INVERT = VkLogicOp.VK_LOGIC_OP_INVERT; 1286 enum VK_LOGIC_OP_OR_REVERSE = VkLogicOp.VK_LOGIC_OP_OR_REVERSE; 1287 enum VK_LOGIC_OP_COPY_INVERTED = VkLogicOp.VK_LOGIC_OP_COPY_INVERTED; 1288 enum VK_LOGIC_OP_OR_INVERTED = VkLogicOp.VK_LOGIC_OP_OR_INVERTED; 1289 enum VK_LOGIC_OP_NAND = VkLogicOp.VK_LOGIC_OP_NAND; 1290 enum VK_LOGIC_OP_SET = VkLogicOp.VK_LOGIC_OP_SET; 1291 enum VK_LOGIC_OP_BEGIN_RANGE = VkLogicOp.VK_LOGIC_OP_BEGIN_RANGE; 1292 enum VK_LOGIC_OP_END_RANGE = VkLogicOp.VK_LOGIC_OP_END_RANGE; 1293 enum VK_LOGIC_OP_RANGE_SIZE = VkLogicOp.VK_LOGIC_OP_RANGE_SIZE; 1294 enum VK_LOGIC_OP_MAX_ENUM = VkLogicOp.VK_LOGIC_OP_MAX_ENUM; 1295 1296 enum VkBlendFactor { 1297 VK_BLEND_FACTOR_ZERO = 0, 1298 VK_BLEND_FACTOR_ONE = 1, 1299 VK_BLEND_FACTOR_SRC_COLOR = 2, 1300 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, 1301 VK_BLEND_FACTOR_DST_COLOR = 4, 1302 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, 1303 VK_BLEND_FACTOR_SRC_ALPHA = 6, 1304 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, 1305 VK_BLEND_FACTOR_DST_ALPHA = 8, 1306 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, 1307 VK_BLEND_FACTOR_CONSTANT_COLOR = 10, 1308 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, 1309 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, 1310 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, 1311 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, 1312 VK_BLEND_FACTOR_SRC1_COLOR = 15, 1313 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, 1314 VK_BLEND_FACTOR_SRC1_ALPHA = 17, 1315 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, 1316 VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, 1317 VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, 1318 VK_BLEND_FACTOR_RANGE_SIZE = ( VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1 ), 1319 VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF 1320 } 1321 1322 // VkBlendFactor global enums 1323 enum VK_BLEND_FACTOR_ZERO = VkBlendFactor.VK_BLEND_FACTOR_ZERO; 1324 enum VK_BLEND_FACTOR_ONE = VkBlendFactor.VK_BLEND_FACTOR_ONE; 1325 enum VK_BLEND_FACTOR_SRC_COLOR = VkBlendFactor.VK_BLEND_FACTOR_SRC_COLOR; 1326 enum VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR; 1327 enum VK_BLEND_FACTOR_DST_COLOR = VkBlendFactor.VK_BLEND_FACTOR_DST_COLOR; 1328 enum VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR; 1329 enum VK_BLEND_FACTOR_SRC_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_SRC_ALPHA; 1330 enum VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; 1331 enum VK_BLEND_FACTOR_DST_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_DST_ALPHA; 1332 enum VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA; 1333 enum VK_BLEND_FACTOR_CONSTANT_COLOR = VkBlendFactor.VK_BLEND_FACTOR_CONSTANT_COLOR; 1334 enum VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR; 1335 enum VK_BLEND_FACTOR_CONSTANT_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_CONSTANT_ALPHA; 1336 enum VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA; 1337 enum VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = VkBlendFactor.VK_BLEND_FACTOR_SRC_ALPHA_SATURATE; 1338 enum VK_BLEND_FACTOR_SRC1_COLOR = VkBlendFactor.VK_BLEND_FACTOR_SRC1_COLOR; 1339 enum VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR; 1340 enum VK_BLEND_FACTOR_SRC1_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_SRC1_ALPHA; 1341 enum VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA; 1342 enum VK_BLEND_FACTOR_BEGIN_RANGE = VkBlendFactor.VK_BLEND_FACTOR_BEGIN_RANGE; 1343 enum VK_BLEND_FACTOR_END_RANGE = VkBlendFactor.VK_BLEND_FACTOR_END_RANGE; 1344 enum VK_BLEND_FACTOR_RANGE_SIZE = VkBlendFactor.VK_BLEND_FACTOR_RANGE_SIZE; 1345 enum VK_BLEND_FACTOR_MAX_ENUM = VkBlendFactor.VK_BLEND_FACTOR_MAX_ENUM; 1346 1347 enum VkBlendOp { 1348 VK_BLEND_OP_ADD = 0, 1349 VK_BLEND_OP_SUBTRACT = 1, 1350 VK_BLEND_OP_REVERSE_SUBTRACT = 2, 1351 VK_BLEND_OP_MIN = 3, 1352 VK_BLEND_OP_MAX = 4, 1353 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, 1354 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, 1355 VK_BLEND_OP_RANGE_SIZE = ( VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1 ), 1356 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF 1357 } 1358 1359 // VkBlendOp global enums 1360 enum VK_BLEND_OP_ADD = VkBlendOp.VK_BLEND_OP_ADD; 1361 enum VK_BLEND_OP_SUBTRACT = VkBlendOp.VK_BLEND_OP_SUBTRACT; 1362 enum VK_BLEND_OP_REVERSE_SUBTRACT = VkBlendOp.VK_BLEND_OP_REVERSE_SUBTRACT; 1363 enum VK_BLEND_OP_MIN = VkBlendOp.VK_BLEND_OP_MIN; 1364 enum VK_BLEND_OP_MAX = VkBlendOp.VK_BLEND_OP_MAX; 1365 enum VK_BLEND_OP_BEGIN_RANGE = VkBlendOp.VK_BLEND_OP_BEGIN_RANGE; 1366 enum VK_BLEND_OP_END_RANGE = VkBlendOp.VK_BLEND_OP_END_RANGE; 1367 enum VK_BLEND_OP_RANGE_SIZE = VkBlendOp.VK_BLEND_OP_RANGE_SIZE; 1368 enum VK_BLEND_OP_MAX_ENUM = VkBlendOp.VK_BLEND_OP_MAX_ENUM; 1369 1370 enum VkDynamicState { 1371 VK_DYNAMIC_STATE_VIEWPORT = 0, 1372 VK_DYNAMIC_STATE_SCISSOR = 1, 1373 VK_DYNAMIC_STATE_LINE_WIDTH = 2, 1374 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, 1375 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, 1376 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, 1377 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, 1378 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, 1379 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, 1380 VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, 1381 VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, 1382 VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, 1383 VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, 1384 VK_DYNAMIC_STATE_RANGE_SIZE = ( VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1 ), 1385 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF 1386 } 1387 1388 // VkDynamicState global enums 1389 enum VK_DYNAMIC_STATE_VIEWPORT = VkDynamicState.VK_DYNAMIC_STATE_VIEWPORT; 1390 enum VK_DYNAMIC_STATE_SCISSOR = VkDynamicState.VK_DYNAMIC_STATE_SCISSOR; 1391 enum VK_DYNAMIC_STATE_LINE_WIDTH = VkDynamicState.VK_DYNAMIC_STATE_LINE_WIDTH; 1392 enum VK_DYNAMIC_STATE_DEPTH_BIAS = VkDynamicState.VK_DYNAMIC_STATE_DEPTH_BIAS; 1393 enum VK_DYNAMIC_STATE_BLEND_CONSTANTS = VkDynamicState.VK_DYNAMIC_STATE_BLEND_CONSTANTS; 1394 enum VK_DYNAMIC_STATE_DEPTH_BOUNDS = VkDynamicState.VK_DYNAMIC_STATE_DEPTH_BOUNDS; 1395 enum VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = VkDynamicState.VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK; 1396 enum VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = VkDynamicState.VK_DYNAMIC_STATE_STENCIL_WRITE_MASK; 1397 enum VK_DYNAMIC_STATE_STENCIL_REFERENCE = VkDynamicState.VK_DYNAMIC_STATE_STENCIL_REFERENCE; 1398 enum VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = VkDynamicState.VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV; 1399 enum VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = VkDynamicState.VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT; 1400 enum VK_DYNAMIC_STATE_BEGIN_RANGE = VkDynamicState.VK_DYNAMIC_STATE_BEGIN_RANGE; 1401 enum VK_DYNAMIC_STATE_END_RANGE = VkDynamicState.VK_DYNAMIC_STATE_END_RANGE; 1402 enum VK_DYNAMIC_STATE_RANGE_SIZE = VkDynamicState.VK_DYNAMIC_STATE_RANGE_SIZE; 1403 enum VK_DYNAMIC_STATE_MAX_ENUM = VkDynamicState.VK_DYNAMIC_STATE_MAX_ENUM; 1404 1405 enum VkFilter { 1406 VK_FILTER_NEAREST = 0, 1407 VK_FILTER_LINEAR = 1, 1408 VK_FILTER_CUBIC_IMG = 1000015000, 1409 VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, 1410 VK_FILTER_END_RANGE = VK_FILTER_LINEAR, 1411 VK_FILTER_RANGE_SIZE = ( VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1 ), 1412 VK_FILTER_MAX_ENUM = 0x7FFFFFFF 1413 } 1414 1415 // VkFilter global enums 1416 enum VK_FILTER_NEAREST = VkFilter.VK_FILTER_NEAREST; 1417 enum VK_FILTER_LINEAR = VkFilter.VK_FILTER_LINEAR; 1418 enum VK_FILTER_CUBIC_IMG = VkFilter.VK_FILTER_CUBIC_IMG; 1419 enum VK_FILTER_BEGIN_RANGE = VkFilter.VK_FILTER_BEGIN_RANGE; 1420 enum VK_FILTER_END_RANGE = VkFilter.VK_FILTER_END_RANGE; 1421 enum VK_FILTER_RANGE_SIZE = VkFilter.VK_FILTER_RANGE_SIZE; 1422 enum VK_FILTER_MAX_ENUM = VkFilter.VK_FILTER_MAX_ENUM; 1423 1424 enum VkSamplerMipmapMode { 1425 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, 1426 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, 1427 VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, 1428 VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, 1429 VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = ( VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1 ), 1430 VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF 1431 } 1432 1433 // VkSamplerMipmapMode global enums 1434 enum VK_SAMPLER_MIPMAP_MODE_NEAREST = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_NEAREST; 1435 enum VK_SAMPLER_MIPMAP_MODE_LINEAR = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_LINEAR; 1436 enum VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE; 1437 enum VK_SAMPLER_MIPMAP_MODE_END_RANGE = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_END_RANGE; 1438 enum VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE; 1439 enum VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_MAX_ENUM; 1440 1441 enum VkSamplerAddressMode { 1442 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, 1443 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, 1444 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, 1445 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, 1446 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, 1447 VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, 1448 VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, 1449 VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = ( VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1 ), 1450 VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF 1451 } 1452 1453 // VkSamplerAddressMode global enums 1454 enum VK_SAMPLER_ADDRESS_MODE_REPEAT = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_REPEAT; 1455 enum VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; 1456 enum VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; 1457 enum VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; 1458 enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; 1459 enum VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE; 1460 enum VK_SAMPLER_ADDRESS_MODE_END_RANGE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_END_RANGE; 1461 enum VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE; 1462 enum VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_MAX_ENUM; 1463 1464 enum VkBorderColor { 1465 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, 1466 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, 1467 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, 1468 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, 1469 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, 1470 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, 1471 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, 1472 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, 1473 VK_BORDER_COLOR_RANGE_SIZE = ( VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1 ), 1474 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF 1475 } 1476 1477 // VkBorderColor global enums 1478 enum VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = VkBorderColor.VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK; 1479 enum VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = VkBorderColor.VK_BORDER_COLOR_INT_TRANSPARENT_BLACK; 1480 enum VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = VkBorderColor.VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK; 1481 enum VK_BORDER_COLOR_INT_OPAQUE_BLACK = VkBorderColor.VK_BORDER_COLOR_INT_OPAQUE_BLACK; 1482 enum VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = VkBorderColor.VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; 1483 enum VK_BORDER_COLOR_INT_OPAQUE_WHITE = VkBorderColor.VK_BORDER_COLOR_INT_OPAQUE_WHITE; 1484 enum VK_BORDER_COLOR_BEGIN_RANGE = VkBorderColor.VK_BORDER_COLOR_BEGIN_RANGE; 1485 enum VK_BORDER_COLOR_END_RANGE = VkBorderColor.VK_BORDER_COLOR_END_RANGE; 1486 enum VK_BORDER_COLOR_RANGE_SIZE = VkBorderColor.VK_BORDER_COLOR_RANGE_SIZE; 1487 enum VK_BORDER_COLOR_MAX_ENUM = VkBorderColor.VK_BORDER_COLOR_MAX_ENUM; 1488 1489 enum VkDescriptorType { 1490 VK_DESCRIPTOR_TYPE_SAMPLER = 0, 1491 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, 1492 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, 1493 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, 1494 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, 1495 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, 1496 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, 1497 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, 1498 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, 1499 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, 1500 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, 1501 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, 1502 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1503 VK_DESCRIPTOR_TYPE_RANGE_SIZE = ( VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1 ), 1504 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF 1505 } 1506 1507 // VkDescriptorType global enums 1508 enum VK_DESCRIPTOR_TYPE_SAMPLER = VkDescriptorType.VK_DESCRIPTOR_TYPE_SAMPLER; 1509 enum VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = VkDescriptorType.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; 1510 enum VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = VkDescriptorType.VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE; 1511 enum VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; 1512 enum VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; 1513 enum VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; 1514 enum VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; 1515 enum VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; 1516 enum VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; 1517 enum VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; 1518 enum VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = VkDescriptorType.VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; 1519 enum VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VkDescriptorType.VK_DESCRIPTOR_TYPE_BEGIN_RANGE; 1520 enum VK_DESCRIPTOR_TYPE_END_RANGE = VkDescriptorType.VK_DESCRIPTOR_TYPE_END_RANGE; 1521 enum VK_DESCRIPTOR_TYPE_RANGE_SIZE = VkDescriptorType.VK_DESCRIPTOR_TYPE_RANGE_SIZE; 1522 enum VK_DESCRIPTOR_TYPE_MAX_ENUM = VkDescriptorType.VK_DESCRIPTOR_TYPE_MAX_ENUM; 1523 1524 enum VkAttachmentLoadOp { 1525 VK_ATTACHMENT_LOAD_OP_LOAD = 0, 1526 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, 1527 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, 1528 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, 1529 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, 1530 VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = ( VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1 ), 1531 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF 1532 } 1533 1534 // VkAttachmentLoadOp global enums 1535 enum VK_ATTACHMENT_LOAD_OP_LOAD = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_LOAD; 1536 enum VK_ATTACHMENT_LOAD_OP_CLEAR = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_CLEAR; 1537 enum VK_ATTACHMENT_LOAD_OP_DONT_CARE = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_DONT_CARE; 1538 enum VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE; 1539 enum VK_ATTACHMENT_LOAD_OP_END_RANGE = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_END_RANGE; 1540 enum VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_RANGE_SIZE; 1541 enum VK_ATTACHMENT_LOAD_OP_MAX_ENUM = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_MAX_ENUM; 1542 1543 enum VkAttachmentStoreOp { 1544 VK_ATTACHMENT_STORE_OP_STORE = 0, 1545 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, 1546 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, 1547 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, 1548 VK_ATTACHMENT_STORE_OP_RANGE_SIZE = ( VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1 ), 1549 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF 1550 } 1551 1552 // VkAttachmentStoreOp global enums 1553 enum VK_ATTACHMENT_STORE_OP_STORE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_STORE; 1554 enum VK_ATTACHMENT_STORE_OP_DONT_CARE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_DONT_CARE; 1555 enum VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_BEGIN_RANGE; 1556 enum VK_ATTACHMENT_STORE_OP_END_RANGE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_END_RANGE; 1557 enum VK_ATTACHMENT_STORE_OP_RANGE_SIZE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_RANGE_SIZE; 1558 enum VK_ATTACHMENT_STORE_OP_MAX_ENUM = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_MAX_ENUM; 1559 1560 enum VkPipelineBindPoint { 1561 VK_PIPELINE_BIND_POINT_GRAPHICS = 0, 1562 VK_PIPELINE_BIND_POINT_COMPUTE = 1, 1563 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, 1564 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, 1565 VK_PIPELINE_BIND_POINT_RANGE_SIZE = ( VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1 ), 1566 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF 1567 } 1568 1569 // VkPipelineBindPoint global enums 1570 enum VK_PIPELINE_BIND_POINT_GRAPHICS = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_GRAPHICS; 1571 enum VK_PIPELINE_BIND_POINT_COMPUTE = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_COMPUTE; 1572 enum VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_BEGIN_RANGE; 1573 enum VK_PIPELINE_BIND_POINT_END_RANGE = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_END_RANGE; 1574 enum VK_PIPELINE_BIND_POINT_RANGE_SIZE = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_RANGE_SIZE; 1575 enum VK_PIPELINE_BIND_POINT_MAX_ENUM = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_MAX_ENUM; 1576 1577 enum VkCommandBufferLevel { 1578 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, 1579 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, 1580 VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1581 VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, 1582 VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = ( VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1 ), 1583 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF 1584 } 1585 1586 // VkCommandBufferLevel global enums 1587 enum VK_COMMAND_BUFFER_LEVEL_PRIMARY = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_PRIMARY; 1588 enum VK_COMMAND_BUFFER_LEVEL_SECONDARY = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_SECONDARY; 1589 enum VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE; 1590 enum VK_COMMAND_BUFFER_LEVEL_END_RANGE = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_END_RANGE; 1591 enum VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE; 1592 enum VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_MAX_ENUM; 1593 1594 enum VkIndexType { 1595 VK_INDEX_TYPE_UINT16 = 0, 1596 VK_INDEX_TYPE_UINT32 = 1, 1597 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, 1598 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, 1599 VK_INDEX_TYPE_RANGE_SIZE = ( VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1 ), 1600 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF 1601 } 1602 1603 // VkIndexType global enums 1604 enum VK_INDEX_TYPE_UINT16 = VkIndexType.VK_INDEX_TYPE_UINT16; 1605 enum VK_INDEX_TYPE_UINT32 = VkIndexType.VK_INDEX_TYPE_UINT32; 1606 enum VK_INDEX_TYPE_BEGIN_RANGE = VkIndexType.VK_INDEX_TYPE_BEGIN_RANGE; 1607 enum VK_INDEX_TYPE_END_RANGE = VkIndexType.VK_INDEX_TYPE_END_RANGE; 1608 enum VK_INDEX_TYPE_RANGE_SIZE = VkIndexType.VK_INDEX_TYPE_RANGE_SIZE; 1609 enum VK_INDEX_TYPE_MAX_ENUM = VkIndexType.VK_INDEX_TYPE_MAX_ENUM; 1610 1611 enum VkSubpassContents { 1612 VK_SUBPASS_CONTENTS_INLINE = 0, 1613 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, 1614 VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, 1615 VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, 1616 VK_SUBPASS_CONTENTS_RANGE_SIZE = ( VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1 ), 1617 VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF 1618 } 1619 1620 // VkSubpassContents global enums 1621 enum VK_SUBPASS_CONTENTS_INLINE = VkSubpassContents.VK_SUBPASS_CONTENTS_INLINE; 1622 enum VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = VkSubpassContents.VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS; 1623 enum VK_SUBPASS_CONTENTS_BEGIN_RANGE = VkSubpassContents.VK_SUBPASS_CONTENTS_BEGIN_RANGE; 1624 enum VK_SUBPASS_CONTENTS_END_RANGE = VkSubpassContents.VK_SUBPASS_CONTENTS_END_RANGE; 1625 enum VK_SUBPASS_CONTENTS_RANGE_SIZE = VkSubpassContents.VK_SUBPASS_CONTENTS_RANGE_SIZE; 1626 enum VK_SUBPASS_CONTENTS_MAX_ENUM = VkSubpassContents.VK_SUBPASS_CONTENTS_MAX_ENUM; 1627 1628 alias VkInstanceCreateFlags = VkFlags; 1629 1630 enum VkFormatFeatureFlagBits { 1631 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, 1632 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, 1633 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, 1634 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, 1635 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, 1636 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, 1637 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, 1638 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, 1639 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, 1640 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, 1641 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, 1642 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, 1643 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, 1644 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, 1645 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000, 1646 VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000, 1647 VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1648 } 1649 1650 // VkFormatFeatureFlagBits global enums 1651 enum VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; 1652 enum VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; 1653 enum VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT; 1654 enum VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT; 1655 enum VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT; 1656 enum VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT; 1657 enum VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT; 1658 enum VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; 1659 enum VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT; 1660 enum VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; 1661 enum VK_FORMAT_FEATURE_BLIT_SRC_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_BLIT_SRC_BIT; 1662 enum VK_FORMAT_FEATURE_BLIT_DST_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_BLIT_DST_BIT; 1663 enum VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT; 1664 enum VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG; 1665 enum VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR; 1666 enum VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR; 1667 enum VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM; 1668 alias VkFormatFeatureFlags = VkFlags; 1669 1670 enum VkImageUsageFlagBits { 1671 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, 1672 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, 1673 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, 1674 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, 1675 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, 1676 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, 1677 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, 1678 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, 1679 VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1680 } 1681 1682 // VkImageUsageFlagBits global enums 1683 enum VK_IMAGE_USAGE_TRANSFER_SRC_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_TRANSFER_SRC_BIT; 1684 enum VK_IMAGE_USAGE_TRANSFER_DST_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_TRANSFER_DST_BIT; 1685 enum VK_IMAGE_USAGE_SAMPLED_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_SAMPLED_BIT; 1686 enum VK_IMAGE_USAGE_STORAGE_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_STORAGE_BIT; 1687 enum VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; 1688 enum VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; 1689 enum VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; 1690 enum VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; 1691 enum VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = VkImageUsageFlagBits.VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM; 1692 alias VkImageUsageFlags = VkFlags; 1693 1694 enum VkImageCreateFlagBits { 1695 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, 1696 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 1697 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 1698 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, 1699 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, 1700 VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040, 1701 VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020, 1702 VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1703 } 1704 1705 // VkImageCreateFlagBits global enums 1706 enum VK_IMAGE_CREATE_SPARSE_BINDING_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_SPARSE_BINDING_BIT; 1707 enum VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT; 1708 enum VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_SPARSE_ALIASED_BIT; 1709 enum VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; 1710 enum VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; 1711 enum VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = VkImageCreateFlagBits.VK_IMAGE_CREATE_BIND_SFR_BIT_KHX; 1712 enum VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VkImageCreateFlagBits.VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR; 1713 enum VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = VkImageCreateFlagBits.VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM; 1714 alias VkImageCreateFlags = VkFlags; 1715 1716 enum VkSampleCountFlagBits { 1717 VK_SAMPLE_COUNT_1_BIT = 0x00000001, 1718 VK_SAMPLE_COUNT_2_BIT = 0x00000002, 1719 VK_SAMPLE_COUNT_4_BIT = 0x00000004, 1720 VK_SAMPLE_COUNT_8_BIT = 0x00000008, 1721 VK_SAMPLE_COUNT_16_BIT = 0x00000010, 1722 VK_SAMPLE_COUNT_32_BIT = 0x00000020, 1723 VK_SAMPLE_COUNT_64_BIT = 0x00000040, 1724 VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1725 } 1726 1727 // VkSampleCountFlagBits global enums 1728 enum VK_SAMPLE_COUNT_1_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_1_BIT; 1729 enum VK_SAMPLE_COUNT_2_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_2_BIT; 1730 enum VK_SAMPLE_COUNT_4_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_4_BIT; 1731 enum VK_SAMPLE_COUNT_8_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_8_BIT; 1732 enum VK_SAMPLE_COUNT_16_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_16_BIT; 1733 enum VK_SAMPLE_COUNT_32_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_32_BIT; 1734 enum VK_SAMPLE_COUNT_64_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_64_BIT; 1735 enum VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = VkSampleCountFlagBits.VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM; 1736 alias VkSampleCountFlags = VkFlags; 1737 1738 enum VkQueueFlagBits { 1739 VK_QUEUE_GRAPHICS_BIT = 0x00000001, 1740 VK_QUEUE_COMPUTE_BIT = 0x00000002, 1741 VK_QUEUE_TRANSFER_BIT = 0x00000004, 1742 VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, 1743 VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1744 } 1745 1746 // VkQueueFlagBits global enums 1747 enum VK_QUEUE_GRAPHICS_BIT = VkQueueFlagBits.VK_QUEUE_GRAPHICS_BIT; 1748 enum VK_QUEUE_COMPUTE_BIT = VkQueueFlagBits.VK_QUEUE_COMPUTE_BIT; 1749 enum VK_QUEUE_TRANSFER_BIT = VkQueueFlagBits.VK_QUEUE_TRANSFER_BIT; 1750 enum VK_QUEUE_SPARSE_BINDING_BIT = VkQueueFlagBits.VK_QUEUE_SPARSE_BINDING_BIT; 1751 enum VK_QUEUE_FLAG_BITS_MAX_ENUM = VkQueueFlagBits.VK_QUEUE_FLAG_BITS_MAX_ENUM; 1752 alias VkQueueFlags = VkFlags; 1753 1754 enum VkMemoryPropertyFlagBits { 1755 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, 1756 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, 1757 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, 1758 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, 1759 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, 1760 VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1761 } 1762 1763 // VkMemoryPropertyFlagBits global enums 1764 enum VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; 1765 enum VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; 1766 enum VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; 1767 enum VK_MEMORY_PROPERTY_HOST_CACHED_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_CACHED_BIT; 1768 enum VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT; 1769 enum VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM; 1770 alias VkMemoryPropertyFlags = VkFlags; 1771 1772 enum VkMemoryHeapFlagBits { 1773 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, 1774 VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002, 1775 VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1776 } 1777 1778 // VkMemoryHeapFlagBits global enums 1779 enum VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = VkMemoryHeapFlagBits.VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; 1780 enum VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = VkMemoryHeapFlagBits.VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX; 1781 enum VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = VkMemoryHeapFlagBits.VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM; 1782 alias VkMemoryHeapFlags = VkFlags; 1783 alias VkDeviceCreateFlags = VkFlags; 1784 alias VkDeviceQueueCreateFlags = VkFlags; 1785 1786 enum VkPipelineStageFlagBits { 1787 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, 1788 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, 1789 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, 1790 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, 1791 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, 1792 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, 1793 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, 1794 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, 1795 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, 1796 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, 1797 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, 1798 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, 1799 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, 1800 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, 1801 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, 1802 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, 1803 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, 1804 VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000, 1805 VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1806 } 1807 1808 // VkPipelineStageFlagBits global enums 1809 enum VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; 1810 enum VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT; 1811 enum VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; 1812 enum VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; 1813 enum VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT; 1814 enum VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT; 1815 enum VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT; 1816 enum VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; 1817 enum VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; 1818 enum VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; 1819 enum VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; 1820 enum VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; 1821 enum VK_PIPELINE_STAGE_TRANSFER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TRANSFER_BIT; 1822 enum VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; 1823 enum VK_PIPELINE_STAGE_HOST_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_HOST_BIT; 1824 enum VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT; 1825 enum VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; 1826 enum VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX; 1827 enum VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM; 1828 alias VkPipelineStageFlags = VkFlags; 1829 alias VkMemoryMapFlags = VkFlags; 1830 1831 enum VkImageAspectFlagBits { 1832 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, 1833 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, 1834 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, 1835 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, 1836 VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1837 } 1838 1839 // VkImageAspectFlagBits global enums 1840 enum VK_IMAGE_ASPECT_COLOR_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_COLOR_BIT; 1841 enum VK_IMAGE_ASPECT_DEPTH_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_DEPTH_BIT; 1842 enum VK_IMAGE_ASPECT_STENCIL_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_STENCIL_BIT; 1843 enum VK_IMAGE_ASPECT_METADATA_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_METADATA_BIT; 1844 enum VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = VkImageAspectFlagBits.VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM; 1845 alias VkImageAspectFlags = VkFlags; 1846 1847 enum VkSparseImageFormatFlagBits { 1848 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, 1849 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, 1850 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, 1851 VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1852 } 1853 1854 // VkSparseImageFormatFlagBits global enums 1855 enum VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; 1856 enum VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT; 1857 enum VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT; 1858 enum VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM; 1859 alias VkSparseImageFormatFlags = VkFlags; 1860 1861 enum VkSparseMemoryBindFlagBits { 1862 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, 1863 VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1864 } 1865 1866 // VkSparseMemoryBindFlagBits global enums 1867 enum VK_SPARSE_MEMORY_BIND_METADATA_BIT = VkSparseMemoryBindFlagBits.VK_SPARSE_MEMORY_BIND_METADATA_BIT; 1868 enum VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = VkSparseMemoryBindFlagBits.VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM; 1869 alias VkSparseMemoryBindFlags = VkFlags; 1870 1871 enum VkFenceCreateFlagBits { 1872 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 1873 VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1874 } 1875 1876 // VkFenceCreateFlagBits global enums 1877 enum VK_FENCE_CREATE_SIGNALED_BIT = VkFenceCreateFlagBits.VK_FENCE_CREATE_SIGNALED_BIT; 1878 enum VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = VkFenceCreateFlagBits.VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM; 1879 alias VkFenceCreateFlags = VkFlags; 1880 alias VkSemaphoreCreateFlags = VkFlags; 1881 alias VkEventCreateFlags = VkFlags; 1882 alias VkQueryPoolCreateFlags = VkFlags; 1883 1884 enum VkQueryPipelineStatisticFlagBits { 1885 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, 1886 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, 1887 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, 1888 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, 1889 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, 1890 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, 1891 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, 1892 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, 1893 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, 1894 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, 1895 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, 1896 VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1897 } 1898 1899 // VkQueryPipelineStatisticFlagBits global enums 1900 enum VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT; 1901 enum VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT; 1902 enum VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT; 1903 enum VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT; 1904 enum VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT; 1905 enum VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT; 1906 enum VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT; 1907 enum VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT; 1908 enum VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT; 1909 enum VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT; 1910 enum VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT; 1911 enum VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM; 1912 alias VkQueryPipelineStatisticFlags = VkFlags; 1913 1914 enum VkQueryResultFlagBits { 1915 VK_QUERY_RESULT_64_BIT = 0x00000001, 1916 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, 1917 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, 1918 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, 1919 VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1920 } 1921 1922 // VkQueryResultFlagBits global enums 1923 enum VK_QUERY_RESULT_64_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_64_BIT; 1924 enum VK_QUERY_RESULT_WAIT_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_WAIT_BIT; 1925 enum VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_WITH_AVAILABILITY_BIT; 1926 enum VK_QUERY_RESULT_PARTIAL_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_PARTIAL_BIT; 1927 enum VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = VkQueryResultFlagBits.VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM; 1928 alias VkQueryResultFlags = VkFlags; 1929 1930 enum VkBufferCreateFlagBits { 1931 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, 1932 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 1933 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 1934 VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1935 } 1936 1937 // VkBufferCreateFlagBits global enums 1938 enum VK_BUFFER_CREATE_SPARSE_BINDING_BIT = VkBufferCreateFlagBits.VK_BUFFER_CREATE_SPARSE_BINDING_BIT; 1939 enum VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = VkBufferCreateFlagBits.VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT; 1940 enum VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = VkBufferCreateFlagBits.VK_BUFFER_CREATE_SPARSE_ALIASED_BIT; 1941 enum VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = VkBufferCreateFlagBits.VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM; 1942 alias VkBufferCreateFlags = VkFlags; 1943 1944 enum VkBufferUsageFlagBits { 1945 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, 1946 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, 1947 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, 1948 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, 1949 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, 1950 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, 1951 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, 1952 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, 1953 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, 1954 VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1955 } 1956 1957 // VkBufferUsageFlagBits global enums 1958 enum VK_BUFFER_USAGE_TRANSFER_SRC_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_TRANSFER_SRC_BIT; 1959 enum VK_BUFFER_USAGE_TRANSFER_DST_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_TRANSFER_DST_BIT; 1960 enum VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT; 1961 enum VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT; 1962 enum VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; 1963 enum VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; 1964 enum VK_BUFFER_USAGE_INDEX_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_INDEX_BUFFER_BIT; 1965 enum VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; 1966 enum VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; 1967 enum VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = VkBufferUsageFlagBits.VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM; 1968 alias VkBufferUsageFlags = VkFlags; 1969 alias VkBufferViewCreateFlags = VkFlags; 1970 alias VkImageViewCreateFlags = VkFlags; 1971 alias VkShaderModuleCreateFlags = VkFlags; 1972 alias VkPipelineCacheCreateFlags = VkFlags; 1973 1974 enum VkPipelineCreateFlagBits { 1975 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 1976 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, 1977 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, 1978 VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008, 1979 VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010, 1980 VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1981 } 1982 1983 // VkPipelineCreateFlagBits global enums 1984 enum VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT; 1985 enum VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT; 1986 enum VK_PIPELINE_CREATE_DERIVATIVE_BIT = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_DERIVATIVE_BIT; 1987 enum VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX; 1988 enum VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_DISPATCH_BASE_KHX; 1989 enum VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM; 1990 alias VkPipelineCreateFlags = VkFlags; 1991 alias VkPipelineShaderStageCreateFlags = VkFlags; 1992 1993 enum VkShaderStageFlagBits { 1994 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 1995 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, 1996 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, 1997 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 1998 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 1999 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 2000 VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, 2001 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 2002 VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2003 } 2004 2005 // VkShaderStageFlagBits global enums 2006 enum VK_SHADER_STAGE_VERTEX_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_VERTEX_BIT; 2007 enum VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; 2008 enum VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; 2009 enum VK_SHADER_STAGE_GEOMETRY_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_GEOMETRY_BIT; 2010 enum VK_SHADER_STAGE_FRAGMENT_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_FRAGMENT_BIT; 2011 enum VK_SHADER_STAGE_COMPUTE_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_COMPUTE_BIT; 2012 enum VK_SHADER_STAGE_ALL_GRAPHICS = VkShaderStageFlagBits.VK_SHADER_STAGE_ALL_GRAPHICS; 2013 enum VK_SHADER_STAGE_ALL = VkShaderStageFlagBits.VK_SHADER_STAGE_ALL; 2014 enum VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = VkShaderStageFlagBits.VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM; 2015 alias VkPipelineVertexInputStateCreateFlags = VkFlags; 2016 alias VkPipelineInputAssemblyStateCreateFlags = VkFlags; 2017 alias VkPipelineTessellationStateCreateFlags = VkFlags; 2018 alias VkPipelineViewportStateCreateFlags = VkFlags; 2019 alias VkPipelineRasterizationStateCreateFlags = VkFlags; 2020 2021 enum VkCullModeFlagBits { 2022 VK_CULL_MODE_NONE = 0, 2023 VK_CULL_MODE_FRONT_BIT = 0x00000001, 2024 VK_CULL_MODE_BACK_BIT = 0x00000002, 2025 VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, 2026 VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2027 } 2028 2029 // VkCullModeFlagBits global enums 2030 enum VK_CULL_MODE_NONE = VkCullModeFlagBits.VK_CULL_MODE_NONE; 2031 enum VK_CULL_MODE_FRONT_BIT = VkCullModeFlagBits.VK_CULL_MODE_FRONT_BIT; 2032 enum VK_CULL_MODE_BACK_BIT = VkCullModeFlagBits.VK_CULL_MODE_BACK_BIT; 2033 enum VK_CULL_MODE_FRONT_AND_BACK = VkCullModeFlagBits.VK_CULL_MODE_FRONT_AND_BACK; 2034 enum VK_CULL_MODE_FLAG_BITS_MAX_ENUM = VkCullModeFlagBits.VK_CULL_MODE_FLAG_BITS_MAX_ENUM; 2035 alias VkCullModeFlags = VkFlags; 2036 alias VkPipelineMultisampleStateCreateFlags = VkFlags; 2037 alias VkPipelineDepthStencilStateCreateFlags = VkFlags; 2038 alias VkPipelineColorBlendStateCreateFlags = VkFlags; 2039 2040 enum VkColorComponentFlagBits { 2041 VK_COLOR_COMPONENT_R_BIT = 0x00000001, 2042 VK_COLOR_COMPONENT_G_BIT = 0x00000002, 2043 VK_COLOR_COMPONENT_B_BIT = 0x00000004, 2044 VK_COLOR_COMPONENT_A_BIT = 0x00000008, 2045 VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2046 } 2047 2048 // VkColorComponentFlagBits global enums 2049 enum VK_COLOR_COMPONENT_R_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_R_BIT; 2050 enum VK_COLOR_COMPONENT_G_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_G_BIT; 2051 enum VK_COLOR_COMPONENT_B_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_B_BIT; 2052 enum VK_COLOR_COMPONENT_A_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_A_BIT; 2053 enum VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = VkColorComponentFlagBits.VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM; 2054 alias VkColorComponentFlags = VkFlags; 2055 alias VkPipelineDynamicStateCreateFlags = VkFlags; 2056 alias VkPipelineLayoutCreateFlags = VkFlags; 2057 alias VkShaderStageFlags = VkFlags; 2058 alias VkSamplerCreateFlags = VkFlags; 2059 2060 enum VkDescriptorSetLayoutCreateFlagBits { 2061 VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, 2062 VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2063 } 2064 2065 // VkDescriptorSetLayoutCreateFlagBits global enums 2066 enum VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = VkDescriptorSetLayoutCreateFlagBits.VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR; 2067 enum VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = VkDescriptorSetLayoutCreateFlagBits.VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM; 2068 alias VkDescriptorSetLayoutCreateFlags = VkFlags; 2069 2070 enum VkDescriptorPoolCreateFlagBits { 2071 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, 2072 VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2073 } 2074 2075 // VkDescriptorPoolCreateFlagBits global enums 2076 enum VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = VkDescriptorPoolCreateFlagBits.VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; 2077 enum VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = VkDescriptorPoolCreateFlagBits.VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM; 2078 alias VkDescriptorPoolCreateFlags = VkFlags; 2079 alias VkDescriptorPoolResetFlags = VkFlags; 2080 alias VkFramebufferCreateFlags = VkFlags; 2081 alias VkRenderPassCreateFlags = VkFlags; 2082 2083 enum VkAttachmentDescriptionFlagBits { 2084 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, 2085 VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2086 } 2087 2088 // VkAttachmentDescriptionFlagBits global enums 2089 enum VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = VkAttachmentDescriptionFlagBits.VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT; 2090 enum VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = VkAttachmentDescriptionFlagBits.VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM; 2091 alias VkAttachmentDescriptionFlags = VkFlags; 2092 2093 enum VkSubpassDescriptionFlagBits { 2094 VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, 2095 VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, 2096 VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2097 } 2098 2099 // VkSubpassDescriptionFlagBits global enums 2100 enum VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = VkSubpassDescriptionFlagBits.VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX; 2101 enum VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = VkSubpassDescriptionFlagBits.VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX; 2102 enum VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = VkSubpassDescriptionFlagBits.VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM; 2103 alias VkSubpassDescriptionFlags = VkFlags; 2104 2105 enum VkAccessFlagBits { 2106 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, 2107 VK_ACCESS_INDEX_READ_BIT = 0x00000002, 2108 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, 2109 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, 2110 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, 2111 VK_ACCESS_SHADER_READ_BIT = 0x00000020, 2112 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, 2113 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, 2114 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, 2115 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, 2116 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, 2117 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, 2118 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, 2119 VK_ACCESS_HOST_READ_BIT = 0x00002000, 2120 VK_ACCESS_HOST_WRITE_BIT = 0x00004000, 2121 VK_ACCESS_MEMORY_READ_BIT = 0x00008000, 2122 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, 2123 VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, 2124 VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, 2125 VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2126 } 2127 2128 // VkAccessFlagBits global enums 2129 enum VK_ACCESS_INDIRECT_COMMAND_READ_BIT = VkAccessFlagBits.VK_ACCESS_INDIRECT_COMMAND_READ_BIT; 2130 enum VK_ACCESS_INDEX_READ_BIT = VkAccessFlagBits.VK_ACCESS_INDEX_READ_BIT; 2131 enum VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = VkAccessFlagBits.VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT; 2132 enum VK_ACCESS_UNIFORM_READ_BIT = VkAccessFlagBits.VK_ACCESS_UNIFORM_READ_BIT; 2133 enum VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = VkAccessFlagBits.VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; 2134 enum VK_ACCESS_SHADER_READ_BIT = VkAccessFlagBits.VK_ACCESS_SHADER_READ_BIT; 2135 enum VK_ACCESS_SHADER_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_SHADER_WRITE_BIT; 2136 enum VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = VkAccessFlagBits.VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; 2137 enum VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; 2138 enum VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = VkAccessFlagBits.VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; 2139 enum VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; 2140 enum VK_ACCESS_TRANSFER_READ_BIT = VkAccessFlagBits.VK_ACCESS_TRANSFER_READ_BIT; 2141 enum VK_ACCESS_TRANSFER_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_TRANSFER_WRITE_BIT; 2142 enum VK_ACCESS_HOST_READ_BIT = VkAccessFlagBits.VK_ACCESS_HOST_READ_BIT; 2143 enum VK_ACCESS_HOST_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_HOST_WRITE_BIT; 2144 enum VK_ACCESS_MEMORY_READ_BIT = VkAccessFlagBits.VK_ACCESS_MEMORY_READ_BIT; 2145 enum VK_ACCESS_MEMORY_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_MEMORY_WRITE_BIT; 2146 enum VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = VkAccessFlagBits.VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX; 2147 enum VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = VkAccessFlagBits.VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX; 2148 enum VK_ACCESS_FLAG_BITS_MAX_ENUM = VkAccessFlagBits.VK_ACCESS_FLAG_BITS_MAX_ENUM; 2149 alias VkAccessFlags = VkFlags; 2150 2151 enum VkDependencyFlagBits { 2152 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, 2153 VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002, 2154 VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004, 2155 VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2156 } 2157 2158 // VkDependencyFlagBits global enums 2159 enum VK_DEPENDENCY_BY_REGION_BIT = VkDependencyFlagBits.VK_DEPENDENCY_BY_REGION_BIT; 2160 enum VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = VkDependencyFlagBits.VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX; 2161 enum VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = VkDependencyFlagBits.VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX; 2162 enum VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = VkDependencyFlagBits.VK_DEPENDENCY_FLAG_BITS_MAX_ENUM; 2163 alias VkDependencyFlags = VkFlags; 2164 2165 enum VkCommandPoolCreateFlagBits { 2166 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 2167 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 2168 VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2169 } 2170 2171 // VkCommandPoolCreateFlagBits global enums 2172 enum VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = VkCommandPoolCreateFlagBits.VK_COMMAND_POOL_CREATE_TRANSIENT_BIT; 2173 enum VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = VkCommandPoolCreateFlagBits.VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; 2174 enum VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = VkCommandPoolCreateFlagBits.VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM; 2175 alias VkCommandPoolCreateFlags = VkFlags; 2176 2177 enum VkCommandPoolResetFlagBits { 2178 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 2179 VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2180 } 2181 2182 // VkCommandPoolResetFlagBits global enums 2183 enum VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = VkCommandPoolResetFlagBits.VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT; 2184 enum VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = VkCommandPoolResetFlagBits.VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM; 2185 alias VkCommandPoolResetFlags = VkFlags; 2186 2187 enum VkCommandBufferUsageFlagBits { 2188 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, 2189 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, 2190 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, 2191 VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2192 } 2193 2194 // VkCommandBufferUsageFlagBits global enums 2195 enum VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; 2196 enum VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT; 2197 enum VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; 2198 enum VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM; 2199 alias VkCommandBufferUsageFlags = VkFlags; 2200 2201 enum VkQueryControlFlagBits { 2202 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, 2203 VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2204 } 2205 2206 // VkQueryControlFlagBits global enums 2207 enum VK_QUERY_CONTROL_PRECISE_BIT = VkQueryControlFlagBits.VK_QUERY_CONTROL_PRECISE_BIT; 2208 enum VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = VkQueryControlFlagBits.VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM; 2209 alias VkQueryControlFlags = VkFlags; 2210 2211 enum VkCommandBufferResetFlagBits { 2212 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 2213 VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2214 } 2215 2216 // VkCommandBufferResetFlagBits global enums 2217 enum VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = VkCommandBufferResetFlagBits.VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT; 2218 enum VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = VkCommandBufferResetFlagBits.VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM; 2219 alias VkCommandBufferResetFlags = VkFlags; 2220 2221 enum VkStencilFaceFlagBits { 2222 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, 2223 VK_STENCIL_FACE_BACK_BIT = 0x00000002, 2224 VK_STENCIL_FRONT_AND_BACK = 0x00000003, 2225 VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2226 } 2227 2228 // VkStencilFaceFlagBits global enums 2229 enum VK_STENCIL_FACE_FRONT_BIT = VkStencilFaceFlagBits.VK_STENCIL_FACE_FRONT_BIT; 2230 enum VK_STENCIL_FACE_BACK_BIT = VkStencilFaceFlagBits.VK_STENCIL_FACE_BACK_BIT; 2231 enum VK_STENCIL_FRONT_AND_BACK = VkStencilFaceFlagBits.VK_STENCIL_FRONT_AND_BACK; 2232 enum VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = VkStencilFaceFlagBits.VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM; 2233 alias VkStencilFaceFlags = VkFlags; 2234 2235 alias PFN_vkAllocationFunction = void* function( void* pUserData, size_t size, size_t alignment, VkSystemAllocationScope allocationScope); 2236 alias PFN_vkReallocationFunction = void* function( void* pUserData, void* pOriginal, size_t size, size_t alignment, VkSystemAllocationScope allocationScope); 2237 alias PFN_vkFreeFunction = void function( void* pUserData, void* pMemory); 2238 alias PFN_vkInternalAllocationNotification = void function( void* pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope); 2239 alias PFN_vkInternalFreeNotification = void function( void* pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope); 2240 alias PFN_vkVoidFunction = void function( ); 2241 2242 struct VkApplicationInfo { 2243 VkStructureType sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; 2244 const( void )* pNext; 2245 const( char )* pApplicationName; 2246 uint32_t applicationVersion; 2247 const( char )* pEngineName; 2248 uint32_t engineVersion; 2249 uint32_t apiVersion; 2250 } 2251 2252 struct VkInstanceCreateInfo { 2253 VkStructureType sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; 2254 const( void )* pNext; 2255 VkInstanceCreateFlags flags; 2256 const( VkApplicationInfo )* pApplicationInfo; 2257 uint32_t enabledLayerCount; 2258 const( char* )* ppEnabledLayerNames; 2259 uint32_t enabledExtensionCount; 2260 const( char* )* ppEnabledExtensionNames; 2261 } 2262 2263 struct VkAllocationCallbacks { 2264 void* pUserData; 2265 PFN_vkAllocationFunction pfnAllocation; 2266 PFN_vkReallocationFunction pfnReallocation; 2267 PFN_vkFreeFunction pfnFree; 2268 PFN_vkInternalAllocationNotification pfnInternalAllocation; 2269 PFN_vkInternalFreeNotification pfnInternalFree; 2270 } 2271 2272 struct VkPhysicalDeviceFeatures { 2273 VkBool32 robustBufferAccess; 2274 VkBool32 fullDrawIndexUint32; 2275 VkBool32 imageCubeArray; 2276 VkBool32 independentBlend; 2277 VkBool32 geometryShader; 2278 VkBool32 tessellationShader; 2279 VkBool32 sampleRateShading; 2280 VkBool32 dualSrcBlend; 2281 VkBool32 logicOp; 2282 VkBool32 multiDrawIndirect; 2283 VkBool32 drawIndirectFirstInstance; 2284 VkBool32 depthClamp; 2285 VkBool32 depthBiasClamp; 2286 VkBool32 fillModeNonSolid; 2287 VkBool32 depthBounds; 2288 VkBool32 wideLines; 2289 VkBool32 largePoints; 2290 VkBool32 alphaToOne; 2291 VkBool32 multiViewport; 2292 VkBool32 samplerAnisotropy; 2293 VkBool32 textureCompressionETC2; 2294 VkBool32 textureCompressionASTC_LDR; 2295 VkBool32 textureCompressionBC; 2296 VkBool32 occlusionQueryPrecise; 2297 VkBool32 pipelineStatisticsQuery; 2298 VkBool32 vertexPipelineStoresAndAtomics; 2299 VkBool32 fragmentStoresAndAtomics; 2300 VkBool32 shaderTessellationAndGeometryPointSize; 2301 VkBool32 shaderImageGatherExtended; 2302 VkBool32 shaderStorageImageExtendedFormats; 2303 VkBool32 shaderStorageImageMultisample; 2304 VkBool32 shaderStorageImageReadWithoutFormat; 2305 VkBool32 shaderStorageImageWriteWithoutFormat; 2306 VkBool32 shaderUniformBufferArrayDynamicIndexing; 2307 VkBool32 shaderSampledImageArrayDynamicIndexing; 2308 VkBool32 shaderStorageBufferArrayDynamicIndexing; 2309 VkBool32 shaderStorageImageArrayDynamicIndexing; 2310 VkBool32 shaderClipDistance; 2311 VkBool32 shaderCullDistance; 2312 VkBool32 shaderFloat64; 2313 VkBool32 shaderInt64; 2314 VkBool32 shaderInt16; 2315 VkBool32 shaderResourceResidency; 2316 VkBool32 shaderResourceMinLod; 2317 VkBool32 sparseBinding; 2318 VkBool32 sparseResidencyBuffer; 2319 VkBool32 sparseResidencyImage2D; 2320 VkBool32 sparseResidencyImage3D; 2321 VkBool32 sparseResidency2Samples; 2322 VkBool32 sparseResidency4Samples; 2323 VkBool32 sparseResidency8Samples; 2324 VkBool32 sparseResidency16Samples; 2325 VkBool32 sparseResidencyAliased; 2326 VkBool32 variableMultisampleRate; 2327 VkBool32 inheritedQueries; 2328 } 2329 2330 struct VkFormatProperties { 2331 VkFormatFeatureFlags linearTilingFeatures; 2332 VkFormatFeatureFlags optimalTilingFeatures; 2333 VkFormatFeatureFlags bufferFeatures; 2334 } 2335 2336 struct VkExtent3D { 2337 uint32_t width; 2338 uint32_t height; 2339 uint32_t depth; 2340 } 2341 2342 struct VkImageFormatProperties { 2343 VkExtent3D maxExtent; 2344 uint32_t maxMipLevels; 2345 uint32_t maxArrayLayers; 2346 VkSampleCountFlags sampleCounts; 2347 VkDeviceSize maxResourceSize; 2348 } 2349 2350 struct VkPhysicalDeviceLimits { 2351 uint32_t maxImageDimension1D; 2352 uint32_t maxImageDimension2D; 2353 uint32_t maxImageDimension3D; 2354 uint32_t maxImageDimensionCube; 2355 uint32_t maxImageArrayLayers; 2356 uint32_t maxTexelBufferElements; 2357 uint32_t maxUniformBufferRange; 2358 uint32_t maxStorageBufferRange; 2359 uint32_t maxPushConstantsSize; 2360 uint32_t maxMemoryAllocationCount; 2361 uint32_t maxSamplerAllocationCount; 2362 VkDeviceSize bufferImageGranularity; 2363 VkDeviceSize sparseAddressSpaceSize; 2364 uint32_t maxBoundDescriptorSets; 2365 uint32_t maxPerStageDescriptorSamplers; 2366 uint32_t maxPerStageDescriptorUniformBuffers; 2367 uint32_t maxPerStageDescriptorStorageBuffers; 2368 uint32_t maxPerStageDescriptorSampledImages; 2369 uint32_t maxPerStageDescriptorStorageImages; 2370 uint32_t maxPerStageDescriptorInputAttachments; 2371 uint32_t maxPerStageResources; 2372 uint32_t maxDescriptorSetSamplers; 2373 uint32_t maxDescriptorSetUniformBuffers; 2374 uint32_t maxDescriptorSetUniformBuffersDynamic; 2375 uint32_t maxDescriptorSetStorageBuffers; 2376 uint32_t maxDescriptorSetStorageBuffersDynamic; 2377 uint32_t maxDescriptorSetSampledImages; 2378 uint32_t maxDescriptorSetStorageImages; 2379 uint32_t maxDescriptorSetInputAttachments; 2380 uint32_t maxVertexInputAttributes; 2381 uint32_t maxVertexInputBindings; 2382 uint32_t maxVertexInputAttributeOffset; 2383 uint32_t maxVertexInputBindingStride; 2384 uint32_t maxVertexOutputComponents; 2385 uint32_t maxTessellationGenerationLevel; 2386 uint32_t maxTessellationPatchSize; 2387 uint32_t maxTessellationControlPerVertexInputComponents; 2388 uint32_t maxTessellationControlPerVertexOutputComponents; 2389 uint32_t maxTessellationControlPerPatchOutputComponents; 2390 uint32_t maxTessellationControlTotalOutputComponents; 2391 uint32_t maxTessellationEvaluationInputComponents; 2392 uint32_t maxTessellationEvaluationOutputComponents; 2393 uint32_t maxGeometryShaderInvocations; 2394 uint32_t maxGeometryInputComponents; 2395 uint32_t maxGeometryOutputComponents; 2396 uint32_t maxGeometryOutputVertices; 2397 uint32_t maxGeometryTotalOutputComponents; 2398 uint32_t maxFragmentInputComponents; 2399 uint32_t maxFragmentOutputAttachments; 2400 uint32_t maxFragmentDualSrcAttachments; 2401 uint32_t maxFragmentCombinedOutputResources; 2402 uint32_t maxComputeSharedMemorySize; 2403 uint32_t[3] maxComputeWorkGroupCount; 2404 uint32_t maxComputeWorkGroupInvocations; 2405 uint32_t[3] maxComputeWorkGroupSize; 2406 uint32_t subPixelPrecisionBits; 2407 uint32_t subTexelPrecisionBits; 2408 uint32_t mipmapPrecisionBits; 2409 uint32_t maxDrawIndexedIndexValue; 2410 uint32_t maxDrawIndirectCount; 2411 float maxSamplerLodBias; 2412 float maxSamplerAnisotropy; 2413 uint32_t maxViewports; 2414 uint32_t[2] maxViewportDimensions; 2415 float[2] viewportBoundsRange; 2416 uint32_t viewportSubPixelBits; 2417 size_t minMemoryMapAlignment; 2418 VkDeviceSize minTexelBufferOffsetAlignment; 2419 VkDeviceSize minUniformBufferOffsetAlignment; 2420 VkDeviceSize minStorageBufferOffsetAlignment; 2421 int32_t minTexelOffset; 2422 uint32_t maxTexelOffset; 2423 int32_t minTexelGatherOffset; 2424 uint32_t maxTexelGatherOffset; 2425 float minInterpolationOffset; 2426 float maxInterpolationOffset; 2427 uint32_t subPixelInterpolationOffsetBits; 2428 uint32_t maxFramebufferWidth; 2429 uint32_t maxFramebufferHeight; 2430 uint32_t maxFramebufferLayers; 2431 VkSampleCountFlags framebufferColorSampleCounts; 2432 VkSampleCountFlags framebufferDepthSampleCounts; 2433 VkSampleCountFlags framebufferStencilSampleCounts; 2434 VkSampleCountFlags framebufferNoAttachmentsSampleCounts; 2435 uint32_t maxColorAttachments; 2436 VkSampleCountFlags sampledImageColorSampleCounts; 2437 VkSampleCountFlags sampledImageIntegerSampleCounts; 2438 VkSampleCountFlags sampledImageDepthSampleCounts; 2439 VkSampleCountFlags sampledImageStencilSampleCounts; 2440 VkSampleCountFlags storageImageSampleCounts; 2441 uint32_t maxSampleMaskWords; 2442 VkBool32 timestampComputeAndGraphics; 2443 float timestampPeriod; 2444 uint32_t maxClipDistances; 2445 uint32_t maxCullDistances; 2446 uint32_t maxCombinedClipAndCullDistances; 2447 uint32_t discreteQueuePriorities; 2448 float[2] pointSizeRange; 2449 float[2] lineWidthRange; 2450 float pointSizeGranularity; 2451 float lineWidthGranularity; 2452 VkBool32 strictLines; 2453 VkBool32 standardSampleLocations; 2454 VkDeviceSize optimalBufferCopyOffsetAlignment; 2455 VkDeviceSize optimalBufferCopyRowPitchAlignment; 2456 VkDeviceSize nonCoherentAtomSize; 2457 } 2458 2459 struct VkPhysicalDeviceSparseProperties { 2460 VkBool32 residencyStandard2DBlockShape; 2461 VkBool32 residencyStandard2DMultisampleBlockShape; 2462 VkBool32 residencyStandard3DBlockShape; 2463 VkBool32 residencyAlignedMipSize; 2464 VkBool32 residencyNonResidentStrict; 2465 } 2466 2467 struct VkPhysicalDeviceProperties { 2468 uint32_t apiVersion; 2469 uint32_t driverVersion; 2470 uint32_t vendorID; 2471 uint32_t deviceID; 2472 VkPhysicalDeviceType deviceType; 2473 char[ VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ] deviceName; 2474 uint8_t[ VK_UUID_SIZE ] pipelineCacheUUID; 2475 VkPhysicalDeviceLimits limits; 2476 VkPhysicalDeviceSparseProperties sparseProperties; 2477 } 2478 2479 struct VkQueueFamilyProperties { 2480 VkQueueFlags queueFlags; 2481 uint32_t queueCount; 2482 uint32_t timestampValidBits; 2483 VkExtent3D minImageTransferGranularity; 2484 } 2485 2486 struct VkMemoryType { 2487 VkMemoryPropertyFlags propertyFlags; 2488 uint32_t heapIndex; 2489 } 2490 2491 struct VkMemoryHeap { 2492 VkDeviceSize size; 2493 VkMemoryHeapFlags flags; 2494 } 2495 2496 struct VkPhysicalDeviceMemoryProperties { 2497 uint32_t memoryTypeCount; 2498 VkMemoryType[ VK_MAX_MEMORY_TYPES ] memoryTypes; 2499 uint32_t memoryHeapCount; 2500 VkMemoryHeap[ VK_MAX_MEMORY_HEAPS ] memoryHeaps; 2501 } 2502 2503 struct VkDeviceQueueCreateInfo { 2504 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; 2505 const( void )* pNext; 2506 VkDeviceQueueCreateFlags flags; 2507 uint32_t queueFamilyIndex; 2508 uint32_t queueCount; 2509 const( float )* pQueuePriorities; 2510 } 2511 2512 struct VkDeviceCreateInfo { 2513 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; 2514 const( void )* pNext; 2515 VkDeviceCreateFlags flags; 2516 uint32_t queueCreateInfoCount; 2517 const( VkDeviceQueueCreateInfo )* pQueueCreateInfos; 2518 uint32_t enabledLayerCount; 2519 const( char* )* ppEnabledLayerNames; 2520 uint32_t enabledExtensionCount; 2521 const( char* )* ppEnabledExtensionNames; 2522 const( VkPhysicalDeviceFeatures )* pEnabledFeatures; 2523 } 2524 2525 struct VkExtensionProperties { 2526 char[ VK_MAX_EXTENSION_NAME_SIZE ] extensionName; 2527 uint32_t specVersion; 2528 } 2529 2530 struct VkLayerProperties { 2531 char[ VK_MAX_EXTENSION_NAME_SIZE ] layerName; 2532 uint32_t specVersion; 2533 uint32_t implementationVersion; 2534 char[ VK_MAX_DESCRIPTION_SIZE ] description; 2535 } 2536 2537 struct VkSubmitInfo { 2538 VkStructureType sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; 2539 const( void )* pNext; 2540 uint32_t waitSemaphoreCount; 2541 const( VkSemaphore )* pWaitSemaphores; 2542 const( VkPipelineStageFlags )* pWaitDstStageMask; 2543 uint32_t commandBufferCount; 2544 const( VkCommandBuffer )* pCommandBuffers; 2545 uint32_t signalSemaphoreCount; 2546 const( VkSemaphore )* pSignalSemaphores; 2547 } 2548 2549 struct VkMemoryAllocateInfo { 2550 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; 2551 const( void )* pNext; 2552 VkDeviceSize allocationSize; 2553 uint32_t memoryTypeIndex; 2554 } 2555 2556 struct VkMappedMemoryRange { 2557 VkStructureType sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; 2558 const( void )* pNext; 2559 VkDeviceMemory memory; 2560 VkDeviceSize offset; 2561 VkDeviceSize size; 2562 } 2563 2564 struct VkMemoryRequirements { 2565 VkDeviceSize size; 2566 VkDeviceSize alignment; 2567 uint32_t memoryTypeBits; 2568 } 2569 2570 struct VkSparseImageFormatProperties { 2571 VkImageAspectFlags aspectMask; 2572 VkExtent3D imageGranularity; 2573 VkSparseImageFormatFlags flags; 2574 } 2575 2576 struct VkSparseImageMemoryRequirements { 2577 VkSparseImageFormatProperties formatProperties; 2578 uint32_t imageMipTailFirstLod; 2579 VkDeviceSize imageMipTailSize; 2580 VkDeviceSize imageMipTailOffset; 2581 VkDeviceSize imageMipTailStride; 2582 } 2583 2584 struct VkSparseMemoryBind { 2585 VkDeviceSize resourceOffset; 2586 VkDeviceSize size; 2587 VkDeviceMemory memory; 2588 VkDeviceSize memoryOffset; 2589 VkSparseMemoryBindFlags flags; 2590 } 2591 2592 struct VkSparseBufferMemoryBindInfo { 2593 VkBuffer buffer; 2594 uint32_t bindCount; 2595 const( VkSparseMemoryBind )* pBinds; 2596 } 2597 2598 struct VkSparseImageOpaqueMemoryBindInfo { 2599 VkImage image; 2600 uint32_t bindCount; 2601 const( VkSparseMemoryBind )* pBinds; 2602 } 2603 2604 struct VkImageSubresource { 2605 VkImageAspectFlags aspectMask; 2606 uint32_t mipLevel; 2607 uint32_t arrayLayer; 2608 } 2609 2610 struct VkOffset3D { 2611 int32_t x; 2612 int32_t y; 2613 int32_t z; 2614 } 2615 2616 struct VkSparseImageMemoryBind { 2617 VkImageSubresource subresource; 2618 VkOffset3D offset; 2619 VkExtent3D extent; 2620 VkDeviceMemory memory; 2621 VkDeviceSize memoryOffset; 2622 VkSparseMemoryBindFlags flags; 2623 } 2624 2625 struct VkSparseImageMemoryBindInfo { 2626 VkImage image; 2627 uint32_t bindCount; 2628 const( VkSparseImageMemoryBind )* pBinds; 2629 } 2630 2631 struct VkBindSparseInfo { 2632 VkStructureType sType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; 2633 const( void )* pNext; 2634 uint32_t waitSemaphoreCount; 2635 const( VkSemaphore )* pWaitSemaphores; 2636 uint32_t bufferBindCount; 2637 const( VkSparseBufferMemoryBindInfo )* pBufferBinds; 2638 uint32_t imageOpaqueBindCount; 2639 const( VkSparseImageOpaqueMemoryBindInfo )* pImageOpaqueBinds; 2640 uint32_t imageBindCount; 2641 const( VkSparseImageMemoryBindInfo )* pImageBinds; 2642 uint32_t signalSemaphoreCount; 2643 const( VkSemaphore )* pSignalSemaphores; 2644 } 2645 2646 struct VkFenceCreateInfo { 2647 VkStructureType sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; 2648 const( void )* pNext; 2649 VkFenceCreateFlags flags; 2650 } 2651 2652 struct VkSemaphoreCreateInfo { 2653 VkStructureType sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; 2654 const( void )* pNext; 2655 VkSemaphoreCreateFlags flags; 2656 } 2657 2658 struct VkEventCreateInfo { 2659 VkStructureType sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; 2660 const( void )* pNext; 2661 VkEventCreateFlags flags; 2662 } 2663 2664 struct VkQueryPoolCreateInfo { 2665 VkStructureType sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; 2666 const( void )* pNext; 2667 VkQueryPoolCreateFlags flags; 2668 VkQueryType queryType; 2669 uint32_t queryCount; 2670 VkQueryPipelineStatisticFlags pipelineStatistics; 2671 } 2672 2673 struct VkBufferCreateInfo { 2674 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; 2675 const( void )* pNext; 2676 VkBufferCreateFlags flags; 2677 VkDeviceSize size; 2678 VkBufferUsageFlags usage; 2679 VkSharingMode sharingMode; 2680 uint32_t queueFamilyIndexCount; 2681 const( uint32_t )* pQueueFamilyIndices; 2682 } 2683 2684 struct VkBufferViewCreateInfo { 2685 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; 2686 const( void )* pNext; 2687 VkBufferViewCreateFlags flags; 2688 VkBuffer buffer; 2689 VkFormat format; 2690 VkDeviceSize offset; 2691 VkDeviceSize range; 2692 } 2693 2694 struct VkImageCreateInfo { 2695 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; 2696 const( void )* pNext; 2697 VkImageCreateFlags flags; 2698 VkImageType imageType; 2699 VkFormat format; 2700 VkExtent3D extent; 2701 uint32_t mipLevels; 2702 uint32_t arrayLayers; 2703 VkSampleCountFlagBits samples; 2704 VkImageTiling tiling; 2705 VkImageUsageFlags usage; 2706 VkSharingMode sharingMode; 2707 uint32_t queueFamilyIndexCount; 2708 const( uint32_t )* pQueueFamilyIndices; 2709 VkImageLayout initialLayout; 2710 } 2711 2712 struct VkSubresourceLayout { 2713 VkDeviceSize offset; 2714 VkDeviceSize size; 2715 VkDeviceSize rowPitch; 2716 VkDeviceSize arrayPitch; 2717 VkDeviceSize depthPitch; 2718 } 2719 2720 struct VkComponentMapping { 2721 VkComponentSwizzle r; 2722 VkComponentSwizzle g; 2723 VkComponentSwizzle b; 2724 VkComponentSwizzle a; 2725 } 2726 2727 struct VkImageSubresourceRange { 2728 VkImageAspectFlags aspectMask; 2729 uint32_t baseMipLevel; 2730 uint32_t levelCount; 2731 uint32_t baseArrayLayer; 2732 uint32_t layerCount; 2733 } 2734 2735 struct VkImageViewCreateInfo { 2736 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; 2737 const( void )* pNext; 2738 VkImageViewCreateFlags flags; 2739 VkImage image; 2740 VkImageViewType viewType; 2741 VkFormat format; 2742 VkComponentMapping components; 2743 VkImageSubresourceRange subresourceRange; 2744 } 2745 2746 struct VkShaderModuleCreateInfo { 2747 VkStructureType sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; 2748 const( void )* pNext; 2749 VkShaderModuleCreateFlags flags; 2750 size_t codeSize; 2751 const( uint32_t )* pCode; 2752 } 2753 2754 struct VkPipelineCacheCreateInfo { 2755 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; 2756 const( void )* pNext; 2757 VkPipelineCacheCreateFlags flags; 2758 size_t initialDataSize; 2759 const( void )* pInitialData; 2760 } 2761 2762 struct VkSpecializationMapEntry { 2763 uint32_t constantID; 2764 uint32_t offset; 2765 size_t size; 2766 } 2767 2768 struct VkSpecializationInfo { 2769 uint32_t mapEntryCount; 2770 const( VkSpecializationMapEntry )* pMapEntries; 2771 size_t dataSize; 2772 const( void )* pData; 2773 } 2774 2775 struct VkPipelineShaderStageCreateInfo { 2776 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; 2777 const( void )* pNext; 2778 VkPipelineShaderStageCreateFlags flags; 2779 VkShaderStageFlagBits stage; 2780 VkShaderModule _module; 2781 const( char )* pName; 2782 const( VkSpecializationInfo )* pSpecializationInfo; 2783 } 2784 2785 struct VkVertexInputBindingDescription { 2786 uint32_t binding; 2787 uint32_t stride; 2788 VkVertexInputRate inputRate; 2789 } 2790 2791 struct VkVertexInputAttributeDescription { 2792 uint32_t location; 2793 uint32_t binding; 2794 VkFormat format; 2795 uint32_t offset; 2796 } 2797 2798 struct VkPipelineVertexInputStateCreateInfo { 2799 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; 2800 const( void )* pNext; 2801 VkPipelineVertexInputStateCreateFlags flags; 2802 uint32_t vertexBindingDescriptionCount; 2803 const( VkVertexInputBindingDescription )* pVertexBindingDescriptions; 2804 uint32_t vertexAttributeDescriptionCount; 2805 const( VkVertexInputAttributeDescription )* pVertexAttributeDescriptions; 2806 } 2807 2808 struct VkPipelineInputAssemblyStateCreateInfo { 2809 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; 2810 const( void )* pNext; 2811 VkPipelineInputAssemblyStateCreateFlags flags; 2812 VkPrimitiveTopology topology; 2813 VkBool32 primitiveRestartEnable; 2814 } 2815 2816 struct VkPipelineTessellationStateCreateInfo { 2817 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; 2818 const( void )* pNext; 2819 VkPipelineTessellationStateCreateFlags flags; 2820 uint32_t patchControlPoints; 2821 } 2822 2823 struct VkViewport { 2824 float x; 2825 float y; 2826 float width; 2827 float height; 2828 float minDepth; 2829 float maxDepth; 2830 } 2831 2832 struct VkOffset2D { 2833 int32_t x; 2834 int32_t y; 2835 } 2836 2837 struct VkExtent2D { 2838 uint32_t width; 2839 uint32_t height; 2840 } 2841 2842 struct VkRect2D { 2843 VkOffset2D offset; 2844 VkExtent2D extent; 2845 } 2846 2847 struct VkPipelineViewportStateCreateInfo { 2848 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; 2849 const( void )* pNext; 2850 VkPipelineViewportStateCreateFlags flags; 2851 uint32_t viewportCount; 2852 const( VkViewport )* pViewports; 2853 uint32_t scissorCount; 2854 const( VkRect2D )* pScissors; 2855 } 2856 2857 struct VkPipelineRasterizationStateCreateInfo { 2858 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; 2859 const( void )* pNext; 2860 VkPipelineRasterizationStateCreateFlags flags; 2861 VkBool32 depthClampEnable; 2862 VkBool32 rasterizerDiscardEnable; 2863 VkPolygonMode polygonMode; 2864 VkCullModeFlags cullMode; 2865 VkFrontFace frontFace; 2866 VkBool32 depthBiasEnable; 2867 float depthBiasConstantFactor; 2868 float depthBiasClamp; 2869 float depthBiasSlopeFactor; 2870 float lineWidth; 2871 } 2872 2873 struct VkPipelineMultisampleStateCreateInfo { 2874 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; 2875 const( void )* pNext; 2876 VkPipelineMultisampleStateCreateFlags flags; 2877 VkSampleCountFlagBits rasterizationSamples; 2878 VkBool32 sampleShadingEnable; 2879 float minSampleShading; 2880 const( VkSampleMask )* pSampleMask; 2881 VkBool32 alphaToCoverageEnable; 2882 VkBool32 alphaToOneEnable; 2883 } 2884 2885 struct VkStencilOpState { 2886 VkStencilOp failOp; 2887 VkStencilOp passOp; 2888 VkStencilOp depthFailOp; 2889 VkCompareOp compareOp; 2890 uint32_t compareMask; 2891 uint32_t writeMask; 2892 uint32_t reference; 2893 } 2894 2895 struct VkPipelineDepthStencilStateCreateInfo { 2896 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; 2897 const( void )* pNext; 2898 VkPipelineDepthStencilStateCreateFlags flags; 2899 VkBool32 depthTestEnable; 2900 VkBool32 depthWriteEnable; 2901 VkCompareOp depthCompareOp; 2902 VkBool32 depthBoundsTestEnable; 2903 VkBool32 stencilTestEnable; 2904 VkStencilOpState front; 2905 VkStencilOpState back; 2906 float minDepthBounds; 2907 float maxDepthBounds; 2908 } 2909 2910 struct VkPipelineColorBlendAttachmentState { 2911 VkBool32 blendEnable; 2912 VkBlendFactor srcColorBlendFactor; 2913 VkBlendFactor dstColorBlendFactor; 2914 VkBlendOp colorBlendOp; 2915 VkBlendFactor srcAlphaBlendFactor; 2916 VkBlendFactor dstAlphaBlendFactor; 2917 VkBlendOp alphaBlendOp; 2918 VkColorComponentFlags colorWriteMask; 2919 } 2920 2921 struct VkPipelineColorBlendStateCreateInfo { 2922 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; 2923 const( void )* pNext; 2924 VkPipelineColorBlendStateCreateFlags flags; 2925 VkBool32 logicOpEnable; 2926 VkLogicOp logicOp; 2927 uint32_t attachmentCount; 2928 const( VkPipelineColorBlendAttachmentState )* pAttachments; 2929 float[4] blendConstants; 2930 } 2931 2932 struct VkPipelineDynamicStateCreateInfo { 2933 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; 2934 const( void )* pNext; 2935 VkPipelineDynamicStateCreateFlags flags; 2936 uint32_t dynamicStateCount; 2937 const( VkDynamicState )* pDynamicStates; 2938 } 2939 2940 struct VkGraphicsPipelineCreateInfo { 2941 VkStructureType sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; 2942 const( void )* pNext; 2943 VkPipelineCreateFlags flags; 2944 uint32_t stageCount; 2945 const( VkPipelineShaderStageCreateInfo )* pStages; 2946 const( VkPipelineVertexInputStateCreateInfo )* pVertexInputState; 2947 const( VkPipelineInputAssemblyStateCreateInfo )* pInputAssemblyState; 2948 const( VkPipelineTessellationStateCreateInfo )* pTessellationState; 2949 const( VkPipelineViewportStateCreateInfo )* pViewportState; 2950 const( VkPipelineRasterizationStateCreateInfo )* pRasterizationState; 2951 const( VkPipelineMultisampleStateCreateInfo )* pMultisampleState; 2952 const( VkPipelineDepthStencilStateCreateInfo )* pDepthStencilState; 2953 const( VkPipelineColorBlendStateCreateInfo )* pColorBlendState; 2954 const( VkPipelineDynamicStateCreateInfo )* pDynamicState; 2955 VkPipelineLayout layout; 2956 VkRenderPass renderPass; 2957 uint32_t subpass; 2958 VkPipeline basePipelineHandle; 2959 int32_t basePipelineIndex; 2960 } 2961 2962 struct VkComputePipelineCreateInfo { 2963 VkStructureType sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; 2964 const( void )* pNext; 2965 VkPipelineCreateFlags flags; 2966 VkPipelineShaderStageCreateInfo stage; 2967 VkPipelineLayout layout; 2968 VkPipeline basePipelineHandle; 2969 int32_t basePipelineIndex; 2970 } 2971 2972 struct VkPushConstantRange { 2973 VkShaderStageFlags stageFlags; 2974 uint32_t offset; 2975 uint32_t size; 2976 } 2977 2978 struct VkPipelineLayoutCreateInfo { 2979 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; 2980 const( void )* pNext; 2981 VkPipelineLayoutCreateFlags flags; 2982 uint32_t setLayoutCount; 2983 const( VkDescriptorSetLayout )* pSetLayouts; 2984 uint32_t pushConstantRangeCount; 2985 const( VkPushConstantRange )* pPushConstantRanges; 2986 } 2987 2988 struct VkSamplerCreateInfo { 2989 VkStructureType sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; 2990 const( void )* pNext; 2991 VkSamplerCreateFlags flags; 2992 VkFilter magFilter; 2993 VkFilter minFilter; 2994 VkSamplerMipmapMode mipmapMode; 2995 VkSamplerAddressMode addressModeU; 2996 VkSamplerAddressMode addressModeV; 2997 VkSamplerAddressMode addressModeW; 2998 float mipLodBias; 2999 VkBool32 anisotropyEnable; 3000 float maxAnisotropy; 3001 VkBool32 compareEnable; 3002 VkCompareOp compareOp; 3003 float minLod; 3004 float maxLod; 3005 VkBorderColor borderColor; 3006 VkBool32 unnormalizedCoordinates; 3007 } 3008 3009 struct VkDescriptorSetLayoutBinding { 3010 uint32_t binding; 3011 VkDescriptorType descriptorType; 3012 uint32_t descriptorCount; 3013 VkShaderStageFlags stageFlags; 3014 const( VkSampler )* pImmutableSamplers; 3015 } 3016 3017 struct VkDescriptorSetLayoutCreateInfo { 3018 VkStructureType sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; 3019 const( void )* pNext; 3020 VkDescriptorSetLayoutCreateFlags flags; 3021 uint32_t bindingCount; 3022 const( VkDescriptorSetLayoutBinding )* pBindings; 3023 } 3024 3025 struct VkDescriptorPoolSize { 3026 VkDescriptorType type; 3027 uint32_t descriptorCount; 3028 } 3029 3030 struct VkDescriptorPoolCreateInfo { 3031 VkStructureType sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; 3032 const( void )* pNext; 3033 VkDescriptorPoolCreateFlags flags; 3034 uint32_t maxSets; 3035 uint32_t poolSizeCount; 3036 const( VkDescriptorPoolSize )* pPoolSizes; 3037 } 3038 3039 struct VkDescriptorSetAllocateInfo { 3040 VkStructureType sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; 3041 const( void )* pNext; 3042 VkDescriptorPool descriptorPool; 3043 uint32_t descriptorSetCount; 3044 const( VkDescriptorSetLayout )* pSetLayouts; 3045 } 3046 3047 struct VkDescriptorImageInfo { 3048 VkSampler sampler; 3049 VkImageView imageView; 3050 VkImageLayout imageLayout; 3051 } 3052 3053 struct VkDescriptorBufferInfo { 3054 VkBuffer buffer; 3055 VkDeviceSize offset; 3056 VkDeviceSize range; 3057 } 3058 3059 struct VkWriteDescriptorSet { 3060 VkStructureType sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; 3061 const( void )* pNext; 3062 VkDescriptorSet dstSet; 3063 uint32_t dstBinding; 3064 uint32_t dstArrayElement; 3065 uint32_t descriptorCount; 3066 VkDescriptorType descriptorType; 3067 const( VkDescriptorImageInfo )* pImageInfo; 3068 const( VkDescriptorBufferInfo )* pBufferInfo; 3069 const( VkBufferView )* pTexelBufferView; 3070 } 3071 3072 struct VkCopyDescriptorSet { 3073 VkStructureType sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; 3074 const( void )* pNext; 3075 VkDescriptorSet srcSet; 3076 uint32_t srcBinding; 3077 uint32_t srcArrayElement; 3078 VkDescriptorSet dstSet; 3079 uint32_t dstBinding; 3080 uint32_t dstArrayElement; 3081 uint32_t descriptorCount; 3082 } 3083 3084 struct VkFramebufferCreateInfo { 3085 VkStructureType sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; 3086 const( void )* pNext; 3087 VkFramebufferCreateFlags flags; 3088 VkRenderPass renderPass; 3089 uint32_t attachmentCount; 3090 const( VkImageView )* pAttachments; 3091 uint32_t width; 3092 uint32_t height; 3093 uint32_t layers; 3094 } 3095 3096 struct VkAttachmentDescription { 3097 VkAttachmentDescriptionFlags flags; 3098 VkFormat format; 3099 VkSampleCountFlagBits samples; 3100 VkAttachmentLoadOp loadOp; 3101 VkAttachmentStoreOp storeOp; 3102 VkAttachmentLoadOp stencilLoadOp; 3103 VkAttachmentStoreOp stencilStoreOp; 3104 VkImageLayout initialLayout; 3105 VkImageLayout finalLayout; 3106 } 3107 3108 struct VkAttachmentReference { 3109 uint32_t attachment; 3110 VkImageLayout layout; 3111 } 3112 3113 struct VkSubpassDescription { 3114 VkSubpassDescriptionFlags flags; 3115 VkPipelineBindPoint pipelineBindPoint; 3116 uint32_t inputAttachmentCount; 3117 const( VkAttachmentReference )* pInputAttachments; 3118 uint32_t colorAttachmentCount; 3119 const( VkAttachmentReference )* pColorAttachments; 3120 const( VkAttachmentReference )* pResolveAttachments; 3121 const( VkAttachmentReference )* pDepthStencilAttachment; 3122 uint32_t preserveAttachmentCount; 3123 const( uint32_t )* pPreserveAttachments; 3124 } 3125 3126 struct VkSubpassDependency { 3127 uint32_t srcSubpass; 3128 uint32_t dstSubpass; 3129 VkPipelineStageFlags srcStageMask; 3130 VkPipelineStageFlags dstStageMask; 3131 VkAccessFlags srcAccessMask; 3132 VkAccessFlags dstAccessMask; 3133 VkDependencyFlags dependencyFlags; 3134 } 3135 3136 struct VkRenderPassCreateInfo { 3137 VkStructureType sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; 3138 const( void )* pNext; 3139 VkRenderPassCreateFlags flags; 3140 uint32_t attachmentCount; 3141 const( VkAttachmentDescription )* pAttachments; 3142 uint32_t subpassCount; 3143 const( VkSubpassDescription )* pSubpasses; 3144 uint32_t dependencyCount; 3145 const( VkSubpassDependency )* pDependencies; 3146 } 3147 3148 struct VkCommandPoolCreateInfo { 3149 VkStructureType sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; 3150 const( void )* pNext; 3151 VkCommandPoolCreateFlags flags; 3152 uint32_t queueFamilyIndex; 3153 } 3154 3155 struct VkCommandBufferAllocateInfo { 3156 VkStructureType sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; 3157 const( void )* pNext; 3158 VkCommandPool commandPool; 3159 VkCommandBufferLevel level; 3160 uint32_t commandBufferCount; 3161 } 3162 3163 struct VkCommandBufferInheritanceInfo { 3164 VkStructureType sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; 3165 const( void )* pNext; 3166 VkRenderPass renderPass; 3167 uint32_t subpass; 3168 VkFramebuffer framebuffer; 3169 VkBool32 occlusionQueryEnable; 3170 VkQueryControlFlags queryFlags; 3171 VkQueryPipelineStatisticFlags pipelineStatistics; 3172 } 3173 3174 struct VkCommandBufferBeginInfo { 3175 VkStructureType sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; 3176 const( void )* pNext; 3177 VkCommandBufferUsageFlags flags; 3178 const( VkCommandBufferInheritanceInfo )* pInheritanceInfo; 3179 } 3180 3181 struct VkBufferCopy { 3182 VkDeviceSize srcOffset; 3183 VkDeviceSize dstOffset; 3184 VkDeviceSize size; 3185 } 3186 3187 struct VkImageSubresourceLayers { 3188 VkImageAspectFlags aspectMask; 3189 uint32_t mipLevel; 3190 uint32_t baseArrayLayer; 3191 uint32_t layerCount; 3192 } 3193 3194 struct VkImageCopy { 3195 VkImageSubresourceLayers srcSubresource; 3196 VkOffset3D srcOffset; 3197 VkImageSubresourceLayers dstSubresource; 3198 VkOffset3D dstOffset; 3199 VkExtent3D extent; 3200 } 3201 3202 struct VkImageBlit { 3203 VkImageSubresourceLayers srcSubresource; 3204 VkOffset3D[2] srcOffsets; 3205 VkImageSubresourceLayers dstSubresource; 3206 VkOffset3D[2] dstOffsets; 3207 } 3208 3209 struct VkBufferImageCopy { 3210 VkDeviceSize bufferOffset; 3211 uint32_t bufferRowLength; 3212 uint32_t bufferImageHeight; 3213 VkImageSubresourceLayers imageSubresource; 3214 VkOffset3D imageOffset; 3215 VkExtent3D imageExtent; 3216 } 3217 3218 union VkClearColorValue { 3219 float[4] float32; 3220 int32_t[4] int32; 3221 uint32_t[4] uint32; 3222 } 3223 3224 struct VkClearDepthStencilValue { 3225 float depth; 3226 uint32_t stencil; 3227 } 3228 3229 union VkClearValue { 3230 VkClearColorValue color; 3231 VkClearDepthStencilValue depthStencil; 3232 } 3233 3234 struct VkClearAttachment { 3235 VkImageAspectFlags aspectMask; 3236 uint32_t colorAttachment; 3237 VkClearValue clearValue; 3238 } 3239 3240 struct VkClearRect { 3241 VkRect2D rect; 3242 uint32_t baseArrayLayer; 3243 uint32_t layerCount; 3244 } 3245 3246 struct VkImageResolve { 3247 VkImageSubresourceLayers srcSubresource; 3248 VkOffset3D srcOffset; 3249 VkImageSubresourceLayers dstSubresource; 3250 VkOffset3D dstOffset; 3251 VkExtent3D extent; 3252 } 3253 3254 struct VkMemoryBarrier { 3255 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; 3256 const( void )* pNext; 3257 VkAccessFlags srcAccessMask; 3258 VkAccessFlags dstAccessMask; 3259 } 3260 3261 struct VkBufferMemoryBarrier { 3262 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; 3263 const( void )* pNext; 3264 VkAccessFlags srcAccessMask; 3265 VkAccessFlags dstAccessMask; 3266 uint32_t srcQueueFamilyIndex; 3267 uint32_t dstQueueFamilyIndex; 3268 VkBuffer buffer; 3269 VkDeviceSize offset; 3270 VkDeviceSize size; 3271 } 3272 3273 struct VkImageMemoryBarrier { 3274 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; 3275 const( void )* pNext; 3276 VkAccessFlags srcAccessMask; 3277 VkAccessFlags dstAccessMask; 3278 VkImageLayout oldLayout; 3279 VkImageLayout newLayout; 3280 uint32_t srcQueueFamilyIndex; 3281 uint32_t dstQueueFamilyIndex; 3282 VkImage image; 3283 VkImageSubresourceRange subresourceRange; 3284 } 3285 3286 struct VkRenderPassBeginInfo { 3287 VkStructureType sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; 3288 const( void )* pNext; 3289 VkRenderPass renderPass; 3290 VkFramebuffer framebuffer; 3291 VkRect2D renderArea; 3292 uint32_t clearValueCount; 3293 const( VkClearValue )* pClearValues; 3294 } 3295 3296 struct VkDispatchIndirectCommand { 3297 uint32_t x; 3298 uint32_t y; 3299 uint32_t z; 3300 } 3301 3302 struct VkDrawIndexedIndirectCommand { 3303 uint32_t indexCount; 3304 uint32_t instanceCount; 3305 uint32_t firstIndex; 3306 int32_t vertexOffset; 3307 uint32_t firstInstance; 3308 } 3309 3310 struct VkDrawIndirectCommand { 3311 uint32_t vertexCount; 3312 uint32_t instanceCount; 3313 uint32_t firstVertex; 3314 uint32_t firstInstance; 3315 } 3316 3317 // VK_KHR_surface 3318 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSurfaceKHR} ); 3319 3320 enum VK_KHR_SURFACE_SPEC_VERSION = 25; 3321 enum VK_KHR_SURFACE_EXTENSION_NAME = "VK_KHR_surface"; 3322 enum VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; 3323 3324 3325 enum VkColorSpaceKHR { 3326 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, 3327 VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104001, 3328 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104002, 3329 VK_COLOR_SPACE_SCRGB_LINEAR_EXT = 1000104003, 3330 VK_COLOR_SPACE_SCRGB_NONLINEAR_EXT = 1000104004, 3331 VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104005, 3332 VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104006, 3333 VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104007, 3334 VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104008, 3335 VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104009, 3336 VK_COLOR_SPACE_BT2020_NONLINEAR_EXT = 1000104010, 3337 VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, 3338 VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, 3339 VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 3340 VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 3341 VK_COLOR_SPACE_RANGE_SIZE_KHR = ( VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1 ), 3342 VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF 3343 } 3344 3345 // VkColorSpaceKHR global enums 3346 enum VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; 3347 enum VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT; 3348 enum VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT; 3349 enum VK_COLOR_SPACE_SCRGB_LINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_SCRGB_LINEAR_EXT; 3350 enum VK_COLOR_SPACE_SCRGB_NONLINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_SCRGB_NONLINEAR_EXT; 3351 enum VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_DCI_P3_LINEAR_EXT; 3352 enum VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT; 3353 enum VK_COLOR_SPACE_BT709_LINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_BT709_LINEAR_EXT; 3354 enum VK_COLOR_SPACE_BT709_NONLINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_BT709_NONLINEAR_EXT; 3355 enum VK_COLOR_SPACE_BT2020_LINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_BT2020_LINEAR_EXT; 3356 enum VK_COLOR_SPACE_BT2020_NONLINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_BT2020_NONLINEAR_EXT; 3357 enum VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT; 3358 enum VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = VkColorSpaceKHR.VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT; 3359 enum VK_COLOR_SPACE_BEGIN_RANGE_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_BEGIN_RANGE_KHR; 3360 enum VK_COLOR_SPACE_END_RANGE_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_END_RANGE_KHR; 3361 enum VK_COLOR_SPACE_RANGE_SIZE_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_RANGE_SIZE_KHR; 3362 enum VK_COLOR_SPACE_MAX_ENUM_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_MAX_ENUM_KHR; 3363 3364 enum VkPresentModeKHR { 3365 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, 3366 VK_PRESENT_MODE_MAILBOX_KHR = 1, 3367 VK_PRESENT_MODE_FIFO_KHR = 2, 3368 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, 3369 VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, 3370 VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR, 3371 VK_PRESENT_MODE_RANGE_SIZE_KHR = ( VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1 ), 3372 VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF 3373 } 3374 3375 // VkPresentModeKHR global enums 3376 enum VK_PRESENT_MODE_IMMEDIATE_KHR = VkPresentModeKHR.VK_PRESENT_MODE_IMMEDIATE_KHR; 3377 enum VK_PRESENT_MODE_MAILBOX_KHR = VkPresentModeKHR.VK_PRESENT_MODE_MAILBOX_KHR; 3378 enum VK_PRESENT_MODE_FIFO_KHR = VkPresentModeKHR.VK_PRESENT_MODE_FIFO_KHR; 3379 enum VK_PRESENT_MODE_FIFO_RELAXED_KHR = VkPresentModeKHR.VK_PRESENT_MODE_FIFO_RELAXED_KHR; 3380 enum VK_PRESENT_MODE_BEGIN_RANGE_KHR = VkPresentModeKHR.VK_PRESENT_MODE_BEGIN_RANGE_KHR; 3381 enum VK_PRESENT_MODE_END_RANGE_KHR = VkPresentModeKHR.VK_PRESENT_MODE_END_RANGE_KHR; 3382 enum VK_PRESENT_MODE_RANGE_SIZE_KHR = VkPresentModeKHR.VK_PRESENT_MODE_RANGE_SIZE_KHR; 3383 enum VK_PRESENT_MODE_MAX_ENUM_KHR = VkPresentModeKHR.VK_PRESENT_MODE_MAX_ENUM_KHR; 3384 3385 3386 enum VkSurfaceTransformFlagBitsKHR { 3387 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, 3388 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, 3389 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, 3390 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, 3391 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, 3392 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, 3393 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, 3394 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, 3395 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, 3396 VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3397 } 3398 3399 // VkSurfaceTransformFlagBitsKHR global enums 3400 enum VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; 3401 enum VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR; 3402 enum VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR; 3403 enum VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR; 3404 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR; 3405 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR; 3406 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR; 3407 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR; 3408 enum VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR; 3409 enum VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR; 3410 alias VkSurfaceTransformFlagsKHR = VkFlags; 3411 3412 enum VkCompositeAlphaFlagBitsKHR { 3413 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 3414 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, 3415 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, 3416 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, 3417 VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3418 } 3419 3420 // VkCompositeAlphaFlagBitsKHR global enums 3421 enum VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; 3422 enum VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR; 3423 enum VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR; 3424 enum VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; 3425 enum VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR; 3426 alias VkCompositeAlphaFlagsKHR = VkFlags; 3427 3428 struct VkSurfaceCapabilitiesKHR { 3429 uint32_t minImageCount; 3430 uint32_t maxImageCount; 3431 VkExtent2D currentExtent; 3432 VkExtent2D minImageExtent; 3433 VkExtent2D maxImageExtent; 3434 uint32_t maxImageArrayLayers; 3435 VkSurfaceTransformFlagsKHR supportedTransforms; 3436 VkSurfaceTransformFlagBitsKHR currentTransform; 3437 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 3438 VkImageUsageFlags supportedUsageFlags; 3439 } 3440 3441 struct VkSurfaceFormatKHR { 3442 VkFormat format; 3443 VkColorSpaceKHR colorSpace; 3444 } 3445 3446 // VK_KHR_swapchain 3447 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSwapchainKHR} ); 3448 3449 enum VK_KHR_SWAPCHAIN_SPEC_VERSION = 68; 3450 enum VK_KHR_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_swapchain"; 3451 3452 3453 enum VkSwapchainCreateFlagBitsKHR { 3454 VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001, 3455 VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3456 } 3457 3458 // VkSwapchainCreateFlagBitsKHR global enums 3459 enum VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = VkSwapchainCreateFlagBitsKHR.VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX; 3460 enum VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = VkSwapchainCreateFlagBitsKHR.VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR; 3461 alias VkSwapchainCreateFlagsKHR = VkFlags; 3462 3463 struct VkSwapchainCreateInfoKHR { 3464 VkStructureType sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; 3465 const( void )* pNext; 3466 VkSwapchainCreateFlagsKHR flags; 3467 VkSurfaceKHR surface; 3468 uint32_t minImageCount; 3469 VkFormat imageFormat; 3470 VkColorSpaceKHR imageColorSpace; 3471 VkExtent2D imageExtent; 3472 uint32_t imageArrayLayers; 3473 VkImageUsageFlags imageUsage; 3474 VkSharingMode imageSharingMode; 3475 uint32_t queueFamilyIndexCount; 3476 const( uint32_t )* pQueueFamilyIndices; 3477 VkSurfaceTransformFlagBitsKHR preTransform; 3478 VkCompositeAlphaFlagBitsKHR compositeAlpha; 3479 VkPresentModeKHR presentMode; 3480 VkBool32 clipped; 3481 VkSwapchainKHR oldSwapchain; 3482 } 3483 3484 struct VkPresentInfoKHR { 3485 VkStructureType sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; 3486 const( void )* pNext; 3487 uint32_t waitSemaphoreCount; 3488 const( VkSemaphore )* pWaitSemaphores; 3489 uint32_t swapchainCount; 3490 const( VkSwapchainKHR )* pSwapchains; 3491 const( uint32_t )* pImageIndices; 3492 VkResult* pResults; 3493 } 3494 3495 // VK_KHR_display 3496 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDisplayKHR} ); 3497 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDisplayModeKHR} ); 3498 3499 enum VK_KHR_DISPLAY_SPEC_VERSION = 21; 3500 enum VK_KHR_DISPLAY_EXTENSION_NAME = "VK_KHR_display"; 3501 3502 3503 enum VkDisplayPlaneAlphaFlagBitsKHR { 3504 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 3505 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, 3506 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, 3507 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, 3508 VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3509 } 3510 3511 // VkDisplayPlaneAlphaFlagBitsKHR global enums 3512 enum VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR; 3513 enum VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR; 3514 enum VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR; 3515 enum VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR; 3516 enum VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR; 3517 alias VkDisplayPlaneAlphaFlagsKHR = VkFlags; 3518 alias VkDisplayModeCreateFlagsKHR = VkFlags; 3519 alias VkDisplaySurfaceCreateFlagsKHR = VkFlags; 3520 3521 struct VkDisplayPropertiesKHR { 3522 VkDisplayKHR display; 3523 const( char )* displayName; 3524 VkExtent2D physicalDimensions; 3525 VkExtent2D physicalResolution; 3526 VkSurfaceTransformFlagsKHR supportedTransforms; 3527 VkBool32 planeReorderPossible; 3528 VkBool32 persistentContent; 3529 } 3530 3531 struct VkDisplayModeParametersKHR { 3532 VkExtent2D visibleRegion; 3533 uint32_t refreshRate; 3534 } 3535 3536 struct VkDisplayModePropertiesKHR { 3537 VkDisplayModeKHR displayMode; 3538 VkDisplayModeParametersKHR parameters; 3539 } 3540 3541 struct VkDisplayModeCreateInfoKHR { 3542 VkStructureType sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR; 3543 const( void )* pNext; 3544 VkDisplayModeCreateFlagsKHR flags; 3545 VkDisplayModeParametersKHR parameters; 3546 } 3547 3548 struct VkDisplayPlaneCapabilitiesKHR { 3549 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; 3550 VkOffset2D minSrcPosition; 3551 VkOffset2D maxSrcPosition; 3552 VkExtent2D minSrcExtent; 3553 VkExtent2D maxSrcExtent; 3554 VkOffset2D minDstPosition; 3555 VkOffset2D maxDstPosition; 3556 VkExtent2D minDstExtent; 3557 VkExtent2D maxDstExtent; 3558 } 3559 3560 struct VkDisplayPlanePropertiesKHR { 3561 VkDisplayKHR currentDisplay; 3562 uint32_t currentStackIndex; 3563 } 3564 3565 struct VkDisplaySurfaceCreateInfoKHR { 3566 VkStructureType sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR; 3567 const( void )* pNext; 3568 VkDisplaySurfaceCreateFlagsKHR flags; 3569 VkDisplayModeKHR displayMode; 3570 uint32_t planeIndex; 3571 uint32_t planeStackIndex; 3572 VkSurfaceTransformFlagBitsKHR transform; 3573 float globalAlpha; 3574 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; 3575 VkExtent2D imageExtent; 3576 } 3577 3578 // VK_KHR_display_swapchain 3579 enum VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION = 9; 3580 enum VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_display_swapchain"; 3581 3582 struct VkDisplayPresentInfoKHR { 3583 VkStructureType sType = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR; 3584 const( void )* pNext; 3585 VkRect2D srcRect; 3586 VkRect2D dstRect; 3587 VkBool32 persistent; 3588 } 3589 3590 // VK_KHR_xlib_surface 3591 version( VK_USE_PLATFORM_XLIB_KHR ) { 3592 public import X11.Xlib; 3593 3594 enum VK_KHR_XLIB_SURFACE_SPEC_VERSION = 6; 3595 enum VK_KHR_XLIB_SURFACE_EXTENSION_NAME = "VK_KHR_xlib_surface"; 3596 3597 alias VkXlibSurfaceCreateFlagsKHR = VkFlags; 3598 3599 struct VkXlibSurfaceCreateInfoKHR { 3600 VkStructureType sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; 3601 const( void )* pNext; 3602 VkXlibSurfaceCreateFlagsKHR flags; 3603 Display* dpy; 3604 Window window; 3605 } 3606 } 3607 3608 // VK_KHR_xcb_surface 3609 version( VK_USE_PLATFORM_XCB_KHR ) { 3610 public import xcb.xcb; 3611 3612 enum VK_KHR_XCB_SURFACE_SPEC_VERSION = 6; 3613 enum VK_KHR_XCB_SURFACE_EXTENSION_NAME = "VK_KHR_xcb_surface"; 3614 3615 alias VkXcbSurfaceCreateFlagsKHR = VkFlags; 3616 3617 struct VkXcbSurfaceCreateInfoKHR { 3618 VkStructureType sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; 3619 const( void )* pNext; 3620 VkXcbSurfaceCreateFlagsKHR flags; 3621 xcb_connection_t* connection; 3622 xcb_window_t window; 3623 } 3624 } 3625 3626 // VK_KHR_wayland_surface 3627 version( VK_USE_PLATFORM_WAYLAND_KHR ) { 3628 public import wayland.client; 3629 3630 enum VK_KHR_WAYLAND_SURFACE_SPEC_VERSION = 6; 3631 enum VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME = "VK_KHR_wayland_surface"; 3632 3633 alias VkWaylandSurfaceCreateFlagsKHR = VkFlags; 3634 struct wl_surface; 3635 struct wl_display; 3636 3637 3638 struct VkWaylandSurfaceCreateInfoKHR { 3639 VkStructureType sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; 3640 const( void )* pNext; 3641 VkWaylandSurfaceCreateFlagsKHR flags; 3642 wl_display* display; 3643 wl_surface* surface; 3644 } 3645 } 3646 3647 // VK_KHR_mir_surface 3648 version( VK_USE_PLATFORM_MIR_KHR ) { 3649 public import mir_toolkit.client_types; 3650 3651 enum VK_KHR_MIR_SURFACE_SPEC_VERSION = 4; 3652 enum VK_KHR_MIR_SURFACE_EXTENSION_NAME = "VK_KHR_mir_surface"; 3653 3654 alias VkMirSurfaceCreateFlagsKHR = VkFlags; 3655 3656 struct VkMirSurfaceCreateInfoKHR { 3657 VkStructureType sType = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR; 3658 const( void )* pNext; 3659 VkMirSurfaceCreateFlagsKHR flags; 3660 MirConnection* connection; 3661 MirSurface* mirSurface; 3662 } 3663 } 3664 3665 // VK_KHR_android_surface 3666 version( VK_USE_PLATFORM_ANDROID_KHR ) { 3667 public import android.native_window; 3668 3669 enum VK_KHR_ANDROID_SURFACE_SPEC_VERSION = 6; 3670 enum VK_KHR_ANDROID_SURFACE_EXTENSION_NAME = "VK_KHR_android_surface"; 3671 3672 alias VkAndroidSurfaceCreateFlagsKHR = VkFlags; 3673 3674 struct VkAndroidSurfaceCreateInfoKHR { 3675 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; 3676 const( void )* pNext; 3677 VkAndroidSurfaceCreateFlagsKHR flags; 3678 ANativeWindow* window; 3679 } 3680 } 3681 3682 // VK_KHR_win32_surface 3683 version( VK_USE_PLATFORM_WIN32_KHR ) { 3684 public import core.sys.windows.windows; 3685 3686 enum VK_KHR_WIN32_SURFACE_SPEC_VERSION = 5; 3687 enum VK_KHR_WIN32_SURFACE_EXTENSION_NAME = "VK_KHR_win32_surface"; 3688 3689 alias VkWin32SurfaceCreateFlagsKHR = VkFlags; 3690 3691 struct VkWin32SurfaceCreateInfoKHR { 3692 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; 3693 const( void )* pNext; 3694 VkWin32SurfaceCreateFlagsKHR flags; 3695 HINSTANCE hinstance; 3696 HWND hwnd; 3697 } 3698 } 3699 3700 // VK_KHR_sampler_mirror_clamp_to_edge 3701 enum VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION = 1; 3702 enum VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME = "VK_KHR_sampler_mirror_clamp_to_edge"; 3703 3704 // VK_KHR_get_physical_device_properties2 3705 enum VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION = 1; 3706 enum VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME = "VK_KHR_get_physical_device_properties2"; 3707 3708 struct VkPhysicalDeviceFeatures2KHR { 3709 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR; 3710 void* pNext; 3711 VkPhysicalDeviceFeatures features; 3712 } 3713 3714 struct VkPhysicalDeviceProperties2KHR { 3715 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR; 3716 void* pNext; 3717 VkPhysicalDeviceProperties properties; 3718 } 3719 3720 struct VkFormatProperties2KHR { 3721 VkStructureType sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR; 3722 void* pNext; 3723 VkFormatProperties formatProperties; 3724 } 3725 3726 struct VkImageFormatProperties2KHR { 3727 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR; 3728 void* pNext; 3729 VkImageFormatProperties imageFormatProperties; 3730 } 3731 3732 struct VkPhysicalDeviceImageFormatInfo2KHR { 3733 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR; 3734 const( void )* pNext; 3735 VkFormat format; 3736 VkImageType type; 3737 VkImageTiling tiling; 3738 VkImageUsageFlags usage; 3739 VkImageCreateFlags flags; 3740 } 3741 3742 struct VkQueueFamilyProperties2KHR { 3743 VkStructureType sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR; 3744 void* pNext; 3745 VkQueueFamilyProperties queueFamilyProperties; 3746 } 3747 3748 struct VkPhysicalDeviceMemoryProperties2KHR { 3749 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR; 3750 void* pNext; 3751 VkPhysicalDeviceMemoryProperties memoryProperties; 3752 } 3753 3754 struct VkSparseImageFormatProperties2KHR { 3755 VkStructureType sType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR; 3756 void* pNext; 3757 VkSparseImageFormatProperties properties; 3758 } 3759 3760 struct VkPhysicalDeviceSparseImageFormatInfo2KHR { 3761 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR; 3762 const( void )* pNext; 3763 VkFormat format; 3764 VkImageType type; 3765 VkSampleCountFlagBits samples; 3766 VkImageUsageFlags usage; 3767 VkImageTiling tiling; 3768 } 3769 3770 // VK_KHR_shader_draw_parameters 3771 enum VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION = 1; 3772 enum VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME = "VK_KHR_shader_draw_parameters"; 3773 3774 // VK_KHR_maintenance1 3775 enum VK_KHR_MAINTENANCE1_SPEC_VERSION = 1; 3776 enum VK_KHR_MAINTENANCE1_EXTENSION_NAME = "VK_KHR_maintenance1"; 3777 3778 alias VkCommandPoolTrimFlagsKHR = VkFlags; 3779 3780 // VK_KHR_push_descriptor 3781 enum VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION = 1; 3782 enum VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME = "VK_KHR_push_descriptor"; 3783 3784 struct VkPhysicalDevicePushDescriptorPropertiesKHR { 3785 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR; 3786 void* pNext; 3787 uint32_t maxPushDescriptors; 3788 } 3789 3790 // VK_KHR_extension_82 3791 enum VK_KHR_EXTENSION_82_SPEC_VERSION = 0; 3792 enum VK_KHR_EXTENSION_82_EXTENSION_NAME = "VK_KHR_extension_82"; 3793 3794 // VK_KHR_extension_83 3795 enum VK_KHR_EXTENSION_83_SPEC_VERSION = 0; 3796 enum VK_KHR_EXTENSION_83_EXTENSION_NAME = "VK_KHR_extension_83"; 3797 3798 // VK_KHR_extension_84 3799 enum VK_KHR_EXTENSION_84_SPEC_VERSION = 0; 3800 enum VK_KHR_EXTENSION_84_EXTENSION_NAME = "VK_KHR_extension_84"; 3801 3802 // VK_KHR_extension_85 3803 enum VK_KHR_EXTENSION_85_SPEC_VERSION = 0; 3804 enum VK_KHR_EXTENSION_85_EXTENSION_NAME = "VK_KHR_extension_85"; 3805 3806 // VK_KHR_descriptor_update_template 3807 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDescriptorUpdateTemplateKHR} ); 3808 3809 enum VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION = 1; 3810 enum VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME = "VK_KHR_descriptor_update_template"; 3811 3812 3813 enum VkDescriptorUpdateTemplateTypeKHR { 3814 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0, 3815 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, 3816 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR, 3817 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, 3818 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = ( VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + 1 ), 3819 VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF 3820 } 3821 3822 // VkDescriptorUpdateTemplateTypeKHR global enums 3823 enum VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VkDescriptorUpdateTemplateTypeKHR.VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR; 3824 enum VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = VkDescriptorUpdateTemplateTypeKHR.VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR; 3825 enum VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VkDescriptorUpdateTemplateTypeKHR.VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR; 3826 enum VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VkDescriptorUpdateTemplateTypeKHR.VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR; 3827 enum VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = VkDescriptorUpdateTemplateTypeKHR.VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR; 3828 enum VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = VkDescriptorUpdateTemplateTypeKHR.VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR; 3829 3830 alias VkDescriptorUpdateTemplateCreateFlagsKHR = VkFlags; 3831 3832 struct VkDescriptorUpdateTemplateEntryKHR { 3833 uint32_t dstBinding; 3834 uint32_t dstArrayElement; 3835 uint32_t descriptorCount; 3836 VkDescriptorType descriptorType; 3837 size_t offset; 3838 size_t stride; 3839 } 3840 3841 struct VkDescriptorUpdateTemplateCreateInfoKHR { 3842 VkStructureType sType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR; 3843 void* pNext; 3844 VkDescriptorUpdateTemplateCreateFlagsKHR flags; 3845 uint32_t descriptorUpdateEntryCount; 3846 const( VkDescriptorUpdateTemplateEntryKHR )* pDescriptorUpdateEntries; 3847 VkDescriptorUpdateTemplateTypeKHR templateType; 3848 VkDescriptorSetLayout descriptorSetLayout; 3849 VkPipelineBindPoint pipelineBindPoint; 3850 VkPipelineLayout pipelineLayout; 3851 uint32_t set; 3852 } 3853 3854 // VK_KHR_extension_94 3855 enum VK_KHR_EXTENSION_94_SPEC_VERSION = 0; 3856 enum VK_KHR_EXTENSION_94_EXTENSION_NAME = "VK_KHR_extension_94"; 3857 3858 // VK_KHR_extension_112 3859 enum VK_KHR_EXTENSION_112_SPEC_VERSION = 0; 3860 enum VK_KHR_EXTENSION_112_EXTENSION_NAME = "VK_KHR_extension_112"; 3861 3862 // VK_KHR_extension_113 3863 enum VK_KHR_EXTENSION_113_SPEC_VERSION = 0; 3864 enum VK_KHR_EXTENSION_113_EXTENSION_NAME = "VK_KHR_extension_113"; 3865 3866 // VK_KHR_extension_114 3867 enum VK_KHR_EXTENSION_114_SPEC_VERSION = 0; 3868 enum VK_KHR_EXTENSION_114_EXTENSION_NAME = "VK_KHR_extension_114"; 3869 3870 // VK_KHR_extension_115 3871 enum VK_KHR_EXTENSION_115_SPEC_VERSION = 0; 3872 enum VK_KHR_EXTENSION_115_EXTENSION_NAME = "VK_KHR_extension_115"; 3873 3874 // VK_KHR_extension_116 3875 enum VK_KHR_EXTENSION_116_SPEC_VERSION = 0; 3876 enum VK_KHR_EXTENSION_116_EXTENSION_NAME = "VK_KHR_extension_116"; 3877 3878 // VK_KHR_extension_117 3879 enum VK_KHR_EXTENSION_117_SPEC_VERSION = 0; 3880 enum VK_KHR_EXTENSION_117_EXTENSION_NAME = "VK_KHR_extension_117"; 3881 3882 // VK_KHR_extension_118 3883 enum VK_KHR_EXTENSION_118_SPEC_VERSION = 0; 3884 enum VK_KHR_EXTENSION_118_EXTENSION_NAME = "VK_KHR_extension_118"; 3885 3886 // VK_KHR_extension_119 3887 enum VK_KHR_EXTENSION_119_SPEC_VERSION = 0; 3888 enum VK_KHR_EXTENSION_119_EXTENSION_NAME = "VK_KHR_extension_119"; 3889 3890 // VK_KHR_extension_120 3891 enum VK_KHR_EXTENSION_120_SPEC_VERSION = 0; 3892 enum VK_KHR_EXTENSION_120_EXTENSION_NAME = "VK_KHR_extension_120"; 3893 3894 // VK_KHR_variable_pointers 3895 enum VK_KHR_variable_pointers_SPEC_VERSION = 0; 3896 enum VK_KHR_variable_pointers_EXTENSION_NAME = "VK_KHR_variable_pointers"; 3897 3898 // VK_KHR_extension_122 3899 enum VK_KHR_EXTENSION_122_SPEC_VERSION = 0; 3900 enum VK_KHR_EXTENSION_122_EXTENSION_NAME = "VK_KHR_extension_122"; 3901 3902 // VK_KHR_extension_128 3903 enum VK_KHR_EXTENSION_128_SPEC_VERSION = 0; 3904 enum VK_KHR_EXTENSION_128_EXTENSION_NAME = "VK_KHR_extension_128"; 3905 3906 // VK_KHR_extension_130 3907 enum VK_KHR_EXTENSION_130_SPEC_VERSION = 0; 3908 enum VK_KHR_EXTENSION_130_EXTENSION_NAME = "VK_KHR_extension_130"; 3909 3910 // VK_ANDROID_native_buffer 3911 enum VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION = 4; 3912 enum VK_ANDROID_NATIVE_BUFFER_NUMBER = 11; 3913 enum VK_ANDROID_NATIVE_BUFFER_NAME = "VK_ANDROID_native_buffer"; 3914 3915 // VK_EXT_debug_report 3916 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDebugReportCallbackEXT} ); 3917 3918 enum VK_EXT_DEBUG_REPORT_SPEC_VERSION = 5; 3919 enum VK_EXT_DEBUG_REPORT_EXTENSION_NAME = "VK_EXT_debug_report"; 3920 enum VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; 3921 3922 3923 enum VkDebugReportObjectTypeEXT { 3924 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, 3925 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, 3926 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, 3927 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, 3928 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, 3929 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, 3930 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, 3931 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, 3932 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, 3933 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, 3934 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, 3935 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, 3936 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, 3937 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, 3938 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, 3939 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, 3940 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, 3941 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, 3942 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, 3943 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, 3944 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, 3945 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, 3946 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, 3947 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, 3948 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, 3949 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, 3950 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, 3951 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, 3952 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, 3953 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, 3954 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, 3955 VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, 3956 VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32, 3957 VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 3958 VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, 3959 VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = ( VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1 ), 3960 VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 3961 } 3962 3963 // VkDebugReportObjectTypeEXT global enums 3964 enum VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT; 3965 enum VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT; 3966 enum VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT; 3967 enum VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT; 3968 enum VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT; 3969 enum VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT; 3970 enum VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT; 3971 enum VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT; 3972 enum VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT; 3973 enum VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT; 3974 enum VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT; 3975 enum VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT; 3976 enum VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT; 3977 enum VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT; 3978 enum VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT; 3979 enum VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT; 3980 enum VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT; 3981 enum VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT; 3982 enum VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT; 3983 enum VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT; 3984 enum VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT; 3985 enum VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT; 3986 enum VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT; 3987 enum VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT; 3988 enum VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT; 3989 enum VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT; 3990 enum VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT; 3991 enum VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT; 3992 enum VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT; 3993 enum VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT; 3994 enum VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT; 3995 enum VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT; 3996 enum VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT; 3997 enum VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT; 3998 enum VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT; 3999 enum VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT; 4000 enum VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT; 4001 4002 enum VkDebugReportErrorEXT { 4003 VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, 4004 VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, 4005 VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_ERROR_NONE_EXT, 4006 VK_DEBUG_REPORT_ERROR_END_RANGE_EXT = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT, 4007 VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = ( VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT - VK_DEBUG_REPORT_ERROR_NONE_EXT + 1 ), 4008 VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = 0x7FFFFFFF 4009 } 4010 4011 // VkDebugReportErrorEXT global enums 4012 enum VK_DEBUG_REPORT_ERROR_NONE_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_NONE_EXT; 4013 enum VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT; 4014 enum VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT; 4015 enum VK_DEBUG_REPORT_ERROR_END_RANGE_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_END_RANGE_EXT; 4016 enum VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT; 4017 enum VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT; 4018 4019 4020 enum VkDebugReportFlagBitsEXT { 4021 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, 4022 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, 4023 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, 4024 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, 4025 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, 4026 VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 4027 } 4028 4029 // VkDebugReportFlagBitsEXT global enums 4030 enum VK_DEBUG_REPORT_INFORMATION_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_INFORMATION_BIT_EXT; 4031 enum VK_DEBUG_REPORT_WARNING_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_WARNING_BIT_EXT; 4032 enum VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT; 4033 enum VK_DEBUG_REPORT_ERROR_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_ERROR_BIT_EXT; 4034 enum VK_DEBUG_REPORT_DEBUG_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_DEBUG_BIT_EXT; 4035 enum VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT; 4036 alias VkDebugReportFlagsEXT = VkFlags; 4037 4038 alias PFN_vkDebugReportCallbackEXT = VkBool32 function( VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const( char )* pLayerPrefix, const( char )* pMessage, void* pUserData); 4039 4040 struct VkDebugReportCallbackCreateInfoEXT { 4041 VkStructureType sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; 4042 const( void )* pNext; 4043 VkDebugReportFlagsEXT flags; 4044 PFN_vkDebugReportCallbackEXT pfnCallback; 4045 void* pUserData; 4046 } 4047 4048 // VK_NV_glsl_shader 4049 enum VK_NV_GLSL_SHADER_SPEC_VERSION = 1; 4050 enum VK_NV_GLSL_SHADER_EXTENSION_NAME = "VK_NV_glsl_shader"; 4051 4052 // VK_NV_extension_1 4053 enum VK_NV_EXTENSION_1_SPEC_VERSION = 0; 4054 enum VK_NV_EXTENSION_1_EXTENSION_NAME = "VK_NV_extension_1"; 4055 4056 // VK_IMG_filter_cubic 4057 enum VK_IMG_FILTER_CUBIC_SPEC_VERSION = 1; 4058 enum VK_IMG_FILTER_CUBIC_EXTENSION_NAME = "VK_IMG_filter_cubic"; 4059 4060 // VK_AMD_extension_17 4061 enum VK_AMD_EXTENSION_17_SPEC_VERSION = 0; 4062 enum VK_AMD_EXTENSION_17_EXTENSION_NAME = "VK_AMD_extension_17"; 4063 4064 // VK_AMD_extension_18 4065 enum VK_AMD_EXTENSION_18_SPEC_VERSION = 0; 4066 enum VK_AMD_EXTENSION_18_EXTENSION_NAME = "VK_AMD_extension_18"; 4067 4068 // VK_AMD_rasterization_order 4069 enum VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION = 1; 4070 enum VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME = "VK_AMD_rasterization_order"; 4071 4072 4073 enum VkRasterizationOrderAMD { 4074 VK_RASTERIZATION_ORDER_STRICT_AMD = 0, 4075 VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, 4076 VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD, 4077 VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD, 4078 VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = ( VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1 ), 4079 VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF 4080 } 4081 4082 // VkRasterizationOrderAMD global enums 4083 enum VK_RASTERIZATION_ORDER_STRICT_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_STRICT_AMD; 4084 enum VK_RASTERIZATION_ORDER_RELAXED_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_RELAXED_AMD; 4085 enum VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD; 4086 enum VK_RASTERIZATION_ORDER_END_RANGE_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_END_RANGE_AMD; 4087 enum VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD; 4088 enum VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_MAX_ENUM_AMD; 4089 4090 struct VkPipelineRasterizationStateRasterizationOrderAMD { 4091 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; 4092 const( void )* pNext; 4093 VkRasterizationOrderAMD rasterizationOrder; 4094 } 4095 4096 // VK_AMD_extension_20 4097 enum VK_AMD_EXTENSION_20_SPEC_VERSION = 0; 4098 enum VK_AMD_EXTENSION_20_EXTENSION_NAME = "VK_AMD_extension_20"; 4099 4100 // VK_AMD_shader_trinary_minmax 4101 enum VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION = 1; 4102 enum VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME = "VK_AMD_shader_trinary_minmax"; 4103 4104 // VK_AMD_shader_explicit_vertex_parameter 4105 enum VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION = 1; 4106 enum VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME = "VK_AMD_shader_explicit_vertex_parameter"; 4107 4108 // VK_EXT_debug_marker 4109 enum VK_EXT_DEBUG_MARKER_SPEC_VERSION = 4; 4110 enum VK_EXT_DEBUG_MARKER_EXTENSION_NAME = "VK_EXT_debug_marker"; 4111 4112 struct VkDebugMarkerObjectNameInfoEXT { 4113 VkStructureType sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; 4114 const( void )* pNext; 4115 VkDebugReportObjectTypeEXT objectType; 4116 uint64_t object; 4117 const( char )* pObjectName; 4118 } 4119 4120 struct VkDebugMarkerObjectTagInfoEXT { 4121 VkStructureType sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT; 4122 const( void )* pNext; 4123 VkDebugReportObjectTypeEXT objectType; 4124 uint64_t object; 4125 uint64_t tagName; 4126 size_t tagSize; 4127 const( void )* pTag; 4128 } 4129 4130 struct VkDebugMarkerMarkerInfoEXT { 4131 VkStructureType sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; 4132 const( void )* pNext; 4133 const( char )* pMarkerName; 4134 float[4] color; 4135 } 4136 4137 // VK_AMD_extension_24 4138 enum VK_AMD_EXTENSION_24_SPEC_VERSION = 0; 4139 enum VK_AMD_EXTENSION_24_EXTENSION_NAME = "VK_AMD_extension_24"; 4140 4141 // VK_AMD_extension_25 4142 enum VK_AMD_EXTENSION_25_SPEC_VERSION = 0; 4143 enum VK_AMD_EXTENSION_25_EXTENSION_NAME = "VK_AMD_extension_25"; 4144 4145 // VK_AMD_gcn_shader 4146 enum VK_AMD_GCN_SHADER_SPEC_VERSION = 1; 4147 enum VK_AMD_GCN_SHADER_EXTENSION_NAME = "VK_AMD_gcn_shader"; 4148 4149 // VK_NV_dedicated_allocation 4150 enum VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION = 1; 4151 enum VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME = "VK_NV_dedicated_allocation"; 4152 4153 struct VkDedicatedAllocationImageCreateInfoNV { 4154 VkStructureType sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; 4155 const( void )* pNext; 4156 VkBool32 dedicatedAllocation; 4157 } 4158 4159 struct VkDedicatedAllocationBufferCreateInfoNV { 4160 VkStructureType sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; 4161 const( void )* pNext; 4162 VkBool32 dedicatedAllocation; 4163 } 4164 4165 struct VkDedicatedAllocationMemoryAllocateInfoNV { 4166 VkStructureType sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; 4167 const( void )* pNext; 4168 VkImage image; 4169 VkBuffer buffer; 4170 } 4171 4172 // VK_EXT_extension_28 4173 enum VK_EXT_EXTENSION_28_SPEC_VERSION = 0; 4174 enum VK_EXT_EXTENSION_28_EXTENSION_NAME = "VK_NV_extension_28"; 4175 4176 // VK_NVX_extension_29 4177 enum VK_NVX_EXTENSION_29_SPEC_VERSION = 0; 4178 enum VK_NVX_EXTENSION_29_EXTENSION_NAME = "VK_NVX_extension_29"; 4179 4180 // VK_NVX_extension_30 4181 enum VK_NVX_EXTENSION_30_SPEC_VERSION = 0; 4182 enum VK_NVX_EXTENSION_30_EXTENSION_NAME = "VK_NVX_extension_30"; 4183 4184 // VK_NVX_extension_31 4185 enum VK_NVX_EXTENSION_31_SPEC_VERSION = 0; 4186 enum VK_NVX_EXTENSION_31_EXTENSION_NAME = "VK_NVX_extension_31"; 4187 4188 // VK_AMD_extension_32 4189 enum VK_AMD_EXTENSION_32_SPEC_VERSION = 0; 4190 enum VK_AMD_EXTENSION_32_EXTENSION_NAME = "VK_AMD_extension_32"; 4191 4192 // VK_AMD_extension_33 4193 enum VK_AMD_EXTENSION_33_SPEC_VERSION = 0; 4194 enum VK_AMD_EXTENSION_33_EXTENSION_NAME = "VK_AMD_extension_33"; 4195 4196 // VK_AMD_draw_indirect_count 4197 enum VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION = 1; 4198 enum VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME = "VK_AMD_draw_indirect_count"; 4199 4200 // VK_AMD_extension_35 4201 enum VK_AMD_EXTENSION_35_SPEC_VERSION = 0; 4202 enum VK_AMD_EXTENSION_35_EXTENSION_NAME = "VK_AMD_extension_35"; 4203 4204 // VK_AMD_negative_viewport_height 4205 enum VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION = 1; 4206 enum VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME = "VK_AMD_negative_viewport_height"; 4207 4208 // VK_AMD_gpu_shader_half_float 4209 enum VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION = 1; 4210 enum VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME = "VK_AMD_gpu_shader_half_float"; 4211 4212 // VK_AMD_shader_ballot 4213 enum VK_AMD_SHADER_BALLOT_SPEC_VERSION = 1; 4214 enum VK_AMD_SHADER_BALLOT_EXTENSION_NAME = "VK_AMD_shader_ballot"; 4215 4216 // VK_AMD_extension_39 4217 enum VK_AMD_EXTENSION_39_SPEC_VERSION = 0; 4218 enum VK_AMD_EXTENSION_39_EXTENSION_NAME = "VK_AMD_extension_39"; 4219 4220 // VK_AMD_extension_40 4221 enum VK_AMD_EXTENSION_40_SPEC_VERSION = 0; 4222 enum VK_AMD_EXTENSION_40_EXTENSION_NAME = "VK_AMD_extension_40"; 4223 4224 // VK_AMD_extension_41 4225 enum VK_AMD_EXTENSION_41_SPEC_VERSION = 0; 4226 enum VK_AMD_EXTENSION_41_EXTENSION_NAME = "VK_AMD_extension_41"; 4227 4228 // VK_AMD_extension_42 4229 enum VK_AMD_EXTENSION_42_SPEC_VERSION = 0; 4230 enum VK_AMD_EXTENSION_42_EXTENSION_NAME = "VK_AMD_extension_42"; 4231 4232 // VK_AMD_extension_43 4233 enum VK_AMD_EXTENSION_43_SPEC_VERSION = 0; 4234 enum VK_AMD_EXTENSION_43_EXTENSION_NAME = "VK_AMD_extension_43"; 4235 4236 // VK_AMD_extension_44 4237 enum VK_AMD_EXTENSION_44_SPEC_VERSION = 0; 4238 enum VK_AMD_EXTENSION_44_EXTENSION_NAME = "VK_AMD_extension_44"; 4239 4240 // VK_AMD_extension_45 4241 enum VK_AMD_EXTENSION_45_SPEC_VERSION = 0; 4242 enum VK_AMD_EXTENSION_45_EXTENSION_NAME = "VK_AMD_extension_45"; 4243 4244 // VK_AMD_extension_46 4245 enum VK_AMD_EXTENSION_46_SPEC_VERSION = 0; 4246 enum VK_AMD_EXTENSION_46_EXTENSION_NAME = "VK_AMD_extension_46"; 4247 4248 // VK_AMD_extension_47 4249 enum VK_AMD_EXTENSION_47_SPEC_VERSION = 0; 4250 enum VK_AMD_EXTENSION_47_EXTENSION_NAME = "VK_AMD_extension_47"; 4251 4252 // VK_NVX_extension_48 4253 enum VK_NVX_EXTENSION_48_SPEC_VERSION = 0; 4254 enum VK_NVX_EXTENSION_48_EXTENSION_NAME = "VK_NVX_extension_48"; 4255 4256 // VK_GOOGLE_extension_49 4257 enum VK_GOOGLE_EXTENSION_49_SPEC_VERSION = 0; 4258 enum VK_GOOGLE_EXTENSION_49_EXTENSION_NAME = "VK_GOOGLE_extension_49"; 4259 4260 // VK_GOOGLE_extension_50 4261 enum VK_GOOGLE_EXTENSION_50_SPEC_VERSION = 0; 4262 enum VK_GOOGLE_EXTENSION_50_EXTENSION_NAME = "VK_GOOGLE_extension_50"; 4263 4264 // VK_NVX_extension_51 4265 enum VK_NVX_EXTENSION_51_SPEC_VERSION = 0; 4266 enum VK_NVX_EXTENSION_51_EXTENSION_NAME = "VK_NVX_extension_51"; 4267 4268 // VK_NVX_extension_52 4269 enum VK_NVX_EXTENSION_52_SPEC_VERSION = 0; 4270 enum VK_NVX_EXTENSION_52_EXTENSION_NAME = "VK_NVX_extension_52"; 4271 4272 // VK_NV_extension_53 4273 enum VK_NV_EXTENSION_53_SPEC_VERSION = 0; 4274 enum VK_NV_EXTENSION_53_EXTENSION_NAME = "VK_NV_extension_53"; 4275 4276 // VK_KHX_multiview 4277 enum VK_KHX_MULTIVIEW_SPEC_VERSION = 1; 4278 enum VK_KHX_MULTIVIEW_EXTENSION_NAME = "VK_KHX_multiview"; 4279 4280 struct VkRenderPassMultiviewCreateInfoKHX { 4281 VkStructureType sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX; 4282 const( void )* pNext; 4283 uint32_t subpassCount; 4284 const( uint32_t )* pViewMasks; 4285 uint32_t dependencyCount; 4286 const( int32_t )* pViewOffsets; 4287 uint32_t correlationMaskCount; 4288 const( uint32_t )* pCorrelationMasks; 4289 } 4290 4291 struct VkPhysicalDeviceMultiviewFeaturesKHX { 4292 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX; 4293 void* pNext; 4294 VkBool32 multiview; 4295 VkBool32 multiviewGeometryShader; 4296 VkBool32 multiviewTessellationShader; 4297 } 4298 4299 struct VkPhysicalDeviceMultiviewPropertiesKHX { 4300 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX; 4301 void* pNext; 4302 uint32_t maxMultiviewViewCount; 4303 uint32_t maxMultiviewInstanceIndex; 4304 } 4305 4306 // VK_IMG_format_pvrtc 4307 enum VK_IMG_FORMAT_PVRTC_SPEC_VERSION = 1; 4308 enum VK_IMG_FORMAT_PVRTC_EXTENSION_NAME = "VK_IMG_format_pvrtc"; 4309 4310 // VK_NV_external_memory_capabilities 4311 enum VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1; 4312 enum VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME = "VK_NV_external_memory_capabilities"; 4313 4314 4315 enum VkExternalMemoryHandleTypeFlagBitsNV { 4316 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, 4317 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, 4318 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, 4319 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, 4320 VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF 4321 } 4322 4323 // VkExternalMemoryHandleTypeFlagBitsNV global enums 4324 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = VkExternalMemoryHandleTypeFlagBitsNV.VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV; 4325 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = VkExternalMemoryHandleTypeFlagBitsNV.VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV; 4326 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = VkExternalMemoryHandleTypeFlagBitsNV.VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV; 4327 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = VkExternalMemoryHandleTypeFlagBitsNV.VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV; 4328 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = VkExternalMemoryHandleTypeFlagBitsNV.VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV; 4329 alias VkExternalMemoryHandleTypeFlagsNV = VkFlags; 4330 4331 enum VkExternalMemoryFeatureFlagBitsNV { 4332 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, 4333 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, 4334 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, 4335 VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF 4336 } 4337 4338 // VkExternalMemoryFeatureFlagBitsNV global enums 4339 enum VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = VkExternalMemoryFeatureFlagBitsNV.VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV; 4340 enum VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = VkExternalMemoryFeatureFlagBitsNV.VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV; 4341 enum VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = VkExternalMemoryFeatureFlagBitsNV.VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV; 4342 enum VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = VkExternalMemoryFeatureFlagBitsNV.VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV; 4343 alias VkExternalMemoryFeatureFlagsNV = VkFlags; 4344 4345 struct VkExternalImageFormatPropertiesNV { 4346 VkImageFormatProperties imageFormatProperties; 4347 VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; 4348 VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; 4349 VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; 4350 } 4351 4352 // VK_NV_external_memory 4353 enum VK_NV_EXTERNAL_MEMORY_SPEC_VERSION = 1; 4354 enum VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_NV_external_memory"; 4355 4356 struct VkExternalMemoryImageCreateInfoNV { 4357 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; 4358 const( void )* pNext; 4359 VkExternalMemoryHandleTypeFlagsNV handleTypes; 4360 } 4361 4362 struct VkExportMemoryAllocateInfoNV { 4363 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV; 4364 const( void )* pNext; 4365 VkExternalMemoryHandleTypeFlagsNV handleTypes; 4366 } 4367 4368 // VK_NV_external_memory_win32 4369 version( VK_USE_PLATFORM_WIN32_KHR ) { 4370 public import core.sys.windows.winnt; 4371 4372 enum VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; 4373 enum VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_NV_external_memory_win32"; 4374 4375 struct VkImportMemoryWin32HandleInfoNV { 4376 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; 4377 const( void )* pNext; 4378 VkExternalMemoryHandleTypeFlagsNV handleType; 4379 HANDLE handle; 4380 } 4381 4382 struct VkExportMemoryWin32HandleInfoNV { 4383 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; 4384 const( void )* pNext; 4385 const( SECURITY_ATTRIBUTES )* pAttributes; 4386 DWORD dwAccess; 4387 } 4388 } 4389 4390 // VK_NV_win32_keyed_mutex 4391 version( VK_USE_PLATFORM_WIN32_KHR ) { 4392 4393 enum VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION = 1; 4394 enum VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_NV_win32_keyed_mutex"; 4395 4396 struct VkWin32KeyedMutexAcquireReleaseInfoNV { 4397 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; 4398 const( void )* pNext; 4399 uint32_t acquireCount; 4400 const( VkDeviceMemory )* pAcquireSyncs; 4401 const( uint64_t )* pAcquireKeys; 4402 const( uint32_t )* pAcquireTimeoutMilliseconds; 4403 uint32_t releaseCount; 4404 const( VkDeviceMemory )* pReleaseSyncs; 4405 const( uint64_t )* pReleaseKeys; 4406 } 4407 } 4408 4409 // VK_KHX_device_group 4410 enum VK_MAX_DEVICE_GROUP_SIZE_KHX = 32; 4411 enum VK_KHX_DEVICE_GROUP_SPEC_VERSION = 1; 4412 enum VK_KHX_DEVICE_GROUP_EXTENSION_NAME = "VK_KHX_device_group"; 4413 4414 4415 enum VkPeerMemoryFeatureFlagBitsKHX { 4416 VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = 0x00000001, 4417 VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = 0x00000002, 4418 VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 0x00000004, 4419 VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 0x00000008, 4420 VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF 4421 } 4422 4423 // VkPeerMemoryFeatureFlagBitsKHX global enums 4424 enum VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = VkPeerMemoryFeatureFlagBitsKHX.VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX; 4425 enum VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = VkPeerMemoryFeatureFlagBitsKHX.VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX; 4426 enum VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = VkPeerMemoryFeatureFlagBitsKHX.VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX; 4427 enum VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = VkPeerMemoryFeatureFlagBitsKHX.VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX; 4428 enum VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = VkPeerMemoryFeatureFlagBitsKHX.VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX; 4429 alias VkPeerMemoryFeatureFlagsKHX = VkFlags; 4430 4431 enum VkMemoryAllocateFlagBitsKHX { 4432 VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 0x00000001, 4433 VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF 4434 } 4435 4436 // VkMemoryAllocateFlagBitsKHX global enums 4437 enum VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = VkMemoryAllocateFlagBitsKHX.VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX; 4438 enum VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX = VkMemoryAllocateFlagBitsKHX.VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX; 4439 alias VkMemoryAllocateFlagsKHX = VkFlags; 4440 4441 enum VkDeviceGroupPresentModeFlagBitsKHX { 4442 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = 0x00000001, 4443 VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = 0x00000002, 4444 VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = 0x00000004, 4445 VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 0x00000008, 4446 VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF 4447 } 4448 4449 // VkDeviceGroupPresentModeFlagBitsKHX global enums 4450 enum VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = VkDeviceGroupPresentModeFlagBitsKHX.VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX; 4451 enum VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = VkDeviceGroupPresentModeFlagBitsKHX.VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX; 4452 enum VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = VkDeviceGroupPresentModeFlagBitsKHX.VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX; 4453 enum VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = VkDeviceGroupPresentModeFlagBitsKHX.VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX; 4454 enum VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX = VkDeviceGroupPresentModeFlagBitsKHX.VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX; 4455 alias VkDeviceGroupPresentModeFlagsKHX = VkFlags; 4456 4457 struct VkMemoryAllocateFlagsInfoKHX { 4458 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX; 4459 const( void )* pNext; 4460 VkMemoryAllocateFlagsKHX flags; 4461 uint32_t deviceMask; 4462 } 4463 4464 struct VkBindBufferMemoryInfoKHX { 4465 VkStructureType sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHX; 4466 const( void )* pNext; 4467 VkBuffer buffer; 4468 VkDeviceMemory memory; 4469 VkDeviceSize memoryOffset; 4470 uint32_t deviceIndexCount; 4471 const( uint32_t )* pDeviceIndices; 4472 } 4473 4474 struct VkBindImageMemoryInfoKHX { 4475 VkStructureType sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHX; 4476 const( void )* pNext; 4477 VkImage image; 4478 VkDeviceMemory memory; 4479 VkDeviceSize memoryOffset; 4480 uint32_t deviceIndexCount; 4481 const( uint32_t )* pDeviceIndices; 4482 uint32_t SFRRectCount; 4483 const( VkRect2D )* pSFRRects; 4484 } 4485 4486 struct VkDeviceGroupRenderPassBeginInfoKHX { 4487 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX; 4488 const( void )* pNext; 4489 uint32_t deviceMask; 4490 uint32_t deviceRenderAreaCount; 4491 const( VkRect2D )* pDeviceRenderAreas; 4492 } 4493 4494 struct VkDeviceGroupCommandBufferBeginInfoKHX { 4495 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX; 4496 const( void )* pNext; 4497 uint32_t deviceMask; 4498 } 4499 4500 struct VkDeviceGroupSubmitInfoKHX { 4501 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX; 4502 const( void )* pNext; 4503 uint32_t waitSemaphoreCount; 4504 const( uint32_t )* pWaitSemaphoreDeviceIndices; 4505 uint32_t commandBufferCount; 4506 const( uint32_t )* pCommandBufferDeviceMasks; 4507 uint32_t signalSemaphoreCount; 4508 const( uint32_t )* pSignalSemaphoreDeviceIndices; 4509 } 4510 4511 struct VkDeviceGroupBindSparseInfoKHX { 4512 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX; 4513 const( void )* pNext; 4514 uint32_t resourceDeviceIndex; 4515 uint32_t memoryDeviceIndex; 4516 } 4517 4518 struct VkDeviceGroupPresentCapabilitiesKHX { 4519 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX; 4520 const( void )* pNext; 4521 uint32_t[ VK_MAX_DEVICE_GROUP_SIZE_KHX ] presentMask; 4522 VkDeviceGroupPresentModeFlagsKHX modes; 4523 } 4524 4525 struct VkImageSwapchainCreateInfoKHX { 4526 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX; 4527 const( void )* pNext; 4528 VkSwapchainKHR swapchain; 4529 } 4530 4531 struct VkBindImageMemorySwapchainInfoKHX { 4532 VkStructureType sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX; 4533 const( void )* pNext; 4534 VkSwapchainKHR swapchain; 4535 uint32_t imageIndex; 4536 } 4537 4538 struct VkAcquireNextImageInfoKHX { 4539 VkStructureType sType = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX; 4540 const( void )* pNext; 4541 VkSwapchainKHR swapchain; 4542 uint64_t timeout; 4543 VkSemaphore semaphore; 4544 VkFence fence; 4545 uint32_t deviceMask; 4546 } 4547 4548 struct VkDeviceGroupPresentInfoKHX { 4549 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX; 4550 const( void )* pNext; 4551 uint32_t swapchainCount; 4552 const( uint32_t )* pDeviceMasks; 4553 VkDeviceGroupPresentModeFlagBitsKHX mode; 4554 } 4555 4556 struct VkDeviceGroupSwapchainCreateInfoKHX { 4557 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX; 4558 const( void )* pNext; 4559 VkDeviceGroupPresentModeFlagsKHX modes; 4560 } 4561 4562 // VK_EXT_validation_flags 4563 enum VK_EXT_VALIDATION_FLAGS_SPEC_VERSION = 1; 4564 enum VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME = "VK_EXT_validation_flags"; 4565 4566 4567 enum VkValidationCheckEXT { 4568 VK_VALIDATION_CHECK_ALL_EXT = 0, 4569 VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, 4570 VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, 4571 VK_VALIDATION_CHECK_RANGE_SIZE_EXT = ( VK_VALIDATION_CHECK_ALL_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1 ), 4572 VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF 4573 } 4574 4575 // VkValidationCheckEXT global enums 4576 enum VK_VALIDATION_CHECK_ALL_EXT = VkValidationCheckEXT.VK_VALIDATION_CHECK_ALL_EXT; 4577 enum VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VkValidationCheckEXT.VK_VALIDATION_CHECK_BEGIN_RANGE_EXT; 4578 enum VK_VALIDATION_CHECK_END_RANGE_EXT = VkValidationCheckEXT.VK_VALIDATION_CHECK_END_RANGE_EXT; 4579 enum VK_VALIDATION_CHECK_RANGE_SIZE_EXT = VkValidationCheckEXT.VK_VALIDATION_CHECK_RANGE_SIZE_EXT; 4580 enum VK_VALIDATION_CHECK_MAX_ENUM_EXT = VkValidationCheckEXT.VK_VALIDATION_CHECK_MAX_ENUM_EXT; 4581 4582 struct VkValidationFlagsEXT { 4583 VkStructureType sType; 4584 const( void )* pNext; 4585 uint32_t disabledValidationCheckCount; 4586 VkValidationCheckEXT* pDisabledValidationChecks; 4587 } 4588 4589 // VK_NN_vi_surface 4590 enum VK_NN_VI_SURFACE_SPEC_VERSION = 1; 4591 enum VK_NN_VI_SURFACE_EXTENSION_NAME = "VK_NN_vi_surface"; 4592 4593 alias VkViSurfaceCreateFlagsNN = VkFlags; 4594 4595 struct VkViSurfaceCreateInfoNN { 4596 VkStructureType sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN; 4597 const( void )* pNext; 4598 VkViSurfaceCreateFlagsNN flags; 4599 void* window; 4600 } 4601 4602 // VK_EXT_shader_subgroup_ballot 4603 enum VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION = 1; 4604 enum VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME = "VK_EXT_shader_subgroup_ballot"; 4605 4606 // VK_EXT_shader_subgroup_vote 4607 enum VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION = 1; 4608 enum VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME = "VK_EXT_shader_subgroup_vote"; 4609 4610 // VK_ARM_extension_01 4611 enum VK_ARM_EXTENSION_01_SPEC_VERSION = 0; 4612 enum VK_ARM_EXTENSION_01_EXTENSION_NAME = "VK_ARM_extension_01"; 4613 4614 // VK_ARM_extension_02 4615 enum VK_ARM_EXTENSION_02_SPEC_VERSION = 0; 4616 enum VK_ARM_EXTENSION_02_EXTENSION_NAME = "VK_ARM_extension_02"; 4617 4618 // VK_IMG_extension_69 4619 enum VK_IMG_EXTENSION_69_SPEC_VERSION = 0; 4620 enum VK_IMG_EXTENSION_69_EXTENSION_NAME = "VK_IMG_extension_69"; 4621 4622 // VK_KHX_device_group_creation 4623 enum VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION = 1; 4624 enum VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME = "VK_KHX_device_group_creation"; 4625 4626 struct VkPhysicalDeviceGroupPropertiesKHX { 4627 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX; 4628 const( void )* pNext; 4629 uint32_t physicalDeviceCount; 4630 VkPhysicalDevice[ VK_MAX_DEVICE_GROUP_SIZE_KHX ] physicalDevices; 4631 VkBool32 subsetAllocation; 4632 } 4633 4634 struct VkDeviceGroupDeviceCreateInfoKHX { 4635 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX; 4636 const( void )* pNext; 4637 uint32_t physicalDeviceCount; 4638 const( VkPhysicalDevice )* pPhysicalDevices; 4639 } 4640 4641 // VK_KHX_external_memory_capabilities 4642 enum VK_LUID_SIZE_KHX = 8; 4643 enum VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1; 4644 enum VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME = "VK_KHX_external_memory_capabilities"; 4645 4646 4647 enum VkExternalMemoryHandleTypeFlagBitsKHX { 4648 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001, 4649 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002, 4650 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004, 4651 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX = 0x00000008, 4652 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX = 0x00000010, 4653 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX = 0x00000020, 4654 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX = 0x00000040, 4655 VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF 4656 } 4657 4658 // VkExternalMemoryHandleTypeFlagBitsKHX global enums 4659 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = VkExternalMemoryHandleTypeFlagBitsKHX.VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX; 4660 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = VkExternalMemoryHandleTypeFlagBitsKHX.VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX; 4661 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = VkExternalMemoryHandleTypeFlagBitsKHX.VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX; 4662 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX = VkExternalMemoryHandleTypeFlagBitsKHX.VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX; 4663 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX = VkExternalMemoryHandleTypeFlagBitsKHX.VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX; 4664 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX = VkExternalMemoryHandleTypeFlagBitsKHX.VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX; 4665 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX = VkExternalMemoryHandleTypeFlagBitsKHX.VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX; 4666 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = VkExternalMemoryHandleTypeFlagBitsKHX.VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX; 4667 alias VkExternalMemoryHandleTypeFlagsKHX = VkFlags; 4668 4669 enum VkExternalMemoryFeatureFlagBitsKHX { 4670 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX = 0x00000001, 4671 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX = 0x00000002, 4672 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX = 0x00000004, 4673 VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF 4674 } 4675 4676 // VkExternalMemoryFeatureFlagBitsKHX global enums 4677 enum VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX = VkExternalMemoryFeatureFlagBitsKHX.VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX; 4678 enum VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX = VkExternalMemoryFeatureFlagBitsKHX.VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX; 4679 enum VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX = VkExternalMemoryFeatureFlagBitsKHX.VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX; 4680 enum VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = VkExternalMemoryFeatureFlagBitsKHX.VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX; 4681 alias VkExternalMemoryFeatureFlagsKHX = VkFlags; 4682 4683 struct VkExternalMemoryPropertiesKHX { 4684 VkExternalMemoryFeatureFlagsKHX externalMemoryFeatures; 4685 VkExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes; 4686 VkExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes; 4687 } 4688 4689 struct VkPhysicalDeviceExternalImageFormatInfoKHX { 4690 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX; 4691 const( void )* pNext; 4692 VkExternalMemoryHandleTypeFlagBitsKHX handleType; 4693 } 4694 4695 struct VkExternalImageFormatPropertiesKHX { 4696 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX; 4697 void* pNext; 4698 VkExternalMemoryPropertiesKHX externalMemoryProperties; 4699 } 4700 4701 struct VkPhysicalDeviceExternalBufferInfoKHX { 4702 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX; 4703 const( void )* pNext; 4704 VkBufferCreateFlags flags; 4705 VkBufferUsageFlags usage; 4706 VkExternalMemoryHandleTypeFlagBitsKHX handleType; 4707 } 4708 4709 struct VkExternalBufferPropertiesKHX { 4710 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX; 4711 void* pNext; 4712 VkExternalMemoryPropertiesKHX externalMemoryProperties; 4713 } 4714 4715 struct VkPhysicalDeviceIDPropertiesKHX { 4716 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX; 4717 void* pNext; 4718 uint8_t[ VK_UUID_SIZE ] deviceUUID; 4719 uint8_t[ VK_UUID_SIZE ] driverUUID; 4720 uint8_t[ VK_LUID_SIZE_KHX ] deviceLUID; 4721 VkBool32 deviceLUIDValid; 4722 } 4723 4724 // VK_KHX_external_memory 4725 enum VK_KHX_EXTERNAL_MEMORY_SPEC_VERSION = 1; 4726 enum VK_KHX_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_KHX_external_memory"; 4727 enum VK_QUEUE_FAMILY_EXTERNAL_KHX = (~0U-1); 4728 4729 struct VkExternalMemoryImageCreateInfoKHX { 4730 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX; 4731 const( void )* pNext; 4732 VkExternalMemoryHandleTypeFlagsKHX handleTypes; 4733 } 4734 4735 struct VkExternalMemoryBufferCreateInfoKHX { 4736 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX; 4737 const( void )* pNext; 4738 VkExternalMemoryHandleTypeFlagsKHX handleTypes; 4739 } 4740 4741 struct VkExportMemoryAllocateInfoKHX { 4742 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX; 4743 const( void )* pNext; 4744 VkExternalMemoryHandleTypeFlagsKHX handleTypes; 4745 } 4746 4747 // VK_KHX_external_memory_win32 4748 version( VK_USE_PLATFORM_WIN32_KHR ) { 4749 4750 enum VK_KHX_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; 4751 enum VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_KHX_external_memory_win32"; 4752 4753 struct VkImportMemoryWin32HandleInfoKHX { 4754 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX; 4755 const( void )* pNext; 4756 VkExternalMemoryHandleTypeFlagBitsKHX handleType; 4757 HANDLE handle; 4758 } 4759 4760 struct VkExportMemoryWin32HandleInfoKHX { 4761 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX; 4762 const( void )* pNext; 4763 const( SECURITY_ATTRIBUTES )* pAttributes; 4764 DWORD dwAccess; 4765 LPCWSTR name; 4766 } 4767 4768 struct VkMemoryWin32HandlePropertiesKHX { 4769 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX; 4770 void* pNext; 4771 uint32_t memoryTypeBits; 4772 } 4773 } 4774 4775 // VK_KHX_external_memory_fd 4776 enum VK_KHX_EXTERNAL_MEMORY_FD_SPEC_VERSION = 1; 4777 enum VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME = "VK_KHX_external_memory_fd"; 4778 4779 struct VkImportMemoryFdInfoKHX { 4780 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX; 4781 const( void )* pNext; 4782 VkExternalMemoryHandleTypeFlagBitsKHX handleType; 4783 int fd; 4784 } 4785 4786 struct VkMemoryFdPropertiesKHX { 4787 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX; 4788 void* pNext; 4789 uint32_t memoryTypeBits; 4790 } 4791 4792 // VK_KHX_win32_keyed_mutex 4793 version( VK_USE_PLATFORM_WIN32_KHR ) { 4794 4795 enum VK_KHX_WIN32_KEYED_MUTEX_SPEC_VERSION = 1; 4796 enum VK_KHX_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_KHX_win32_keyed_mutex"; 4797 4798 struct VkWin32KeyedMutexAcquireReleaseInfoKHX { 4799 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX; 4800 const( void )* pNext; 4801 uint32_t acquireCount; 4802 const( VkDeviceMemory )* pAcquireSyncs; 4803 const( uint64_t )* pAcquireKeys; 4804 const( uint32_t )* pAcquireTimeouts; 4805 uint32_t releaseCount; 4806 const( VkDeviceMemory )* pReleaseSyncs; 4807 const( uint64_t )* pReleaseKeys; 4808 } 4809 } 4810 4811 // VK_KHX_external_semaphore_capabilities 4812 enum VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION = 1; 4813 enum VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME = "VK_KHX_external_semaphore_capabilities"; 4814 4815 4816 enum VkExternalSemaphoreHandleTypeFlagBitsKHX { 4817 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001, 4818 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002, 4819 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004, 4820 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX = 0x00000008, 4821 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX = 0x00000010, 4822 VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF 4823 } 4824 4825 // VkExternalSemaphoreHandleTypeFlagBitsKHX global enums 4826 enum VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = VkExternalSemaphoreHandleTypeFlagBitsKHX.VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX; 4827 enum VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = VkExternalSemaphoreHandleTypeFlagBitsKHX.VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX; 4828 enum VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = VkExternalSemaphoreHandleTypeFlagBitsKHX.VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX; 4829 enum VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX = VkExternalSemaphoreHandleTypeFlagBitsKHX.VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX; 4830 enum VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX = VkExternalSemaphoreHandleTypeFlagBitsKHX.VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX; 4831 enum VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = VkExternalSemaphoreHandleTypeFlagBitsKHX.VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX; 4832 alias VkExternalSemaphoreHandleTypeFlagsKHX = VkFlags; 4833 4834 enum VkExternalSemaphoreFeatureFlagBitsKHX { 4835 VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX = 0x00000001, 4836 VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX = 0x00000002, 4837 VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF 4838 } 4839 4840 // VkExternalSemaphoreFeatureFlagBitsKHX global enums 4841 enum VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX = VkExternalSemaphoreFeatureFlagBitsKHX.VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX; 4842 enum VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX = VkExternalSemaphoreFeatureFlagBitsKHX.VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX; 4843 enum VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHX = VkExternalSemaphoreFeatureFlagBitsKHX.VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHX; 4844 alias VkExternalSemaphoreFeatureFlagsKHX = VkFlags; 4845 4846 struct VkPhysicalDeviceExternalSemaphoreInfoKHX { 4847 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX; 4848 const( void )* pNext; 4849 VkExternalSemaphoreHandleTypeFlagBitsKHX handleType; 4850 } 4851 4852 struct VkExternalSemaphorePropertiesKHX { 4853 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX; 4854 void* pNext; 4855 VkExternalSemaphoreHandleTypeFlagsKHX exportFromImportedHandleTypes; 4856 VkExternalSemaphoreHandleTypeFlagsKHX compatibleHandleTypes; 4857 VkExternalSemaphoreFeatureFlagsKHX externalSemaphoreFeatures; 4858 } 4859 4860 // VK_KHX_external_semaphore 4861 enum VK_KHX_EXTERNAL_SEMAPHORE_SPEC_VERSION = 1; 4862 enum VK_KHX_EXTERNAL_SEMAPHORE_EXTENSION_NAME = "VK_KHX_external_semaphore"; 4863 4864 struct VkExportSemaphoreCreateInfoKHX { 4865 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX; 4866 const( void )* pNext; 4867 VkExternalSemaphoreHandleTypeFlagsKHX handleTypes; 4868 } 4869 4870 // VK_KHX_external_semaphore_win32 4871 version( VK_USE_PLATFORM_WIN32_KHR ) { 4872 4873 enum VK_KHX_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION = 1; 4874 enum VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME = "VK_KHX_external_semaphore_win32"; 4875 4876 struct VkImportSemaphoreWin32HandleInfoKHX { 4877 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX; 4878 const( void )* pNext; 4879 VkSemaphore semaphore; 4880 VkExternalSemaphoreHandleTypeFlagsKHX handleType; 4881 HANDLE handle; 4882 } 4883 4884 struct VkExportSemaphoreWin32HandleInfoKHX { 4885 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX; 4886 const( void )* pNext; 4887 const( SECURITY_ATTRIBUTES )* pAttributes; 4888 DWORD dwAccess; 4889 LPCWSTR name; 4890 } 4891 4892 struct VkD3D12FenceSubmitInfoKHX { 4893 VkStructureType sType = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX; 4894 const( void )* pNext; 4895 uint32_t waitSemaphoreValuesCount; 4896 const( uint64_t )* pWaitSemaphoreValues; 4897 uint32_t signalSemaphoreValuesCount; 4898 const( uint64_t )* pSignalSemaphoreValues; 4899 } 4900 } 4901 4902 // VK_KHX_external_semaphore_fd 4903 enum VK_KHX_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION = 1; 4904 enum VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME = "VK_KHX_external_semaphore_fd"; 4905 4906 struct VkImportSemaphoreFdInfoKHX { 4907 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX; 4908 const( void )* pNext; 4909 VkSemaphore semaphore; 4910 VkExternalSemaphoreHandleTypeFlagBitsKHX handleType; 4911 int fd; 4912 } 4913 4914 // VK_NVX_device_generated_commands 4915 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkObjectTableNVX} ); 4916 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkIndirectCommandsLayoutNVX} ); 4917 4918 enum VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION = 1; 4919 enum VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME = "VK_NVX_device_generated_commands"; 4920 4921 4922 enum VkIndirectCommandsTokenTypeNVX { 4923 VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX = 0, 4924 VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX = 1, 4925 VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX = 2, 4926 VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX = 3, 4927 VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX = 4, 4928 VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX = 5, 4929 VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX = 6, 4930 VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX = 7, 4931 VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX, 4932 VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX, 4933 VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = ( VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX + 1 ), 4934 VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF 4935 } 4936 4937 // VkIndirectCommandsTokenTypeNVX global enums 4938 enum VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX; 4939 enum VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX; 4940 enum VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX; 4941 enum VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX; 4942 enum VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX; 4943 enum VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX; 4944 enum VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX; 4945 enum VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX; 4946 enum VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX; 4947 enum VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX; 4948 enum VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX; 4949 enum VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = VkIndirectCommandsTokenTypeNVX.VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX; 4950 4951 enum VkObjectEntryTypeNVX { 4952 VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = 0, 4953 VK_OBJECT_ENTRY_PIPELINE_NVX = 1, 4954 VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = 2, 4955 VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = 3, 4956 VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = 4, 4957 VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX, 4958 VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX, 4959 VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = ( VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX + 1 ), 4960 VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF 4961 } 4962 4963 // VkObjectEntryTypeNVX global enums 4964 enum VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = VkObjectEntryTypeNVX.VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX; 4965 enum VK_OBJECT_ENTRY_PIPELINE_NVX = VkObjectEntryTypeNVX.VK_OBJECT_ENTRY_PIPELINE_NVX; 4966 enum VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = VkObjectEntryTypeNVX.VK_OBJECT_ENTRY_INDEX_BUFFER_NVX; 4967 enum VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = VkObjectEntryTypeNVX.VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX; 4968 enum VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = VkObjectEntryTypeNVX.VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX; 4969 enum VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VkObjectEntryTypeNVX.VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX; 4970 enum VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VkObjectEntryTypeNVX.VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX; 4971 enum VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = VkObjectEntryTypeNVX.VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX; 4972 enum VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = VkObjectEntryTypeNVX.VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX; 4973 4974 4975 enum VkIndirectCommandsLayoutUsageFlagBitsNVX { 4976 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001, 4977 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002, 4978 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004, 4979 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008, 4980 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF 4981 } 4982 4983 // VkIndirectCommandsLayoutUsageFlagBitsNVX global enums 4984 enum VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = VkIndirectCommandsLayoutUsageFlagBitsNVX.VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX; 4985 enum VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = VkIndirectCommandsLayoutUsageFlagBitsNVX.VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX; 4986 enum VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = VkIndirectCommandsLayoutUsageFlagBitsNVX.VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX; 4987 enum VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = VkIndirectCommandsLayoutUsageFlagBitsNVX.VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX; 4988 enum VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = VkIndirectCommandsLayoutUsageFlagBitsNVX.VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX; 4989 alias VkIndirectCommandsLayoutUsageFlagsNVX = VkFlags; 4990 4991 enum VkObjectEntryUsageFlagBitsNVX { 4992 VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001, 4993 VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002, 4994 VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF 4995 } 4996 4997 // VkObjectEntryUsageFlagBitsNVX global enums 4998 enum VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = VkObjectEntryUsageFlagBitsNVX.VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX; 4999 enum VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = VkObjectEntryUsageFlagBitsNVX.VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX; 5000 enum VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = VkObjectEntryUsageFlagBitsNVX.VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX; 5001 alias VkObjectEntryUsageFlagsNVX = VkFlags; 5002 5003 struct VkDeviceGeneratedCommandsFeaturesNVX { 5004 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX; 5005 const( void )* pNext; 5006 VkBool32 computeBindingPointSupport; 5007 } 5008 5009 struct VkDeviceGeneratedCommandsLimitsNVX { 5010 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX; 5011 const( void )* pNext; 5012 uint32_t maxIndirectCommandsLayoutTokenCount; 5013 uint32_t maxObjectEntryCounts; 5014 uint32_t minSequenceCountBufferOffsetAlignment; 5015 uint32_t minSequenceIndexBufferOffsetAlignment; 5016 uint32_t minCommandsTokenBufferOffsetAlignment; 5017 } 5018 5019 struct VkIndirectCommandsTokenNVX { 5020 VkIndirectCommandsTokenTypeNVX tokenType; 5021 VkBuffer buffer; 5022 VkDeviceSize offset; 5023 } 5024 5025 struct VkIndirectCommandsLayoutTokenNVX { 5026 VkIndirectCommandsTokenTypeNVX tokenType; 5027 uint32_t bindingUnit; 5028 uint32_t dynamicCount; 5029 uint32_t divisor; 5030 } 5031 5032 struct VkIndirectCommandsLayoutCreateInfoNVX { 5033 VkStructureType sType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX; 5034 const( void )* pNext; 5035 VkPipelineBindPoint pipelineBindPoint; 5036 VkIndirectCommandsLayoutUsageFlagsNVX flags; 5037 uint32_t tokenCount; 5038 const( VkIndirectCommandsLayoutTokenNVX )* pTokens; 5039 } 5040 5041 struct VkCmdProcessCommandsInfoNVX { 5042 VkStructureType sType = VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX; 5043 const( void )* pNext; 5044 VkObjectTableNVX objectTable; 5045 VkIndirectCommandsLayoutNVX indirectCommandsLayout; 5046 uint32_t indirectCommandsTokenCount; 5047 const( VkIndirectCommandsTokenNVX )* pIndirectCommandsTokens; 5048 uint32_t maxSequencesCount; 5049 VkCommandBuffer targetCommandBuffer; 5050 VkBuffer sequencesCountBuffer; 5051 VkDeviceSize sequencesCountOffset; 5052 VkBuffer sequencesIndexBuffer; 5053 VkDeviceSize sequencesIndexOffset; 5054 } 5055 5056 struct VkCmdReserveSpaceForCommandsInfoNVX { 5057 VkStructureType sType = VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX; 5058 const( void )* pNext; 5059 VkObjectTableNVX objectTable; 5060 VkIndirectCommandsLayoutNVX indirectCommandsLayout; 5061 uint32_t maxSequencesCount; 5062 } 5063 5064 struct VkObjectTableCreateInfoNVX { 5065 VkStructureType sType = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX; 5066 const( void )* pNext; 5067 uint32_t objectCount; 5068 const( VkObjectEntryTypeNVX )* pObjectEntryTypes; 5069 const( uint32_t )* pObjectEntryCounts; 5070 const( VkObjectEntryUsageFlagsNVX )* pObjectEntryUsageFlags; 5071 uint32_t maxUniformBuffersPerDescriptor; 5072 uint32_t maxStorageBuffersPerDescriptor; 5073 uint32_t maxStorageImagesPerDescriptor; 5074 uint32_t maxSampledImagesPerDescriptor; 5075 uint32_t maxPipelineLayouts; 5076 } 5077 5078 struct VkObjectTableEntryNVX { 5079 VkObjectEntryTypeNVX type; 5080 VkObjectEntryUsageFlagsNVX flags; 5081 } 5082 5083 struct VkObjectTablePipelineEntryNVX { 5084 VkObjectEntryTypeNVX type; 5085 VkObjectEntryUsageFlagsNVX flags; 5086 VkPipeline pipeline; 5087 } 5088 5089 struct VkObjectTableDescriptorSetEntryNVX { 5090 VkObjectEntryTypeNVX type; 5091 VkObjectEntryUsageFlagsNVX flags; 5092 VkPipelineLayout pipelineLayout; 5093 VkDescriptorSet descriptorSet; 5094 } 5095 5096 struct VkObjectTableVertexBufferEntryNVX { 5097 VkObjectEntryTypeNVX type; 5098 VkObjectEntryUsageFlagsNVX flags; 5099 VkBuffer buffer; 5100 } 5101 5102 struct VkObjectTableIndexBufferEntryNVX { 5103 VkObjectEntryTypeNVX type; 5104 VkObjectEntryUsageFlagsNVX flags; 5105 VkBuffer buffer; 5106 VkIndexType indexType; 5107 } 5108 5109 struct VkObjectTablePushConstantEntryNVX { 5110 VkObjectEntryTypeNVX type; 5111 VkObjectEntryUsageFlagsNVX flags; 5112 VkPipelineLayout pipelineLayout; 5113 VkShaderStageFlags stageFlags; 5114 } 5115 5116 // VK_NV_clip_space_w_scaling 5117 enum VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION = 1; 5118 enum VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME = "VK_NV_clip_space_w_scaling"; 5119 5120 struct VkViewportWScalingNV { 5121 float xcoeff; 5122 float ycoeff; 5123 } 5124 5125 struct VkPipelineViewportWScalingStateCreateInfoNV { 5126 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; 5127 const( void )* pNext; 5128 VkBool32 viewportWScalingEnable; 5129 uint32_t viewportCount; 5130 const( VkViewportWScalingNV )* pViewportWScalings; 5131 } 5132 5133 // VK_EXT_direct_mode_display 5134 enum VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION = 1; 5135 enum VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME = "VK_EXT_direct_mode_display"; 5136 5137 // VK_EXT_acquire_xlib_display 5138 version( VK_USE_PLATFORM_XLIB_KHR ) { 5139 5140 enum VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION = 1; 5141 enum VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME = "VK_EXT_acquire_xlib_display"; 5142 } 5143 5144 // VK_EXT_display_surface_counter 5145 enum VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION = 1; 5146 enum VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME = "VK_EXT_display_surface_counter"; 5147 5148 5149 enum VkSurfaceCounterFlagBitsEXT { 5150 VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001, 5151 VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 5152 } 5153 5154 // VkSurfaceCounterFlagBitsEXT global enums 5155 enum VK_SURFACE_COUNTER_VBLANK_EXT = VkSurfaceCounterFlagBitsEXT.VK_SURFACE_COUNTER_VBLANK_EXT; 5156 enum VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = VkSurfaceCounterFlagBitsEXT.VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT; 5157 alias VkSurfaceCounterFlagsEXT = VkFlags; 5158 5159 struct VkSurfaceCapabilities2EXT { 5160 VkStructureType sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT; 5161 void* pNext; 5162 uint32_t minImageCount; 5163 uint32_t maxImageCount; 5164 VkExtent2D currentExtent; 5165 VkExtent2D minImageExtent; 5166 VkExtent2D maxImageExtent; 5167 uint32_t maxImageArrayLayers; 5168 VkSurfaceTransformFlagsKHR supportedTransforms; 5169 VkSurfaceTransformFlagBitsKHR currentTransform; 5170 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 5171 VkImageUsageFlags supportedUsageFlags; 5172 VkSurfaceCounterFlagsEXT supportedSurfaceCounters; 5173 } 5174 5175 // VK_EXT_display_control 5176 enum VK_EXT_DISPLAY_CONTROL_SPEC_VERSION = 1; 5177 enum VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME = "VK_EXT_display_control"; 5178 5179 5180 enum VkDisplayPowerStateEXT { 5181 VK_DISPLAY_POWER_STATE_OFF_EXT = 0, 5182 VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, 5183 VK_DISPLAY_POWER_STATE_ON_EXT = 2, 5184 VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT, 5185 VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT, 5186 VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = ( VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1 ), 5187 VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF 5188 } 5189 5190 // VkDisplayPowerStateEXT global enums 5191 enum VK_DISPLAY_POWER_STATE_OFF_EXT = VkDisplayPowerStateEXT.VK_DISPLAY_POWER_STATE_OFF_EXT; 5192 enum VK_DISPLAY_POWER_STATE_SUSPEND_EXT = VkDisplayPowerStateEXT.VK_DISPLAY_POWER_STATE_SUSPEND_EXT; 5193 enum VK_DISPLAY_POWER_STATE_ON_EXT = VkDisplayPowerStateEXT.VK_DISPLAY_POWER_STATE_ON_EXT; 5194 enum VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VkDisplayPowerStateEXT.VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT; 5195 enum VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VkDisplayPowerStateEXT.VK_DISPLAY_POWER_STATE_END_RANGE_EXT; 5196 enum VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = VkDisplayPowerStateEXT.VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT; 5197 enum VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = VkDisplayPowerStateEXT.VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT; 5198 5199 enum VkDeviceEventTypeEXT { 5200 VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, 5201 VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, 5202 VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT, 5203 VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = ( VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1 ), 5204 VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 5205 } 5206 5207 // VkDeviceEventTypeEXT global enums 5208 enum VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = VkDeviceEventTypeEXT.VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT; 5209 enum VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VkDeviceEventTypeEXT.VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT; 5210 enum VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VkDeviceEventTypeEXT.VK_DEVICE_EVENT_TYPE_END_RANGE_EXT; 5211 enum VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = VkDeviceEventTypeEXT.VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT; 5212 enum VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = VkDeviceEventTypeEXT.VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT; 5213 5214 enum VkDisplayEventTypeEXT { 5215 VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, 5216 VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, 5217 VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT, 5218 VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = ( VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1 ), 5219 VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 5220 } 5221 5222 // VkDisplayEventTypeEXT global enums 5223 enum VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = VkDisplayEventTypeEXT.VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT; 5224 enum VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VkDisplayEventTypeEXT.VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT; 5225 enum VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VkDisplayEventTypeEXT.VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT; 5226 enum VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = VkDisplayEventTypeEXT.VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT; 5227 enum VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = VkDisplayEventTypeEXT.VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT; 5228 5229 struct VkDisplayPowerInfoEXT { 5230 VkStructureType sType = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT; 5231 const( void )* pNext; 5232 VkDisplayPowerStateEXT powerState; 5233 } 5234 5235 struct VkDeviceEventInfoEXT { 5236 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT; 5237 const( void )* pNext; 5238 VkDeviceEventTypeEXT deviceEvent; 5239 } 5240 5241 struct VkDisplayEventInfoEXT { 5242 VkStructureType sType = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT; 5243 const( void )* pNext; 5244 VkDisplayEventTypeEXT displayEvent; 5245 } 5246 5247 struct VkSwapchainCounterCreateInfoEXT { 5248 VkStructureType sType = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT; 5249 const( void )* pNext; 5250 VkSurfaceCounterFlagsEXT surfaceCounters; 5251 } 5252 5253 // VK_GOOGLE_display_timing 5254 enum VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION = 1; 5255 enum VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME = "VK_GOOGLE_display_timing"; 5256 5257 struct VkRefreshCycleDurationGOOGLE { 5258 uint64_t refreshDuration; 5259 } 5260 5261 struct VkPastPresentationTimingGOOGLE { 5262 uint32_t presentID; 5263 uint64_t desiredPresentTime; 5264 uint64_t actualPresentTime; 5265 uint64_t earliestPresentTime; 5266 uint64_t presentMargin; 5267 } 5268 5269 struct VkPresentTimeGOOGLE { 5270 uint32_t presentID; 5271 uint64_t desiredPresentTime; 5272 } 5273 5274 struct VkPresentTimesInfoGOOGLE { 5275 VkStructureType sType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE; 5276 const( void )* pNext; 5277 uint32_t swapchainCount; 5278 const( VkPresentTimeGOOGLE )* pTimes; 5279 } 5280 5281 // VK_NV_sample_mask_override_coverage 5282 enum VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION = 1; 5283 enum VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME = "VK_NV_sample_mask_override_coverage"; 5284 5285 // VK_NV_geometry_shader_passthrough 5286 enum VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION = 1; 5287 enum VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME = "VK_NV_geometry_shader_passthrough"; 5288 5289 // VK_NV_viewport_array2 5290 enum VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION = 1; 5291 enum VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME = "VK_NV_viewport_array2"; 5292 5293 // VK_NVX_multiview_per_view_attributes 5294 enum VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION = 1; 5295 enum VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME = "VK_NVX_multiview_per_view_attributes"; 5296 5297 struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { 5298 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; 5299 void* pNext; 5300 VkBool32 perViewPositionAllComponents; 5301 } 5302 5303 // VK_NV_viewport_swizzle 5304 enum VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION = 1; 5305 enum VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME = "VK_NV_viewport_swizzle"; 5306 5307 5308 enum VkViewportCoordinateSwizzleNV { 5309 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, 5310 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, 5311 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, 5312 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, 5313 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, 5314 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, 5315 VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, 5316 VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, 5317 VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, 5318 VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV, 5319 VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = ( VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1 ), 5320 VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF 5321 } 5322 5323 // VkViewportCoordinateSwizzleNV global enums 5324 enum VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV; 5325 enum VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV; 5326 enum VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV; 5327 enum VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV; 5328 enum VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV; 5329 enum VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV; 5330 enum VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV; 5331 enum VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV; 5332 enum VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV; 5333 enum VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV; 5334 enum VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV; 5335 enum VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = VkViewportCoordinateSwizzleNV.VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV; 5336 5337 alias VkPipelineViewportSwizzleStateCreateFlagsNV = VkFlags; 5338 5339 struct VkViewportSwizzleNV { 5340 VkViewportCoordinateSwizzleNV x; 5341 VkViewportCoordinateSwizzleNV y; 5342 VkViewportCoordinateSwizzleNV z; 5343 VkViewportCoordinateSwizzleNV w; 5344 } 5345 5346 struct VkPipelineViewportSwizzleStateCreateInfoNV { 5347 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; 5348 const( void )* pNext; 5349 VkPipelineViewportSwizzleStateCreateFlagsNV flags; 5350 uint32_t viewportCount; 5351 const( VkViewportSwizzleNV )* pViewportSwizzles; 5352 } 5353 5354 // VK_EXT_discard_rectangles 5355 enum VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION = 1; 5356 enum VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME = "VK_EXT_discard_rectangles"; 5357 5358 5359 enum VkDiscardRectangleModeEXT { 5360 VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, 5361 VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, 5362 VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, 5363 VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT, 5364 VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = ( VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1 ), 5365 VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF 5366 } 5367 5368 // VkDiscardRectangleModeEXT global enums 5369 enum VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = VkDiscardRectangleModeEXT.VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT; 5370 enum VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = VkDiscardRectangleModeEXT.VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT; 5371 enum VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VkDiscardRectangleModeEXT.VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT; 5372 enum VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VkDiscardRectangleModeEXT.VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT; 5373 enum VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = VkDiscardRectangleModeEXT.VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT; 5374 enum VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = VkDiscardRectangleModeEXT.VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT; 5375 5376 alias VkPipelineDiscardRectangleStateCreateFlagsEXT = VkFlags; 5377 5378 struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { 5379 VkStructureType sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; 5380 const( void )* pNext; 5381 uint32_t maxDiscardRectangles; 5382 } 5383 5384 struct VkPipelineDiscardRectangleStateCreateInfoEXT { 5385 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; 5386 const( void )* pNext; 5387 VkPipelineDiscardRectangleStateCreateFlagsEXT flags; 5388 VkDiscardRectangleModeEXT discardRectangleMode; 5389 uint32_t discardRectangleCount; 5390 const( VkRect2D )* pDiscardRectangles; 5391 } 5392 5393 // VK_NV_extension_101 5394 enum VK_NV_EXTENSION_101_SPEC_VERSION = 0; 5395 enum VK_NV_EXTENSION_101_EXTENSION_NAME = "VK_NV_extension_101"; 5396 5397 // VK_NV_extension_102 5398 enum VK_NV_EXTENSION_102_SPEC_VERSION = 0; 5399 enum VK_NV_EXTENSION_102_EXTENSION_NAME = "VK_NV_extension_102"; 5400 5401 // VK_NV_extension_103 5402 enum VK_NV_EXTENSION_103_SPEC_VERSION = 0; 5403 enum VK_NV_EXTENSION_103_EXTENSION_NAME = "VK_NV_extension_103"; 5404 5405 // VK_NV_extension_104 5406 enum VK_NV_EXTENSION_104_SPEC_VERSION = 0; 5407 enum VK_NV_EXTENSION_104_EXTENSION_NAME = "VK_NV_extension_104"; 5408 5409 // VK_EXT_swapchain_colorspace 5410 enum VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION = 1; 5411 enum VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME = "VK_EXT_swapchain_colorspace"; 5412 5413 // VK_EXT_hdr_metadata 5414 enum VK_EXT_HDR_METADATA_SPEC_VERSION = 0; 5415 enum VK_EXT_HDR_METADATA_EXTENSION_NAME = "VK_EXT_hdr_metadata"; 5416 5417 struct VkXYColorEXT { 5418 float x; 5419 float y; 5420 } 5421 5422 struct VkHdrMetadataEXT { 5423 VkStructureType sType = VK_STRUCTURE_TYPE_HDR_METADATA_EXT; 5424 const( void )* pNext; 5425 VkXYColorEXT displayPrimaryRed; 5426 VkXYColorEXT displayPrimaryGreen; 5427 VkXYColorEXT displayPrimaryBlue; 5428 VkXYColorEXT whitePoint; 5429 float maxLuminance; 5430 float minLuminance; 5431 float maxContentLightLevel; 5432 float maxFrameAverageLightLevel; 5433 } 5434 5435 // VK_IMG_extension_107 5436 enum VK_IMG_EXTENSION_107_SPEC_VERSION = 0; 5437 enum VK_IMG_EXTENSION_107_EXTENSION_NAME = "VK_IMG_extension_107"; 5438 5439 // VK_IMG_extension_108 5440 enum VK_IMG_EXTENSION_108_SPEC_VERSION = 0; 5441 enum VK_IMG_EXTENSION_108_EXTENSION_NAME = "VK_IMG_extension_108"; 5442 5443 // VK_IMG_extension_109 5444 enum VK_IMG_EXTENSION_109_SPEC_VERSION = 0; 5445 enum VK_IMG_EXTENSION_109_EXTENSION_NAME = "VK_IMG_extension_109"; 5446 5447 // VK_IMG_extension_110 5448 enum VK_IMG_EXTENSION_110_SPEC_VERSION = 0; 5449 enum VK_IMG_EXTENSION_110_EXTENSION_NAME = "VK_IMG_extension_110"; 5450 5451 // VK_IMG_extension_111 5452 enum VK_IMG_EXTENSION_111_SPEC_VERSION = 0; 5453 enum VK_IMG_EXTENSION_111_EXTENSION_NAME = "VK_IMG_extension_111"; 5454 5455 // VK_MVK_ios_surface 5456 enum VK_MVK_IOS_SURFACE_SPEC_VERSION = 2; 5457 enum VK_MVK_IOS_SURFACE_EXTENSION_NAME = "VK_MVK_ios_surface"; 5458 5459 alias VkIOSSurfaceCreateFlagsMVK = VkFlags; 5460 5461 struct VkIOSSurfaceCreateInfoMVK { 5462 VkStructureType sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; 5463 const( void )* pNext; 5464 VkIOSSurfaceCreateFlagsMVK flags; 5465 const( void )* pView; 5466 } 5467 5468 // VK_MVK_macos_surface 5469 enum VK_MVK_MACOS_SURFACE_SPEC_VERSION = 2; 5470 enum VK_MVK_MACOS_SURFACE_EXTENSION_NAME = "VK_MVK_macos_surface"; 5471 5472 alias VkMacOSSurfaceCreateFlagsMVK = VkFlags; 5473 5474 struct VkMacOSSurfaceCreateInfoMVK { 5475 VkStructureType sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; 5476 const( void )* pNext; 5477 VkMacOSSurfaceCreateFlagsMVK flags; 5478 const( void )* pView; 5479 } 5480 5481 // VK_MVK_moltenvk 5482 enum VK_MVK_MOLTENVK_SPEC_VERSION = 0; 5483 enum VK_MVK_MOLTENVK_EXTENSION_NAME = "VK_MVK_moltenvk"; 5484 5485 // VK_MESA_extension_126 5486 enum VK_MESA_EXTENSION_126_SPEC_VERSION = 0; 5487 enum VK_MESA_EXTENSION_126_EXTENSION_NAME = "VK_MESA_extension_126"; 5488 5489 // VK_MESA_extension_127 5490 enum VK_MESA_EXTENSION_127_SPEC_VERSION = 0; 5491 enum VK_MESA_EXTENSION_127_EXTENSION_NAME = "VK_MESA_extension_127"; 5492 5493 // VK_EXT_extension_129 5494 enum VK_KHR_EXTENSION_129_SPEC_VERSION = 0; 5495 enum VK_KHR_EXTENSION_129_EXTENSION_NAME = "VK_EXT_extension_129"; 5496