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