1 2 /// Vulkan types. 3 module dvulkan.types; 4 // THIS FILE IS AUTOMATICALLY GENERATED. DO NOT MODIFY. 5 6 alias uint8_t = ubyte; 7 alias uint16_t = ushort; 8 alias uint32_t = uint; 9 alias uint64_t = ulong; 10 alias int8_t = byte; 11 alias int16_t = short; 12 alias int32_t = int; 13 alias int64_t = long; 14 15 @nogc pure nothrow { 16 uint VK_MAKE_VERSION(uint major, uint minor, uint patch) { 17 return (major << 22) | (minor << 12) | (patch); 18 } 19 uint VK_VERSION_MAJOR(uint ver) { 20 return ver >> 22; 21 } 22 uint VK_VERSION_MINOR(uint ver) { 23 return (ver >> 12) & 0x3ff; 24 } 25 uint VK_VERSION_PATCH(uint ver) { 26 return ver & 0xfff; 27 } 28 } 29 30 /+ 31 + On 32-bit systems, VK_NULL_HANDLE must be compatible with both opaque struct pointers 32 + (for dispatchable object) and integers (for nondispatchable objects). This is not possible 33 + with D's type system, which doesn't implicitly convert 0 to the null pointer as in C 34 + (for better or for worse). Either use the `VK_NULL_[NON_]DISPATCHABLE_HANDLE` constants or 35 + `Vk(Type).init`. 36 + 37 + See also https://github.com/ColonelThirtyTwo/dvulkan/issues/13 38 +/ 39 deprecated("VK_NULL_HANDLE is impossible to implement portably in D. Use Vk(Type).init or VK_NULL_[NON_]DISPATCHABLE_HANDLE") 40 enum VK_NULL_HANDLE = null; 41 42 enum VK_DEFINE_HANDLE(string name) = "struct "~name~"_handle; alias "~name~" = "~name~"_handle*;"; 43 44 enum VK_NULL_DISPATCHABLE_HANDLE = null; 45 version(X86_64) { 46 alias VK_DEFINE_NON_DISPATCHABLE_HANDLE(string name) = VK_DEFINE_HANDLE!name; 47 enum VK_NULL_NON_DISPATCHABLE_HANDLE = null; 48 } else { 49 enum VK_DEFINE_NON_DISPATCHABLE_HANDLE(string name) = "alias "~name~" = ulong;"; 50 enum VK_NULL_NON_DISPATCHABLE_HANDLE = 0; 51 } 52 version(DVulkanAllExtensions) { 53 version = DVulkan_VK_VERSION_1_0; 54 version = DVulkan_VK_KHR_surface; 55 version = DVulkan_VK_KHR_swapchain; 56 version = DVulkan_VK_KHR_display; 57 version = DVulkan_VK_KHR_display_swapchain; 58 version = DVulkan_VK_KHR_sampler_mirror_clamp_to_edge; 59 version = DVulkan_VK_ANDROID_native_buffer; 60 version = DVulkan_VK_EXT_debug_report; 61 version = DVulkan_VK_NV_glsl_shader; 62 version = DVulkan_VK_NV_extension_1; 63 version = DVulkan_VK_IMG_filter_cubic; 64 version = DVulkan_VK_AMD_extension_1; 65 version = DVulkan_VK_AMD_extension_2; 66 version = DVulkan_VK_AMD_rasterization_order; 67 version = DVulkan_VK_AMD_extension_4; 68 version = DVulkan_VK_AMD_extension_5; 69 version = DVulkan_VK_AMD_extension_6; 70 version = DVulkan_VK_EXT_debug_marker; 71 } 72 version(DVulkan_VK_VERSION_1_0) { 73 enum VkPipelineCacheHeaderVersion { 74 VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, 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 VkResult { 86 VK_SUCCESS = 0, 87 VK_NOT_READY = 1, 88 VK_TIMEOUT = 2, 89 VK_EVENT_SET = 3, 90 VK_EVENT_RESET = 4, 91 VK_INCOMPLETE = 5, 92 VK_ERROR_OUT_OF_HOST_MEMORY = -1, 93 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, 94 VK_ERROR_INITIALIZATION_FAILED = -3, 95 VK_ERROR_DEVICE_LOST = -4, 96 VK_ERROR_MEMORY_MAP_FAILED = -5, 97 VK_ERROR_LAYER_NOT_PRESENT = -6, 98 VK_ERROR_EXTENSION_NOT_PRESENT = -7, 99 VK_ERROR_FEATURE_NOT_PRESENT = -8, 100 VK_ERROR_INCOMPATIBLE_DRIVER = -9, 101 VK_ERROR_TOO_MANY_OBJECTS = -10, 102 VK_ERROR_FORMAT_NOT_SUPPORTED = -11, 103 VK_ERROR_SURFACE_LOST_KHR = -1000000000, 104 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, 105 VK_SUBOPTIMAL_KHR = 1000001003, 106 VK_ERROR_OUT_OF_DATE_KHR = -1000001004, 107 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, 108 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, 109 VK_ERROR_INVALID_SHADER_NV = -1000012000, 110 VK_NV_EXTENSION_1_ERROR = -1000013000, 111 } 112 enum VkStructureType { 113 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, 114 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, 115 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, 116 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, 117 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, 118 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, 119 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, 120 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, 121 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, 122 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, 123 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, 124 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, 125 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, 126 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, 127 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, 128 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, 129 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, 130 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, 131 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, 132 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, 133 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, 134 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, 135 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, 136 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, 137 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, 138 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, 139 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, 140 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, 141 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, 142 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, 143 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, 144 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, 145 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, 146 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, 147 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, 148 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, 149 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, 150 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, 151 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, 152 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, 153 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, 154 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, 155 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, 156 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, 157 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, 158 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, 159 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, 160 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, 161 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, 162 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, 163 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, 164 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, 165 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, 166 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, 167 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, 168 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, 169 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, 170 VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, 171 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, 172 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, 173 VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, 174 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, 175 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, 176 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, 177 VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, 178 } 179 alias VkFlags = uint32_t; 180 alias VkInstanceCreateFlags = VkFlags; 181 struct VkApplicationInfo { 182 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_APPLICATION_INFO; 183 const(void)* pNext; 184 const(char)* pApplicationName; 185 uint32_t applicationVersion; 186 const(char)* pEngineName; 187 uint32_t engineVersion; 188 uint32_t apiVersion; 189 } 190 struct VkInstanceCreateInfo { 191 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; 192 const(void)* pNext; 193 VkInstanceCreateFlags flags; 194 const(VkApplicationInfo)* pApplicationInfo; 195 uint32_t enabledLayerCount; 196 const(char*)* ppEnabledLayerNames; 197 uint32_t enabledExtensionCount; 198 const(char*)* ppEnabledExtensionNames; 199 } 200 enum VkSystemAllocationScope { 201 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, 202 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, 203 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, 204 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, 205 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, 206 } 207 alias PFN_vkAllocationFunction = void* function( 208 void* pUserData, 209 size_t size, 210 size_t alignment, 211 VkSystemAllocationScope allocationScope); 212 alias PFN_vkReallocationFunction = void* function( 213 void* pUserData, 214 void* pOriginal, 215 size_t size, 216 size_t alignment, 217 VkSystemAllocationScope allocationScope); 218 alias PFN_vkFreeFunction = void function( 219 void* pUserData, 220 void* pMemory); 221 enum VkInternalAllocationType { 222 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, 223 } 224 alias PFN_vkInternalAllocationNotification = void function( 225 void* pUserData, 226 size_t size, 227 VkInternalAllocationType allocationType, 228 VkSystemAllocationScope allocationScope); 229 alias PFN_vkInternalFreeNotification = void function( 230 void* pUserData, 231 size_t size, 232 VkInternalAllocationType allocationType, 233 VkSystemAllocationScope allocationScope); 234 struct VkAllocationCallbacks { 235 void* pUserData; 236 PFN_vkAllocationFunction pfnAllocation; 237 PFN_vkReallocationFunction pfnReallocation; 238 PFN_vkFreeFunction pfnFree; 239 PFN_vkInternalAllocationNotification pfnInternalAllocation; 240 PFN_vkInternalFreeNotification pfnInternalFree; 241 } 242 mixin(VK_DEFINE_HANDLE!q{VkInstance}); 243 mixin(VK_DEFINE_HANDLE!q{VkPhysicalDevice}); 244 alias VkBool32 = uint32_t; 245 struct VkPhysicalDeviceFeatures { 246 VkBool32 robustBufferAccess; 247 VkBool32 fullDrawIndexUint32; 248 VkBool32 imageCubeArray; 249 VkBool32 independentBlend; 250 VkBool32 geometryShader; 251 VkBool32 tessellationShader; 252 VkBool32 sampleRateShading; 253 VkBool32 dualSrcBlend; 254 VkBool32 logicOp; 255 VkBool32 multiDrawIndirect; 256 VkBool32 drawIndirectFirstInstance; 257 VkBool32 depthClamp; 258 VkBool32 depthBiasClamp; 259 VkBool32 fillModeNonSolid; 260 VkBool32 depthBounds; 261 VkBool32 wideLines; 262 VkBool32 largePoints; 263 VkBool32 alphaToOne; 264 VkBool32 multiViewport; 265 VkBool32 samplerAnisotropy; 266 VkBool32 textureCompressionETC2; 267 VkBool32 textureCompressionASTC_LDR; 268 VkBool32 textureCompressionBC; 269 VkBool32 occlusionQueryPrecise; 270 VkBool32 pipelineStatisticsQuery; 271 VkBool32 vertexPipelineStoresAndAtomics; 272 VkBool32 fragmentStoresAndAtomics; 273 VkBool32 shaderTessellationAndGeometryPointSize; 274 VkBool32 shaderImageGatherExtended; 275 VkBool32 shaderStorageImageExtendedFormats; 276 VkBool32 shaderStorageImageMultisample; 277 VkBool32 shaderStorageImageReadWithoutFormat; 278 VkBool32 shaderStorageImageWriteWithoutFormat; 279 VkBool32 shaderUniformBufferArrayDynamicIndexing; 280 VkBool32 shaderSampledImageArrayDynamicIndexing; 281 VkBool32 shaderStorageBufferArrayDynamicIndexing; 282 VkBool32 shaderStorageImageArrayDynamicIndexing; 283 VkBool32 shaderClipDistance; 284 VkBool32 shaderCullDistance; 285 VkBool32 shaderFloat64; 286 VkBool32 shaderInt64; 287 VkBool32 shaderInt16; 288 VkBool32 shaderResourceResidency; 289 VkBool32 shaderResourceMinLod; 290 VkBool32 sparseBinding; 291 VkBool32 sparseResidencyBuffer; 292 VkBool32 sparseResidencyImage2D; 293 VkBool32 sparseResidencyImage3D; 294 VkBool32 sparseResidency2Samples; 295 VkBool32 sparseResidency4Samples; 296 VkBool32 sparseResidency8Samples; 297 VkBool32 sparseResidency16Samples; 298 VkBool32 sparseResidencyAliased; 299 VkBool32 variableMultisampleRate; 300 VkBool32 inheritedQueries; 301 } 302 enum VkFormat { 303 VK_FORMAT_UNDEFINED = 0, 304 VK_FORMAT_R4G4_UNORM_PACK8 = 1, 305 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, 306 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, 307 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, 308 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, 309 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, 310 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, 311 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, 312 VK_FORMAT_R8_UNORM = 9, 313 VK_FORMAT_R8_SNORM = 10, 314 VK_FORMAT_R8_USCALED = 11, 315 VK_FORMAT_R8_SSCALED = 12, 316 VK_FORMAT_R8_UINT = 13, 317 VK_FORMAT_R8_SINT = 14, 318 VK_FORMAT_R8_SRGB = 15, 319 VK_FORMAT_R8G8_UNORM = 16, 320 VK_FORMAT_R8G8_SNORM = 17, 321 VK_FORMAT_R8G8_USCALED = 18, 322 VK_FORMAT_R8G8_SSCALED = 19, 323 VK_FORMAT_R8G8_UINT = 20, 324 VK_FORMAT_R8G8_SINT = 21, 325 VK_FORMAT_R8G8_SRGB = 22, 326 VK_FORMAT_R8G8B8_UNORM = 23, 327 VK_FORMAT_R8G8B8_SNORM = 24, 328 VK_FORMAT_R8G8B8_USCALED = 25, 329 VK_FORMAT_R8G8B8_SSCALED = 26, 330 VK_FORMAT_R8G8B8_UINT = 27, 331 VK_FORMAT_R8G8B8_SINT = 28, 332 VK_FORMAT_R8G8B8_SRGB = 29, 333 VK_FORMAT_B8G8R8_UNORM = 30, 334 VK_FORMAT_B8G8R8_SNORM = 31, 335 VK_FORMAT_B8G8R8_USCALED = 32, 336 VK_FORMAT_B8G8R8_SSCALED = 33, 337 VK_FORMAT_B8G8R8_UINT = 34, 338 VK_FORMAT_B8G8R8_SINT = 35, 339 VK_FORMAT_B8G8R8_SRGB = 36, 340 VK_FORMAT_R8G8B8A8_UNORM = 37, 341 VK_FORMAT_R8G8B8A8_SNORM = 38, 342 VK_FORMAT_R8G8B8A8_USCALED = 39, 343 VK_FORMAT_R8G8B8A8_SSCALED = 40, 344 VK_FORMAT_R8G8B8A8_UINT = 41, 345 VK_FORMAT_R8G8B8A8_SINT = 42, 346 VK_FORMAT_R8G8B8A8_SRGB = 43, 347 VK_FORMAT_B8G8R8A8_UNORM = 44, 348 VK_FORMAT_B8G8R8A8_SNORM = 45, 349 VK_FORMAT_B8G8R8A8_USCALED = 46, 350 VK_FORMAT_B8G8R8A8_SSCALED = 47, 351 VK_FORMAT_B8G8R8A8_UINT = 48, 352 VK_FORMAT_B8G8R8A8_SINT = 49, 353 VK_FORMAT_B8G8R8A8_SRGB = 50, 354 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, 355 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, 356 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, 357 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, 358 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, 359 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, 360 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, 361 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, 362 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, 363 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, 364 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, 365 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, 366 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, 367 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, 368 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, 369 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, 370 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, 371 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, 372 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, 373 VK_FORMAT_R16_UNORM = 70, 374 VK_FORMAT_R16_SNORM = 71, 375 VK_FORMAT_R16_USCALED = 72, 376 VK_FORMAT_R16_SSCALED = 73, 377 VK_FORMAT_R16_UINT = 74, 378 VK_FORMAT_R16_SINT = 75, 379 VK_FORMAT_R16_SFLOAT = 76, 380 VK_FORMAT_R16G16_UNORM = 77, 381 VK_FORMAT_R16G16_SNORM = 78, 382 VK_FORMAT_R16G16_USCALED = 79, 383 VK_FORMAT_R16G16_SSCALED = 80, 384 VK_FORMAT_R16G16_UINT = 81, 385 VK_FORMAT_R16G16_SINT = 82, 386 VK_FORMAT_R16G16_SFLOAT = 83, 387 VK_FORMAT_R16G16B16_UNORM = 84, 388 VK_FORMAT_R16G16B16_SNORM = 85, 389 VK_FORMAT_R16G16B16_USCALED = 86, 390 VK_FORMAT_R16G16B16_SSCALED = 87, 391 VK_FORMAT_R16G16B16_UINT = 88, 392 VK_FORMAT_R16G16B16_SINT = 89, 393 VK_FORMAT_R16G16B16_SFLOAT = 90, 394 VK_FORMAT_R16G16B16A16_UNORM = 91, 395 VK_FORMAT_R16G16B16A16_SNORM = 92, 396 VK_FORMAT_R16G16B16A16_USCALED = 93, 397 VK_FORMAT_R16G16B16A16_SSCALED = 94, 398 VK_FORMAT_R16G16B16A16_UINT = 95, 399 VK_FORMAT_R16G16B16A16_SINT = 96, 400 VK_FORMAT_R16G16B16A16_SFLOAT = 97, 401 VK_FORMAT_R32_UINT = 98, 402 VK_FORMAT_R32_SINT = 99, 403 VK_FORMAT_R32_SFLOAT = 100, 404 VK_FORMAT_R32G32_UINT = 101, 405 VK_FORMAT_R32G32_SINT = 102, 406 VK_FORMAT_R32G32_SFLOAT = 103, 407 VK_FORMAT_R32G32B32_UINT = 104, 408 VK_FORMAT_R32G32B32_SINT = 105, 409 VK_FORMAT_R32G32B32_SFLOAT = 106, 410 VK_FORMAT_R32G32B32A32_UINT = 107, 411 VK_FORMAT_R32G32B32A32_SINT = 108, 412 VK_FORMAT_R32G32B32A32_SFLOAT = 109, 413 VK_FORMAT_R64_UINT = 110, 414 VK_FORMAT_R64_SINT = 111, 415 VK_FORMAT_R64_SFLOAT = 112, 416 VK_FORMAT_R64G64_UINT = 113, 417 VK_FORMAT_R64G64_SINT = 114, 418 VK_FORMAT_R64G64_SFLOAT = 115, 419 VK_FORMAT_R64G64B64_UINT = 116, 420 VK_FORMAT_R64G64B64_SINT = 117, 421 VK_FORMAT_R64G64B64_SFLOAT = 118, 422 VK_FORMAT_R64G64B64A64_UINT = 119, 423 VK_FORMAT_R64G64B64A64_SINT = 120, 424 VK_FORMAT_R64G64B64A64_SFLOAT = 121, 425 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, 426 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, 427 VK_FORMAT_D16_UNORM = 124, 428 VK_FORMAT_X8_D24_UNORM_PACK32 = 125, 429 VK_FORMAT_D32_SFLOAT = 126, 430 VK_FORMAT_S8_UINT = 127, 431 VK_FORMAT_D16_UNORM_S8_UINT = 128, 432 VK_FORMAT_D24_UNORM_S8_UINT = 129, 433 VK_FORMAT_D32_SFLOAT_S8_UINT = 130, 434 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, 435 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, 436 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, 437 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, 438 VK_FORMAT_BC2_UNORM_BLOCK = 135, 439 VK_FORMAT_BC2_SRGB_BLOCK = 136, 440 VK_FORMAT_BC3_UNORM_BLOCK = 137, 441 VK_FORMAT_BC3_SRGB_BLOCK = 138, 442 VK_FORMAT_BC4_UNORM_BLOCK = 139, 443 VK_FORMAT_BC4_SNORM_BLOCK = 140, 444 VK_FORMAT_BC5_UNORM_BLOCK = 141, 445 VK_FORMAT_BC5_SNORM_BLOCK = 142, 446 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, 447 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, 448 VK_FORMAT_BC7_UNORM_BLOCK = 145, 449 VK_FORMAT_BC7_SRGB_BLOCK = 146, 450 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, 451 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, 452 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, 453 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, 454 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, 455 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, 456 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, 457 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, 458 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, 459 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, 460 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, 461 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, 462 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, 463 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, 464 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, 465 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, 466 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, 467 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, 468 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, 469 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, 470 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, 471 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, 472 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, 473 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, 474 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, 475 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, 476 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, 477 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, 478 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, 479 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, 480 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, 481 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, 482 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, 483 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, 484 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, 485 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, 486 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, 487 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, 488 } 489 enum VkFormatFeatureFlagBits { 490 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, 491 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, 492 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, 493 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, 494 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, 495 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, 496 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, 497 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, 498 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, 499 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, 500 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, 501 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, 502 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, 503 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, 504 } 505 alias VkFormatFeatureFlags = VkFlags; 506 struct VkFormatProperties { 507 VkFormatFeatureFlags linearTilingFeatures; 508 VkFormatFeatureFlags optimalTilingFeatures; 509 VkFormatFeatureFlags bufferFeatures; 510 } 511 enum VkImageType { 512 VK_IMAGE_TYPE_1D = 0, 513 VK_IMAGE_TYPE_2D = 1, 514 VK_IMAGE_TYPE_3D = 2, 515 } 516 enum VkImageTiling { 517 VK_IMAGE_TILING_OPTIMAL = 0, 518 VK_IMAGE_TILING_LINEAR = 1, 519 } 520 enum VkImageUsageFlagBits { 521 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, 522 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, 523 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, 524 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, 525 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, 526 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, 527 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, 528 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, 529 } 530 alias VkImageUsageFlags = VkFlags; 531 enum VkImageCreateFlagBits { 532 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, 533 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 534 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 535 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, 536 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, 537 } 538 alias VkImageCreateFlags = VkFlags; 539 struct VkExtent3D { 540 uint32_t width; 541 uint32_t height; 542 uint32_t depth; 543 } 544 enum VkSampleCountFlagBits { 545 VK_SAMPLE_COUNT_1_BIT = 0x00000001, 546 VK_SAMPLE_COUNT_2_BIT = 0x00000002, 547 VK_SAMPLE_COUNT_4_BIT = 0x00000004, 548 VK_SAMPLE_COUNT_8_BIT = 0x00000008, 549 VK_SAMPLE_COUNT_16_BIT = 0x00000010, 550 VK_SAMPLE_COUNT_32_BIT = 0x00000020, 551 VK_SAMPLE_COUNT_64_BIT = 0x00000040, 552 } 553 alias VkSampleCountFlags = VkFlags; 554 alias VkDeviceSize = uint64_t; 555 struct VkImageFormatProperties { 556 VkExtent3D maxExtent; 557 uint32_t maxMipLevels; 558 uint32_t maxArrayLayers; 559 VkSampleCountFlags sampleCounts; 560 VkDeviceSize maxResourceSize; 561 } 562 enum VkPhysicalDeviceType { 563 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, 564 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, 565 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, 566 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, 567 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, 568 } 569 struct VkPhysicalDeviceLimits { 570 uint32_t maxImageDimension1D; 571 uint32_t maxImageDimension2D; 572 uint32_t maxImageDimension3D; 573 uint32_t maxImageDimensionCube; 574 uint32_t maxImageArrayLayers; 575 uint32_t maxTexelBufferElements; 576 uint32_t maxUniformBufferRange; 577 uint32_t maxStorageBufferRange; 578 uint32_t maxPushConstantsSize; 579 uint32_t maxMemoryAllocationCount; 580 uint32_t maxSamplerAllocationCount; 581 VkDeviceSize bufferImageGranularity; 582 VkDeviceSize sparseAddressSpaceSize; 583 uint32_t maxBoundDescriptorSets; 584 uint32_t maxPerStageDescriptorSamplers; 585 uint32_t maxPerStageDescriptorUniformBuffers; 586 uint32_t maxPerStageDescriptorStorageBuffers; 587 uint32_t maxPerStageDescriptorSampledImages; 588 uint32_t maxPerStageDescriptorStorageImages; 589 uint32_t maxPerStageDescriptorInputAttachments; 590 uint32_t maxPerStageResources; 591 uint32_t maxDescriptorSetSamplers; 592 uint32_t maxDescriptorSetUniformBuffers; 593 uint32_t maxDescriptorSetUniformBuffersDynamic; 594 uint32_t maxDescriptorSetStorageBuffers; 595 uint32_t maxDescriptorSetStorageBuffersDynamic; 596 uint32_t maxDescriptorSetSampledImages; 597 uint32_t maxDescriptorSetStorageImages; 598 uint32_t maxDescriptorSetInputAttachments; 599 uint32_t maxVertexInputAttributes; 600 uint32_t maxVertexInputBindings; 601 uint32_t maxVertexInputAttributeOffset; 602 uint32_t maxVertexInputBindingStride; 603 uint32_t maxVertexOutputComponents; 604 uint32_t maxTessellationGenerationLevel; 605 uint32_t maxTessellationPatchSize; 606 uint32_t maxTessellationControlPerVertexInputComponents; 607 uint32_t maxTessellationControlPerVertexOutputComponents; 608 uint32_t maxTessellationControlPerPatchOutputComponents; 609 uint32_t maxTessellationControlTotalOutputComponents; 610 uint32_t maxTessellationEvaluationInputComponents; 611 uint32_t maxTessellationEvaluationOutputComponents; 612 uint32_t maxGeometryShaderInvocations; 613 uint32_t maxGeometryInputComponents; 614 uint32_t maxGeometryOutputComponents; 615 uint32_t maxGeometryOutputVertices; 616 uint32_t maxGeometryTotalOutputComponents; 617 uint32_t maxFragmentInputComponents; 618 uint32_t maxFragmentOutputAttachments; 619 uint32_t maxFragmentDualSrcAttachments; 620 uint32_t maxFragmentCombinedOutputResources; 621 uint32_t maxComputeSharedMemorySize; 622 uint32_t[3] maxComputeWorkGroupCount; 623 uint32_t maxComputeWorkGroupInvocations; 624 uint32_t[3] maxComputeWorkGroupSize; 625 uint32_t subPixelPrecisionBits; 626 uint32_t subTexelPrecisionBits; 627 uint32_t mipmapPrecisionBits; 628 uint32_t maxDrawIndexedIndexValue; 629 uint32_t maxDrawIndirectCount; 630 float maxSamplerLodBias; 631 float maxSamplerAnisotropy; 632 uint32_t maxViewports; 633 uint32_t[2] maxViewportDimensions; 634 float[2] viewportBoundsRange; 635 uint32_t viewportSubPixelBits; 636 size_t minMemoryMapAlignment; 637 VkDeviceSize minTexelBufferOffsetAlignment; 638 VkDeviceSize minUniformBufferOffsetAlignment; 639 VkDeviceSize minStorageBufferOffsetAlignment; 640 int32_t minTexelOffset; 641 uint32_t maxTexelOffset; 642 int32_t minTexelGatherOffset; 643 uint32_t maxTexelGatherOffset; 644 float minInterpolationOffset; 645 float maxInterpolationOffset; 646 uint32_t subPixelInterpolationOffsetBits; 647 uint32_t maxFramebufferWidth; 648 uint32_t maxFramebufferHeight; 649 uint32_t maxFramebufferLayers; 650 VkSampleCountFlags framebufferColorSampleCounts; 651 VkSampleCountFlags framebufferDepthSampleCounts; 652 VkSampleCountFlags framebufferStencilSampleCounts; 653 VkSampleCountFlags framebufferNoAttachmentsSampleCounts; 654 uint32_t maxColorAttachments; 655 VkSampleCountFlags sampledImageColorSampleCounts; 656 VkSampleCountFlags sampledImageIntegerSampleCounts; 657 VkSampleCountFlags sampledImageDepthSampleCounts; 658 VkSampleCountFlags sampledImageStencilSampleCounts; 659 VkSampleCountFlags storageImageSampleCounts; 660 uint32_t maxSampleMaskWords; 661 VkBool32 timestampComputeAndGraphics; 662 float timestampPeriod; 663 uint32_t maxClipDistances; 664 uint32_t maxCullDistances; 665 uint32_t maxCombinedClipAndCullDistances; 666 uint32_t discreteQueuePriorities; 667 float[2] pointSizeRange; 668 float[2] lineWidthRange; 669 float pointSizeGranularity; 670 float lineWidthGranularity; 671 VkBool32 strictLines; 672 VkBool32 standardSampleLocations; 673 VkDeviceSize optimalBufferCopyOffsetAlignment; 674 VkDeviceSize optimalBufferCopyRowPitchAlignment; 675 VkDeviceSize nonCoherentAtomSize; 676 } 677 struct VkPhysicalDeviceSparseProperties { 678 VkBool32 residencyStandard2DBlockShape; 679 VkBool32 residencyStandard2DMultisampleBlockShape; 680 VkBool32 residencyStandard3DBlockShape; 681 VkBool32 residencyAlignedMipSize; 682 VkBool32 residencyNonResidentStrict; 683 } 684 enum VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256; 685 enum VK_UUID_SIZE = 16; 686 struct VkPhysicalDeviceProperties { 687 uint32_t apiVersion; 688 uint32_t driverVersion; 689 uint32_t vendorID; 690 uint32_t deviceID; 691 VkPhysicalDeviceType deviceType; 692 char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] deviceName; 693 uint8_t[VK_UUID_SIZE] pipelineCacheUUID; 694 VkPhysicalDeviceLimits limits; 695 VkPhysicalDeviceSparseProperties sparseProperties; 696 } 697 enum VkQueueFlagBits { 698 VK_QUEUE_GRAPHICS_BIT = 0x00000001, 699 VK_QUEUE_COMPUTE_BIT = 0x00000002, 700 VK_QUEUE_TRANSFER_BIT = 0x00000004, 701 VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, 702 } 703 alias VkQueueFlags = VkFlags; 704 struct VkQueueFamilyProperties { 705 VkQueueFlags queueFlags; 706 uint32_t queueCount; 707 uint32_t timestampValidBits; 708 VkExtent3D minImageTransferGranularity; 709 } 710 enum VkMemoryPropertyFlagBits { 711 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, 712 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, 713 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, 714 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, 715 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, 716 } 717 alias VkMemoryPropertyFlags = VkFlags; 718 struct VkMemoryType { 719 VkMemoryPropertyFlags propertyFlags; 720 uint32_t heapIndex; 721 } 722 enum VkMemoryHeapFlagBits { 723 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, 724 } 725 alias VkMemoryHeapFlags = VkFlags; 726 struct VkMemoryHeap { 727 VkDeviceSize size; 728 VkMemoryHeapFlags flags; 729 } 730 enum VK_MAX_MEMORY_TYPES = 32; 731 enum VK_MAX_MEMORY_HEAPS = 16; 732 struct VkPhysicalDeviceMemoryProperties { 733 uint32_t memoryTypeCount; 734 VkMemoryType[VK_MAX_MEMORY_TYPES] memoryTypes; 735 uint32_t memoryHeapCount; 736 VkMemoryHeap[VK_MAX_MEMORY_HEAPS] memoryHeaps; 737 } 738 alias PFN_vkVoidFunction = void function(); 739 mixin(VK_DEFINE_HANDLE!q{VkDevice}); 740 alias VkDeviceCreateFlags = VkFlags; 741 alias VkDeviceQueueCreateFlags = VkFlags; 742 struct VkDeviceQueueCreateInfo { 743 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; 744 const(void)* pNext; 745 VkDeviceQueueCreateFlags flags; 746 uint32_t queueFamilyIndex; 747 uint32_t queueCount; 748 const(float)* pQueuePriorities; 749 } 750 struct VkDeviceCreateInfo { 751 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; 752 const(void)* pNext; 753 VkDeviceCreateFlags flags; 754 uint32_t queueCreateInfoCount; 755 const(VkDeviceQueueCreateInfo)* pQueueCreateInfos; 756 uint32_t enabledLayerCount; 757 const(char*)* ppEnabledLayerNames; 758 uint32_t enabledExtensionCount; 759 const(char*)* ppEnabledExtensionNames; 760 const(VkPhysicalDeviceFeatures)* pEnabledFeatures; 761 } 762 enum VK_MAX_EXTENSION_NAME_SIZE = 256; 763 struct VkExtensionProperties { 764 char[VK_MAX_EXTENSION_NAME_SIZE] extensionName; 765 uint32_t specVersion; 766 } 767 enum VK_MAX_DESCRIPTION_SIZE = 256; 768 struct VkLayerProperties { 769 char[VK_MAX_EXTENSION_NAME_SIZE] layerName; 770 uint32_t specVersion; 771 uint32_t implementationVersion; 772 char[VK_MAX_DESCRIPTION_SIZE] description; 773 } 774 mixin(VK_DEFINE_HANDLE!q{VkQueue}); 775 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSemaphore}); 776 enum VkPipelineStageFlagBits { 777 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, 778 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, 779 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, 780 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, 781 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, 782 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, 783 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, 784 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, 785 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, 786 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, 787 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, 788 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, 789 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, 790 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, 791 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, 792 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, 793 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, 794 } 795 alias VkPipelineStageFlags = VkFlags; 796 mixin(VK_DEFINE_HANDLE!q{VkCommandBuffer}); 797 struct VkSubmitInfo { 798 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_SUBMIT_INFO; 799 const(void)* pNext; 800 uint32_t waitSemaphoreCount; 801 const(VkSemaphore)* pWaitSemaphores; 802 const(VkPipelineStageFlags)* pWaitDstStageMask; 803 uint32_t commandBufferCount; 804 const(VkCommandBuffer)* pCommandBuffers; 805 uint32_t signalSemaphoreCount; 806 const(VkSemaphore)* pSignalSemaphores; 807 } 808 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkFence}); 809 struct VkMemoryAllocateInfo { 810 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; 811 const(void)* pNext; 812 VkDeviceSize allocationSize; 813 uint32_t memoryTypeIndex; 814 } 815 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDeviceMemory}); 816 alias VkMemoryMapFlags = VkFlags; 817 struct VkMappedMemoryRange { 818 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; 819 const(void)* pNext; 820 VkDeviceMemory memory; 821 VkDeviceSize offset; 822 VkDeviceSize size; 823 } 824 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkBuffer}); 825 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkImage}); 826 struct VkMemoryRequirements { 827 VkDeviceSize size; 828 VkDeviceSize alignment; 829 uint32_t memoryTypeBits; 830 } 831 enum VkImageAspectFlagBits { 832 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, 833 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, 834 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, 835 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, 836 } 837 alias VkImageAspectFlags = VkFlags; 838 enum VkSparseImageFormatFlagBits { 839 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, 840 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, 841 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, 842 } 843 alias VkSparseImageFormatFlags = VkFlags; 844 struct VkSparseImageFormatProperties { 845 VkImageAspectFlags aspectMask; 846 VkExtent3D imageGranularity; 847 VkSparseImageFormatFlags flags; 848 } 849 struct VkSparseImageMemoryRequirements { 850 VkSparseImageFormatProperties formatProperties; 851 uint32_t imageMipTailFirstLod; 852 VkDeviceSize imageMipTailSize; 853 VkDeviceSize imageMipTailOffset; 854 VkDeviceSize imageMipTailStride; 855 } 856 enum VkSparseMemoryBindFlagBits { 857 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, 858 } 859 alias VkSparseMemoryBindFlags = VkFlags; 860 struct VkSparseMemoryBind { 861 VkDeviceSize resourceOffset; 862 VkDeviceSize size; 863 VkDeviceMemory memory; 864 VkDeviceSize memoryOffset; 865 VkSparseMemoryBindFlags flags; 866 } 867 struct VkSparseBufferMemoryBindInfo { 868 VkBuffer buffer; 869 uint32_t bindCount; 870 const(VkSparseMemoryBind)* pBinds; 871 } 872 struct VkSparseImageOpaqueMemoryBindInfo { 873 VkImage image; 874 uint32_t bindCount; 875 const(VkSparseMemoryBind)* pBinds; 876 } 877 struct VkImageSubresource { 878 VkImageAspectFlags aspectMask; 879 uint32_t mipLevel; 880 uint32_t arrayLayer; 881 } 882 struct VkOffset3D { 883 int32_t x; 884 int32_t y; 885 int32_t z; 886 } 887 struct VkSparseImageMemoryBind { 888 VkImageSubresource subresource; 889 VkOffset3D offset; 890 VkExtent3D extent; 891 VkDeviceMemory memory; 892 VkDeviceSize memoryOffset; 893 VkSparseMemoryBindFlags flags; 894 } 895 struct VkSparseImageMemoryBindInfo { 896 VkImage image; 897 uint32_t bindCount; 898 const(VkSparseImageMemoryBind)* pBinds; 899 } 900 struct VkBindSparseInfo { 901 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; 902 const(void)* pNext; 903 uint32_t waitSemaphoreCount; 904 const(VkSemaphore)* pWaitSemaphores; 905 uint32_t bufferBindCount; 906 const(VkSparseBufferMemoryBindInfo)* pBufferBinds; 907 uint32_t imageOpaqueBindCount; 908 const(VkSparseImageOpaqueMemoryBindInfo)* pImageOpaqueBinds; 909 uint32_t imageBindCount; 910 const(VkSparseImageMemoryBindInfo)* pImageBinds; 911 uint32_t signalSemaphoreCount; 912 const(VkSemaphore)* pSignalSemaphores; 913 } 914 enum VkFenceCreateFlagBits { 915 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 916 } 917 alias VkFenceCreateFlags = VkFlags; 918 struct VkFenceCreateInfo { 919 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; 920 const(void)* pNext; 921 VkFenceCreateFlags flags; 922 } 923 alias VkSemaphoreCreateFlags = VkFlags; 924 struct VkSemaphoreCreateInfo { 925 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; 926 const(void)* pNext; 927 VkSemaphoreCreateFlags flags; 928 } 929 alias VkEventCreateFlags = VkFlags; 930 struct VkEventCreateInfo { 931 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; 932 const(void)* pNext; 933 VkEventCreateFlags flags; 934 } 935 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkEvent}); 936 alias VkQueryPoolCreateFlags = VkFlags; 937 enum VkQueryType { 938 VK_QUERY_TYPE_OCCLUSION = 0, 939 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, 940 VK_QUERY_TYPE_TIMESTAMP = 2, 941 } 942 enum VkQueryPipelineStatisticFlagBits { 943 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, 944 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, 945 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, 946 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, 947 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, 948 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, 949 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, 950 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, 951 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, 952 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, 953 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, 954 } 955 alias VkQueryPipelineStatisticFlags = VkFlags; 956 struct VkQueryPoolCreateInfo { 957 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; 958 const(void)* pNext; 959 VkQueryPoolCreateFlags flags; 960 VkQueryType queryType; 961 uint32_t queryCount; 962 VkQueryPipelineStatisticFlags pipelineStatistics; 963 } 964 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkQueryPool}); 965 enum VkQueryResultFlagBits { 966 VK_QUERY_RESULT_64_BIT = 0x00000001, 967 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, 968 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, 969 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, 970 } 971 alias VkQueryResultFlags = VkFlags; 972 enum VkBufferCreateFlagBits { 973 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, 974 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 975 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 976 } 977 alias VkBufferCreateFlags = VkFlags; 978 enum VkBufferUsageFlagBits { 979 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, 980 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, 981 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, 982 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, 983 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, 984 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, 985 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, 986 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, 987 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, 988 } 989 alias VkBufferUsageFlags = VkFlags; 990 enum VkSharingMode { 991 VK_SHARING_MODE_EXCLUSIVE = 0, 992 VK_SHARING_MODE_CONCURRENT = 1, 993 } 994 struct VkBufferCreateInfo { 995 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; 996 const(void)* pNext; 997 VkBufferCreateFlags flags; 998 VkDeviceSize size; 999 VkBufferUsageFlags usage; 1000 VkSharingMode sharingMode; 1001 uint32_t queueFamilyIndexCount; 1002 const(uint32_t)* pQueueFamilyIndices; 1003 } 1004 alias VkBufferViewCreateFlags = VkFlags; 1005 struct VkBufferViewCreateInfo { 1006 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; 1007 const(void)* pNext; 1008 VkBufferViewCreateFlags flags; 1009 VkBuffer buffer; 1010 VkFormat format; 1011 VkDeviceSize offset; 1012 VkDeviceSize range; 1013 } 1014 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkBufferView}); 1015 enum VkImageLayout { 1016 VK_IMAGE_LAYOUT_UNDEFINED = 0, 1017 VK_IMAGE_LAYOUT_GENERAL = 1, 1018 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, 1019 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, 1020 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, 1021 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, 1022 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, 1023 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, 1024 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, 1025 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, 1026 } 1027 struct VkImageCreateInfo { 1028 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; 1029 const(void)* pNext; 1030 VkImageCreateFlags flags; 1031 VkImageType imageType; 1032 VkFormat format; 1033 VkExtent3D extent; 1034 uint32_t mipLevels; 1035 uint32_t arrayLayers; 1036 VkSampleCountFlagBits samples; 1037 VkImageTiling tiling; 1038 VkImageUsageFlags usage; 1039 VkSharingMode sharingMode; 1040 uint32_t queueFamilyIndexCount; 1041 const(uint32_t)* pQueueFamilyIndices; 1042 VkImageLayout initialLayout; 1043 } 1044 struct VkSubresourceLayout { 1045 VkDeviceSize offset; 1046 VkDeviceSize size; 1047 VkDeviceSize rowPitch; 1048 VkDeviceSize arrayPitch; 1049 VkDeviceSize depthPitch; 1050 } 1051 alias VkImageViewCreateFlags = VkFlags; 1052 enum VkImageViewType { 1053 VK_IMAGE_VIEW_TYPE_1D = 0, 1054 VK_IMAGE_VIEW_TYPE_2D = 1, 1055 VK_IMAGE_VIEW_TYPE_3D = 2, 1056 VK_IMAGE_VIEW_TYPE_CUBE = 3, 1057 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, 1058 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, 1059 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, 1060 } 1061 enum VkComponentSwizzle { 1062 VK_COMPONENT_SWIZZLE_IDENTITY = 0, 1063 VK_COMPONENT_SWIZZLE_ZERO = 1, 1064 VK_COMPONENT_SWIZZLE_ONE = 2, 1065 VK_COMPONENT_SWIZZLE_R = 3, 1066 VK_COMPONENT_SWIZZLE_G = 4, 1067 VK_COMPONENT_SWIZZLE_B = 5, 1068 VK_COMPONENT_SWIZZLE_A = 6, 1069 } 1070 struct VkComponentMapping { 1071 VkComponentSwizzle r; 1072 VkComponentSwizzle g; 1073 VkComponentSwizzle b; 1074 VkComponentSwizzle a; 1075 } 1076 struct VkImageSubresourceRange { 1077 VkImageAspectFlags aspectMask; 1078 uint32_t baseMipLevel; 1079 uint32_t levelCount; 1080 uint32_t baseArrayLayer; 1081 uint32_t layerCount; 1082 } 1083 struct VkImageViewCreateInfo { 1084 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; 1085 const(void)* pNext; 1086 VkImageViewCreateFlags flags; 1087 VkImage image; 1088 VkImageViewType viewType; 1089 VkFormat format; 1090 VkComponentMapping components; 1091 VkImageSubresourceRange subresourceRange; 1092 } 1093 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkImageView}); 1094 alias VkShaderModuleCreateFlags = VkFlags; 1095 struct VkShaderModuleCreateInfo { 1096 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; 1097 const(void)* pNext; 1098 VkShaderModuleCreateFlags flags; 1099 size_t codeSize; 1100 const(uint32_t)* pCode; 1101 } 1102 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkShaderModule}); 1103 alias VkPipelineCacheCreateFlags = VkFlags; 1104 struct VkPipelineCacheCreateInfo { 1105 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; 1106 const(void)* pNext; 1107 VkPipelineCacheCreateFlags flags; 1108 size_t initialDataSize; 1109 const(void)* pInitialData; 1110 } 1111 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkPipelineCache}); 1112 enum VkPipelineCreateFlagBits { 1113 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 1114 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, 1115 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, 1116 } 1117 alias VkPipelineCreateFlags = VkFlags; 1118 alias VkPipelineShaderStageCreateFlags = VkFlags; 1119 enum VkShaderStageFlagBits { 1120 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 1121 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, 1122 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, 1123 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 1124 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 1125 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 1126 VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, 1127 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 1128 } 1129 struct VkSpecializationMapEntry { 1130 uint32_t constantID; 1131 uint32_t offset; 1132 size_t size; 1133 } 1134 struct VkSpecializationInfo { 1135 uint32_t mapEntryCount; 1136 const(VkSpecializationMapEntry)* pMapEntries; 1137 size_t dataSize; 1138 const(void)* pData; 1139 } 1140 struct VkPipelineShaderStageCreateInfo { 1141 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; 1142 const(void)* pNext; 1143 VkPipelineShaderStageCreateFlags flags; 1144 VkShaderStageFlagBits stage; 1145 VkShaderModule _module; 1146 const(char)* pName; 1147 const(VkSpecializationInfo)* pSpecializationInfo; 1148 } 1149 alias VkPipelineVertexInputStateCreateFlags = VkFlags; 1150 enum VkVertexInputRate { 1151 VK_VERTEX_INPUT_RATE_VERTEX = 0, 1152 VK_VERTEX_INPUT_RATE_INSTANCE = 1, 1153 } 1154 struct VkVertexInputBindingDescription { 1155 uint32_t binding; 1156 uint32_t stride; 1157 VkVertexInputRate inputRate; 1158 } 1159 struct VkVertexInputAttributeDescription { 1160 uint32_t location; 1161 uint32_t binding; 1162 VkFormat format; 1163 uint32_t offset; 1164 } 1165 struct VkPipelineVertexInputStateCreateInfo { 1166 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; 1167 const(void)* pNext; 1168 VkPipelineVertexInputStateCreateFlags flags; 1169 uint32_t vertexBindingDescriptionCount; 1170 const(VkVertexInputBindingDescription)* pVertexBindingDescriptions; 1171 uint32_t vertexAttributeDescriptionCount; 1172 const(VkVertexInputAttributeDescription)* pVertexAttributeDescriptions; 1173 } 1174 alias VkPipelineInputAssemblyStateCreateFlags = VkFlags; 1175 enum VkPrimitiveTopology { 1176 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, 1177 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, 1178 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, 1179 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, 1180 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, 1181 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, 1182 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, 1183 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, 1184 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, 1185 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, 1186 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, 1187 } 1188 struct VkPipelineInputAssemblyStateCreateInfo { 1189 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; 1190 const(void)* pNext; 1191 VkPipelineInputAssemblyStateCreateFlags flags; 1192 VkPrimitiveTopology topology; 1193 VkBool32 primitiveRestartEnable; 1194 } 1195 alias VkPipelineTessellationStateCreateFlags = VkFlags; 1196 struct VkPipelineTessellationStateCreateInfo { 1197 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; 1198 const(void)* pNext; 1199 VkPipelineTessellationStateCreateFlags flags; 1200 uint32_t patchControlPoints; 1201 } 1202 alias VkPipelineViewportStateCreateFlags = VkFlags; 1203 struct VkViewport { 1204 float x; 1205 float y; 1206 float width; 1207 float height; 1208 float minDepth; 1209 float maxDepth; 1210 } 1211 struct VkOffset2D { 1212 int32_t x; 1213 int32_t y; 1214 } 1215 struct VkExtent2D { 1216 uint32_t width; 1217 uint32_t height; 1218 } 1219 struct VkRect2D { 1220 VkOffset2D offset; 1221 VkExtent2D extent; 1222 } 1223 struct VkPipelineViewportStateCreateInfo { 1224 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; 1225 const(void)* pNext; 1226 VkPipelineViewportStateCreateFlags flags; 1227 uint32_t viewportCount; 1228 const(VkViewport)* pViewports; 1229 uint32_t scissorCount; 1230 const(VkRect2D)* pScissors; 1231 } 1232 alias VkPipelineRasterizationStateCreateFlags = VkFlags; 1233 enum VkPolygonMode { 1234 VK_POLYGON_MODE_FILL = 0, 1235 VK_POLYGON_MODE_LINE = 1, 1236 VK_POLYGON_MODE_POINT = 2, 1237 } 1238 enum VkCullModeFlagBits { 1239 VK_CULL_MODE_NONE = 0, 1240 VK_CULL_MODE_FRONT_BIT = 0x00000001, 1241 VK_CULL_MODE_BACK_BIT = 0x00000002, 1242 VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, 1243 } 1244 alias VkCullModeFlags = VkFlags; 1245 enum VkFrontFace { 1246 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, 1247 VK_FRONT_FACE_CLOCKWISE = 1, 1248 } 1249 struct VkPipelineRasterizationStateCreateInfo { 1250 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; 1251 const(void)* pNext; 1252 VkPipelineRasterizationStateCreateFlags flags; 1253 VkBool32 depthClampEnable; 1254 VkBool32 rasterizerDiscardEnable; 1255 VkPolygonMode polygonMode; 1256 VkCullModeFlags cullMode; 1257 VkFrontFace frontFace; 1258 VkBool32 depthBiasEnable; 1259 float depthBiasConstantFactor; 1260 float depthBiasClamp; 1261 float depthBiasSlopeFactor; 1262 float lineWidth; 1263 } 1264 alias VkPipelineMultisampleStateCreateFlags = VkFlags; 1265 alias VkSampleMask = uint32_t; 1266 struct VkPipelineMultisampleStateCreateInfo { 1267 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; 1268 const(void)* pNext; 1269 VkPipelineMultisampleStateCreateFlags flags; 1270 VkSampleCountFlagBits rasterizationSamples; 1271 VkBool32 sampleShadingEnable; 1272 float minSampleShading; 1273 const(VkSampleMask)* pSampleMask; 1274 VkBool32 alphaToCoverageEnable; 1275 VkBool32 alphaToOneEnable; 1276 } 1277 alias VkPipelineDepthStencilStateCreateFlags = VkFlags; 1278 enum VkCompareOp { 1279 VK_COMPARE_OP_NEVER = 0, 1280 VK_COMPARE_OP_LESS = 1, 1281 VK_COMPARE_OP_EQUAL = 2, 1282 VK_COMPARE_OP_LESS_OR_EQUAL = 3, 1283 VK_COMPARE_OP_GREATER = 4, 1284 VK_COMPARE_OP_NOT_EQUAL = 5, 1285 VK_COMPARE_OP_GREATER_OR_EQUAL = 6, 1286 VK_COMPARE_OP_ALWAYS = 7, 1287 } 1288 enum VkStencilOp { 1289 VK_STENCIL_OP_KEEP = 0, 1290 VK_STENCIL_OP_ZERO = 1, 1291 VK_STENCIL_OP_REPLACE = 2, 1292 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, 1293 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, 1294 VK_STENCIL_OP_INVERT = 5, 1295 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, 1296 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, 1297 } 1298 struct VkStencilOpState { 1299 VkStencilOp failOp; 1300 VkStencilOp passOp; 1301 VkStencilOp depthFailOp; 1302 VkCompareOp compareOp; 1303 uint32_t compareMask; 1304 uint32_t writeMask; 1305 uint32_t reference; 1306 } 1307 struct VkPipelineDepthStencilStateCreateInfo { 1308 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; 1309 const(void)* pNext; 1310 VkPipelineDepthStencilStateCreateFlags flags; 1311 VkBool32 depthTestEnable; 1312 VkBool32 depthWriteEnable; 1313 VkCompareOp depthCompareOp; 1314 VkBool32 depthBoundsTestEnable; 1315 VkBool32 stencilTestEnable; 1316 VkStencilOpState front; 1317 VkStencilOpState back; 1318 float minDepthBounds; 1319 float maxDepthBounds; 1320 } 1321 alias VkPipelineColorBlendStateCreateFlags = VkFlags; 1322 enum VkLogicOp { 1323 VK_LOGIC_OP_CLEAR = 0, 1324 VK_LOGIC_OP_AND = 1, 1325 VK_LOGIC_OP_AND_REVERSE = 2, 1326 VK_LOGIC_OP_COPY = 3, 1327 VK_LOGIC_OP_AND_INVERTED = 4, 1328 VK_LOGIC_OP_NO_OP = 5, 1329 VK_LOGIC_OP_XOR = 6, 1330 VK_LOGIC_OP_OR = 7, 1331 VK_LOGIC_OP_NOR = 8, 1332 VK_LOGIC_OP_EQUIVALENT = 9, 1333 VK_LOGIC_OP_INVERT = 10, 1334 VK_LOGIC_OP_OR_REVERSE = 11, 1335 VK_LOGIC_OP_COPY_INVERTED = 12, 1336 VK_LOGIC_OP_OR_INVERTED = 13, 1337 VK_LOGIC_OP_NAND = 14, 1338 VK_LOGIC_OP_SET = 15, 1339 } 1340 enum VkBlendFactor { 1341 VK_BLEND_FACTOR_ZERO = 0, 1342 VK_BLEND_FACTOR_ONE = 1, 1343 VK_BLEND_FACTOR_SRC_COLOR = 2, 1344 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, 1345 VK_BLEND_FACTOR_DST_COLOR = 4, 1346 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, 1347 VK_BLEND_FACTOR_SRC_ALPHA = 6, 1348 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, 1349 VK_BLEND_FACTOR_DST_ALPHA = 8, 1350 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, 1351 VK_BLEND_FACTOR_CONSTANT_COLOR = 10, 1352 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, 1353 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, 1354 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, 1355 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, 1356 VK_BLEND_FACTOR_SRC1_COLOR = 15, 1357 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, 1358 VK_BLEND_FACTOR_SRC1_ALPHA = 17, 1359 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, 1360 } 1361 enum VkBlendOp { 1362 VK_BLEND_OP_ADD = 0, 1363 VK_BLEND_OP_SUBTRACT = 1, 1364 VK_BLEND_OP_REVERSE_SUBTRACT = 2, 1365 VK_BLEND_OP_MIN = 3, 1366 VK_BLEND_OP_MAX = 4, 1367 } 1368 enum VkColorComponentFlagBits { 1369 VK_COLOR_COMPONENT_R_BIT = 0x00000001, 1370 VK_COLOR_COMPONENT_G_BIT = 0x00000002, 1371 VK_COLOR_COMPONENT_B_BIT = 0x00000004, 1372 VK_COLOR_COMPONENT_A_BIT = 0x00000008, 1373 } 1374 alias VkColorComponentFlags = VkFlags; 1375 struct VkPipelineColorBlendAttachmentState { 1376 VkBool32 blendEnable; 1377 VkBlendFactor srcColorBlendFactor; 1378 VkBlendFactor dstColorBlendFactor; 1379 VkBlendOp colorBlendOp; 1380 VkBlendFactor srcAlphaBlendFactor; 1381 VkBlendFactor dstAlphaBlendFactor; 1382 VkBlendOp alphaBlendOp; 1383 VkColorComponentFlags colorWriteMask; 1384 } 1385 struct VkPipelineColorBlendStateCreateInfo { 1386 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; 1387 const(void)* pNext; 1388 VkPipelineColorBlendStateCreateFlags flags; 1389 VkBool32 logicOpEnable; 1390 VkLogicOp logicOp; 1391 uint32_t attachmentCount; 1392 const(VkPipelineColorBlendAttachmentState)* pAttachments; 1393 float[4] blendConstants; 1394 } 1395 alias VkPipelineDynamicStateCreateFlags = VkFlags; 1396 enum VkDynamicState { 1397 VK_DYNAMIC_STATE_VIEWPORT = 0, 1398 VK_DYNAMIC_STATE_SCISSOR = 1, 1399 VK_DYNAMIC_STATE_LINE_WIDTH = 2, 1400 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, 1401 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, 1402 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, 1403 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, 1404 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, 1405 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, 1406 } 1407 struct VkPipelineDynamicStateCreateInfo { 1408 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; 1409 const(void)* pNext; 1410 VkPipelineDynamicStateCreateFlags flags; 1411 uint32_t dynamicStateCount; 1412 const(VkDynamicState)* pDynamicStates; 1413 } 1414 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkPipelineLayout}); 1415 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkRenderPass}); 1416 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkPipeline}); 1417 struct VkGraphicsPipelineCreateInfo { 1418 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; 1419 const(void)* pNext; 1420 VkPipelineCreateFlags flags; 1421 uint32_t stageCount; 1422 const(VkPipelineShaderStageCreateInfo)* pStages; 1423 const(VkPipelineVertexInputStateCreateInfo)* pVertexInputState; 1424 const(VkPipelineInputAssemblyStateCreateInfo)* pInputAssemblyState; 1425 const(VkPipelineTessellationStateCreateInfo)* pTessellationState; 1426 const(VkPipelineViewportStateCreateInfo)* pViewportState; 1427 const(VkPipelineRasterizationStateCreateInfo)* pRasterizationState; 1428 const(VkPipelineMultisampleStateCreateInfo)* pMultisampleState; 1429 const(VkPipelineDepthStencilStateCreateInfo)* pDepthStencilState; 1430 const(VkPipelineColorBlendStateCreateInfo)* pColorBlendState; 1431 const(VkPipelineDynamicStateCreateInfo)* pDynamicState; 1432 VkPipelineLayout layout; 1433 VkRenderPass renderPass; 1434 uint32_t subpass; 1435 VkPipeline basePipelineHandle; 1436 int32_t basePipelineIndex; 1437 } 1438 struct VkComputePipelineCreateInfo { 1439 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; 1440 const(void)* pNext; 1441 VkPipelineCreateFlags flags; 1442 VkPipelineShaderStageCreateInfo stage; 1443 VkPipelineLayout layout; 1444 VkPipeline basePipelineHandle; 1445 int32_t basePipelineIndex; 1446 } 1447 alias VkPipelineLayoutCreateFlags = VkFlags; 1448 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDescriptorSetLayout}); 1449 alias VkShaderStageFlags = VkFlags; 1450 struct VkPushConstantRange { 1451 VkShaderStageFlags stageFlags; 1452 uint32_t offset; 1453 uint32_t size; 1454 } 1455 struct VkPipelineLayoutCreateInfo { 1456 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; 1457 const(void)* pNext; 1458 VkPipelineLayoutCreateFlags flags; 1459 uint32_t setLayoutCount; 1460 const(VkDescriptorSetLayout)* pSetLayouts; 1461 uint32_t pushConstantRangeCount; 1462 const(VkPushConstantRange)* pPushConstantRanges; 1463 } 1464 alias VkSamplerCreateFlags = VkFlags; 1465 enum VkFilter { 1466 VK_FILTER_NEAREST = 0, 1467 VK_FILTER_LINEAR = 1, 1468 VK_FILTER_CUBIC_IMG = 1000015000, 1469 } 1470 enum VkSamplerMipmapMode { 1471 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, 1472 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, 1473 } 1474 enum VkSamplerAddressMode { 1475 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, 1476 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, 1477 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, 1478 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, 1479 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, 1480 } 1481 enum VkBorderColor { 1482 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, 1483 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, 1484 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, 1485 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, 1486 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, 1487 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, 1488 } 1489 struct VkSamplerCreateInfo { 1490 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; 1491 const(void)* pNext; 1492 VkSamplerCreateFlags flags; 1493 VkFilter magFilter; 1494 VkFilter minFilter; 1495 VkSamplerMipmapMode mipmapMode; 1496 VkSamplerAddressMode addressModeU; 1497 VkSamplerAddressMode addressModeV; 1498 VkSamplerAddressMode addressModeW; 1499 float mipLodBias; 1500 VkBool32 anisotropyEnable; 1501 float maxAnisotropy; 1502 VkBool32 compareEnable; 1503 VkCompareOp compareOp; 1504 float minLod; 1505 float maxLod; 1506 VkBorderColor borderColor; 1507 VkBool32 unnormalizedCoordinates; 1508 } 1509 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSampler}); 1510 alias VkDescriptorSetLayoutCreateFlags = VkFlags; 1511 enum VkDescriptorType { 1512 VK_DESCRIPTOR_TYPE_SAMPLER = 0, 1513 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, 1514 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, 1515 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, 1516 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, 1517 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, 1518 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, 1519 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, 1520 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, 1521 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, 1522 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, 1523 } 1524 struct VkDescriptorSetLayoutBinding { 1525 uint32_t binding; 1526 VkDescriptorType descriptorType; 1527 uint32_t descriptorCount; 1528 VkShaderStageFlags stageFlags; 1529 const(VkSampler)* pImmutableSamplers; 1530 } 1531 struct VkDescriptorSetLayoutCreateInfo { 1532 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; 1533 const(void)* pNext; 1534 VkDescriptorSetLayoutCreateFlags flags; 1535 uint32_t bindingCount; 1536 const(VkDescriptorSetLayoutBinding)* pBindings; 1537 } 1538 enum VkDescriptorPoolCreateFlagBits { 1539 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, 1540 } 1541 alias VkDescriptorPoolCreateFlags = VkFlags; 1542 struct VkDescriptorPoolSize { 1543 VkDescriptorType type; 1544 uint32_t descriptorCount; 1545 } 1546 struct VkDescriptorPoolCreateInfo { 1547 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; 1548 const(void)* pNext; 1549 VkDescriptorPoolCreateFlags flags; 1550 uint32_t maxSets; 1551 uint32_t poolSizeCount; 1552 const(VkDescriptorPoolSize)* pPoolSizes; 1553 } 1554 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDescriptorPool}); 1555 alias VkDescriptorPoolResetFlags = VkFlags; 1556 struct VkDescriptorSetAllocateInfo { 1557 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; 1558 const(void)* pNext; 1559 VkDescriptorPool descriptorPool; 1560 uint32_t descriptorSetCount; 1561 const(VkDescriptorSetLayout)* pSetLayouts; 1562 } 1563 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDescriptorSet}); 1564 struct VkDescriptorImageInfo { 1565 VkSampler sampler; 1566 VkImageView imageView; 1567 VkImageLayout imageLayout; 1568 } 1569 struct VkDescriptorBufferInfo { 1570 VkBuffer buffer; 1571 VkDeviceSize offset; 1572 VkDeviceSize range; 1573 } 1574 struct VkWriteDescriptorSet { 1575 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; 1576 const(void)* pNext; 1577 VkDescriptorSet dstSet; 1578 uint32_t dstBinding; 1579 uint32_t dstArrayElement; 1580 uint32_t descriptorCount; 1581 VkDescriptorType descriptorType; 1582 const(VkDescriptorImageInfo)* pImageInfo; 1583 const(VkDescriptorBufferInfo)* pBufferInfo; 1584 const(VkBufferView)* pTexelBufferView; 1585 } 1586 struct VkCopyDescriptorSet { 1587 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; 1588 const(void)* pNext; 1589 VkDescriptorSet srcSet; 1590 uint32_t srcBinding; 1591 uint32_t srcArrayElement; 1592 VkDescriptorSet dstSet; 1593 uint32_t dstBinding; 1594 uint32_t dstArrayElement; 1595 uint32_t descriptorCount; 1596 } 1597 alias VkFramebufferCreateFlags = VkFlags; 1598 struct VkFramebufferCreateInfo { 1599 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; 1600 const(void)* pNext; 1601 VkFramebufferCreateFlags flags; 1602 VkRenderPass renderPass; 1603 uint32_t attachmentCount; 1604 const(VkImageView)* pAttachments; 1605 uint32_t width; 1606 uint32_t height; 1607 uint32_t layers; 1608 } 1609 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkFramebuffer}); 1610 alias VkRenderPassCreateFlags = VkFlags; 1611 enum VkAttachmentDescriptionFlagBits { 1612 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, 1613 } 1614 alias VkAttachmentDescriptionFlags = VkFlags; 1615 enum VkAttachmentLoadOp { 1616 VK_ATTACHMENT_LOAD_OP_LOAD = 0, 1617 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, 1618 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, 1619 } 1620 enum VkAttachmentStoreOp { 1621 VK_ATTACHMENT_STORE_OP_STORE = 0, 1622 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, 1623 } 1624 struct VkAttachmentDescription { 1625 VkAttachmentDescriptionFlags flags; 1626 VkFormat format; 1627 VkSampleCountFlagBits samples; 1628 VkAttachmentLoadOp loadOp; 1629 VkAttachmentStoreOp storeOp; 1630 VkAttachmentLoadOp stencilLoadOp; 1631 VkAttachmentStoreOp stencilStoreOp; 1632 VkImageLayout initialLayout; 1633 VkImageLayout finalLayout; 1634 } 1635 alias VkSubpassDescriptionFlags = VkFlags; 1636 enum VkPipelineBindPoint { 1637 VK_PIPELINE_BIND_POINT_GRAPHICS = 0, 1638 VK_PIPELINE_BIND_POINT_COMPUTE = 1, 1639 } 1640 struct VkAttachmentReference { 1641 uint32_t attachment; 1642 VkImageLayout layout; 1643 } 1644 struct VkSubpassDescription { 1645 VkSubpassDescriptionFlags flags; 1646 VkPipelineBindPoint pipelineBindPoint; 1647 uint32_t inputAttachmentCount; 1648 const(VkAttachmentReference)* pInputAttachments; 1649 uint32_t colorAttachmentCount; 1650 const(VkAttachmentReference)* pColorAttachments; 1651 const(VkAttachmentReference)* pResolveAttachments; 1652 const(VkAttachmentReference)* pDepthStencilAttachment; 1653 uint32_t preserveAttachmentCount; 1654 const(uint32_t)* pPreserveAttachments; 1655 } 1656 enum VkAccessFlagBits { 1657 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, 1658 VK_ACCESS_INDEX_READ_BIT = 0x00000002, 1659 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, 1660 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, 1661 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, 1662 VK_ACCESS_SHADER_READ_BIT = 0x00000020, 1663 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, 1664 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, 1665 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, 1666 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, 1667 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, 1668 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, 1669 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, 1670 VK_ACCESS_HOST_READ_BIT = 0x00002000, 1671 VK_ACCESS_HOST_WRITE_BIT = 0x00004000, 1672 VK_ACCESS_MEMORY_READ_BIT = 0x00008000, 1673 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, 1674 } 1675 alias VkAccessFlags = VkFlags; 1676 enum VkDependencyFlagBits { 1677 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, 1678 } 1679 alias VkDependencyFlags = VkFlags; 1680 struct VkSubpassDependency { 1681 uint32_t srcSubpass; 1682 uint32_t dstSubpass; 1683 VkPipelineStageFlags srcStageMask; 1684 VkPipelineStageFlags dstStageMask; 1685 VkAccessFlags srcAccessMask; 1686 VkAccessFlags dstAccessMask; 1687 VkDependencyFlags dependencyFlags; 1688 } 1689 struct VkRenderPassCreateInfo { 1690 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; 1691 const(void)* pNext; 1692 VkRenderPassCreateFlags flags; 1693 uint32_t attachmentCount; 1694 const(VkAttachmentDescription)* pAttachments; 1695 uint32_t subpassCount; 1696 const(VkSubpassDescription)* pSubpasses; 1697 uint32_t dependencyCount; 1698 const(VkSubpassDependency)* pDependencies; 1699 } 1700 enum VkCommandPoolCreateFlagBits { 1701 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 1702 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 1703 } 1704 alias VkCommandPoolCreateFlags = VkFlags; 1705 struct VkCommandPoolCreateInfo { 1706 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; 1707 const(void)* pNext; 1708 VkCommandPoolCreateFlags flags; 1709 uint32_t queueFamilyIndex; 1710 } 1711 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkCommandPool}); 1712 enum VkCommandPoolResetFlagBits { 1713 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1714 } 1715 alias VkCommandPoolResetFlags = VkFlags; 1716 enum VkCommandBufferLevel { 1717 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, 1718 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, 1719 } 1720 struct VkCommandBufferAllocateInfo { 1721 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; 1722 const(void)* pNext; 1723 VkCommandPool commandPool; 1724 VkCommandBufferLevel level; 1725 uint32_t commandBufferCount; 1726 } 1727 enum VkCommandBufferUsageFlagBits { 1728 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, 1729 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, 1730 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, 1731 } 1732 alias VkCommandBufferUsageFlags = VkFlags; 1733 enum VkQueryControlFlagBits { 1734 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, 1735 } 1736 alias VkQueryControlFlags = VkFlags; 1737 struct VkCommandBufferInheritanceInfo { 1738 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; 1739 const(void)* pNext; 1740 VkRenderPass renderPass; 1741 uint32_t subpass; 1742 VkFramebuffer framebuffer; 1743 VkBool32 occlusionQueryEnable; 1744 VkQueryControlFlags queryFlags; 1745 VkQueryPipelineStatisticFlags pipelineStatistics; 1746 } 1747 struct VkCommandBufferBeginInfo { 1748 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; 1749 const(void)* pNext; 1750 VkCommandBufferUsageFlags flags; 1751 const(VkCommandBufferInheritanceInfo)* pInheritanceInfo; 1752 } 1753 enum VkCommandBufferResetFlagBits { 1754 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1755 } 1756 alias VkCommandBufferResetFlags = VkFlags; 1757 enum VkStencilFaceFlagBits { 1758 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, 1759 VK_STENCIL_FACE_BACK_BIT = 0x00000002, 1760 VK_STENCIL_FRONT_AND_BACK = 0x00000003, 1761 } 1762 alias VkStencilFaceFlags = VkFlags; 1763 enum VkIndexType { 1764 VK_INDEX_TYPE_UINT16 = 0, 1765 VK_INDEX_TYPE_UINT32 = 1, 1766 } 1767 struct VkBufferCopy { 1768 VkDeviceSize srcOffset; 1769 VkDeviceSize dstOffset; 1770 VkDeviceSize size; 1771 } 1772 struct VkImageSubresourceLayers { 1773 VkImageAspectFlags aspectMask; 1774 uint32_t mipLevel; 1775 uint32_t baseArrayLayer; 1776 uint32_t layerCount; 1777 } 1778 struct VkImageCopy { 1779 VkImageSubresourceLayers srcSubresource; 1780 VkOffset3D srcOffset; 1781 VkImageSubresourceLayers dstSubresource; 1782 VkOffset3D dstOffset; 1783 VkExtent3D extent; 1784 } 1785 struct VkImageBlit { 1786 VkImageSubresourceLayers srcSubresource; 1787 VkOffset3D[2] srcOffsets; 1788 VkImageSubresourceLayers dstSubresource; 1789 VkOffset3D[2] dstOffsets; 1790 } 1791 struct VkBufferImageCopy { 1792 VkDeviceSize bufferOffset; 1793 uint32_t bufferRowLength; 1794 uint32_t bufferImageHeight; 1795 VkImageSubresourceLayers imageSubresource; 1796 VkOffset3D imageOffset; 1797 VkExtent3D imageExtent; 1798 } 1799 union VkClearColorValue { 1800 float[4] float32; 1801 int32_t[4] int32; 1802 uint32_t[4] uint32; 1803 } 1804 struct VkClearDepthStencilValue { 1805 float depth; 1806 uint32_t stencil; 1807 } 1808 union VkClearValue { 1809 VkClearColorValue color; 1810 VkClearDepthStencilValue depthStencil; 1811 } 1812 struct VkClearAttachment { 1813 VkImageAspectFlags aspectMask; 1814 uint32_t colorAttachment; 1815 VkClearValue clearValue; 1816 } 1817 struct VkClearRect { 1818 VkRect2D rect; 1819 uint32_t baseArrayLayer; 1820 uint32_t layerCount; 1821 } 1822 struct VkImageResolve { 1823 VkImageSubresourceLayers srcSubresource; 1824 VkOffset3D srcOffset; 1825 VkImageSubresourceLayers dstSubresource; 1826 VkOffset3D dstOffset; 1827 VkExtent3D extent; 1828 } 1829 struct VkMemoryBarrier { 1830 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_BARRIER; 1831 const(void)* pNext; 1832 VkAccessFlags srcAccessMask; 1833 VkAccessFlags dstAccessMask; 1834 } 1835 struct VkBufferMemoryBarrier { 1836 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; 1837 const(void)* pNext; 1838 VkAccessFlags srcAccessMask; 1839 VkAccessFlags dstAccessMask; 1840 uint32_t srcQueueFamilyIndex; 1841 uint32_t dstQueueFamilyIndex; 1842 VkBuffer buffer; 1843 VkDeviceSize offset; 1844 VkDeviceSize size; 1845 } 1846 struct VkImageMemoryBarrier { 1847 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; 1848 const(void)* pNext; 1849 VkAccessFlags srcAccessMask; 1850 VkAccessFlags dstAccessMask; 1851 VkImageLayout oldLayout; 1852 VkImageLayout newLayout; 1853 uint32_t srcQueueFamilyIndex; 1854 uint32_t dstQueueFamilyIndex; 1855 VkImage image; 1856 VkImageSubresourceRange subresourceRange; 1857 } 1858 struct VkRenderPassBeginInfo { 1859 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; 1860 const(void)* pNext; 1861 VkRenderPass renderPass; 1862 VkFramebuffer framebuffer; 1863 VkRect2D renderArea; 1864 uint32_t clearValueCount; 1865 const(VkClearValue)* pClearValues; 1866 } 1867 enum VkSubpassContents { 1868 VK_SUBPASS_CONTENTS_INLINE = 0, 1869 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, 1870 } 1871 struct VkDispatchIndirectCommand { 1872 uint32_t x; 1873 uint32_t y; 1874 uint32_t z; 1875 } 1876 struct VkDrawIndexedIndirectCommand { 1877 uint32_t indexCount; 1878 uint32_t instanceCount; 1879 uint32_t firstIndex; 1880 int32_t vertexOffset; 1881 uint32_t firstInstance; 1882 } 1883 struct VkDrawIndirectCommand { 1884 uint32_t vertexCount; 1885 uint32_t instanceCount; 1886 uint32_t firstVertex; 1887 uint32_t firstInstance; 1888 } 1889 } 1890 version(DVulkan_VK_KHR_surface) { 1891 enum VK_KHR_SURFACE_SPEC_VERSION = 25; 1892 enum VK_KHR_SURFACE_EXTENSION_NAME = "VK_KHR_surface"; 1893 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSurfaceKHR}); 1894 enum VkSurfaceTransformFlagBitsKHR { 1895 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, 1896 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, 1897 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, 1898 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, 1899 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, 1900 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, 1901 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, 1902 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, 1903 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, 1904 } 1905 alias VkSurfaceTransformFlagsKHR = VkFlags; 1906 enum VkCompositeAlphaFlagBitsKHR { 1907 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 1908 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, 1909 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, 1910 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, 1911 } 1912 alias VkCompositeAlphaFlagsKHR = VkFlags; 1913 struct VkSurfaceCapabilitiesKHR { 1914 uint32_t minImageCount; 1915 uint32_t maxImageCount; 1916 VkExtent2D currentExtent; 1917 VkExtent2D minImageExtent; 1918 VkExtent2D maxImageExtent; 1919 uint32_t maxImageArrayLayers; 1920 VkSurfaceTransformFlagsKHR supportedTransforms; 1921 VkSurfaceTransformFlagBitsKHR currentTransform; 1922 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 1923 VkImageUsageFlags supportedUsageFlags; 1924 } 1925 enum VkColorSpaceKHR { 1926 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, 1927 VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 1928 } 1929 struct VkSurfaceFormatKHR { 1930 VkFormat format; 1931 VkColorSpaceKHR colorSpace; 1932 } 1933 enum VkPresentModeKHR { 1934 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, 1935 VK_PRESENT_MODE_MAILBOX_KHR = 1, 1936 VK_PRESENT_MODE_FIFO_KHR = 2, 1937 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, 1938 } 1939 } 1940 version(DVulkan_VK_KHR_swapchain) { 1941 enum VK_KHR_SWAPCHAIN_SPEC_VERSION = 68; 1942 enum VK_KHR_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_swapchain"; 1943 alias VkSwapchainCreateFlagsKHR = VkFlags; 1944 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSwapchainKHR}); 1945 struct VkSwapchainCreateInfoKHR { 1946 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; 1947 const(void)* pNext; 1948 VkSwapchainCreateFlagsKHR flags; 1949 VkSurfaceKHR surface; 1950 uint32_t minImageCount; 1951 VkFormat imageFormat; 1952 VkColorSpaceKHR imageColorSpace; 1953 VkExtent2D imageExtent; 1954 uint32_t imageArrayLayers; 1955 VkImageUsageFlags imageUsage; 1956 VkSharingMode imageSharingMode; 1957 uint32_t queueFamilyIndexCount; 1958 const(uint32_t)* pQueueFamilyIndices; 1959 VkSurfaceTransformFlagBitsKHR preTransform; 1960 VkCompositeAlphaFlagBitsKHR compositeAlpha; 1961 VkPresentModeKHR presentMode; 1962 VkBool32 clipped; 1963 VkSwapchainKHR oldSwapchain; 1964 } 1965 struct VkPresentInfoKHR { 1966 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; 1967 const(void)* pNext; 1968 uint32_t waitSemaphoreCount; 1969 const(VkSemaphore)* pWaitSemaphores; 1970 uint32_t swapchainCount; 1971 const(VkSwapchainKHR)* pSwapchains; 1972 const(uint32_t)* pImageIndices; 1973 VkResult* pResults; 1974 } 1975 } 1976 version(DVulkan_VK_KHR_display) { 1977 enum VkDisplayPlaneAlphaFlagBitsKHR { 1978 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 1979 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, 1980 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, 1981 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, 1982 } 1983 alias VkDisplayPlaneAlphaFlagsKHR = VkFlags; 1984 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDisplayKHR}); 1985 struct VkDisplayPropertiesKHR { 1986 VkDisplayKHR display; 1987 const(char)* displayName; 1988 VkExtent2D physicalDimensions; 1989 VkExtent2D physicalResolution; 1990 VkSurfaceTransformFlagsKHR supportedTransforms; 1991 VkBool32 planeReorderPossible; 1992 VkBool32 persistentContent; 1993 } 1994 struct VkDisplayModeParametersKHR { 1995 VkExtent2D visibleRegion; 1996 uint32_t refreshRate; 1997 } 1998 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDisplayModeKHR}); 1999 struct VkDisplayModePropertiesKHR { 2000 VkDisplayModeKHR displayMode; 2001 VkDisplayModeParametersKHR parameters; 2002 } 2003 alias VkDisplayModeCreateFlagsKHR = VkFlags; 2004 struct VkDisplayModeCreateInfoKHR { 2005 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR; 2006 const(void)* pNext; 2007 VkDisplayModeCreateFlagsKHR flags; 2008 VkDisplayModeParametersKHR parameters; 2009 } 2010 struct VkDisplayPlaneCapabilitiesKHR { 2011 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; 2012 VkOffset2D minSrcPosition; 2013 VkOffset2D maxSrcPosition; 2014 VkExtent2D minSrcExtent; 2015 VkExtent2D maxSrcExtent; 2016 VkOffset2D minDstPosition; 2017 VkOffset2D maxDstPosition; 2018 VkExtent2D minDstExtent; 2019 VkExtent2D maxDstExtent; 2020 } 2021 struct VkDisplayPlanePropertiesKHR { 2022 VkDisplayKHR currentDisplay; 2023 uint32_t currentStackIndex; 2024 } 2025 alias VkDisplaySurfaceCreateFlagsKHR = VkFlags; 2026 struct VkDisplaySurfaceCreateInfoKHR { 2027 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR; 2028 const(void)* pNext; 2029 VkDisplaySurfaceCreateFlagsKHR flags; 2030 VkDisplayModeKHR displayMode; 2031 uint32_t planeIndex; 2032 uint32_t planeStackIndex; 2033 VkSurfaceTransformFlagBitsKHR transform; 2034 float globalAlpha; 2035 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; 2036 VkExtent2D imageExtent; 2037 } 2038 enum VK_KHR_DISPLAY_SPEC_VERSION = 21; 2039 enum VK_KHR_DISPLAY_EXTENSION_NAME = "VK_KHR_display"; 2040 } 2041 version(DVulkan_VK_KHR_display_swapchain) { 2042 struct VkDisplayPresentInfoKHR { 2043 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR; 2044 const(void)* pNext; 2045 VkRect2D srcRect; 2046 VkRect2D dstRect; 2047 VkBool32 persistent; 2048 } 2049 enum VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION = 9; 2050 enum VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_display_swapchain"; 2051 } 2052 version(DVulkan_VK_KHR_sampler_mirror_clamp_to_edge) { 2053 enum VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION = 1; 2054 enum VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME = "VK_KHR_sampler_mirror_clamp_to_edge"; 2055 } 2056 version(DVulkan_VK_ANDROID_native_buffer) { 2057 enum VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION = 4; 2058 enum VK_ANDROID_NATIVE_BUFFER_NUMBER = 11; 2059 enum VK_ANDROID_NATIVE_BUFFER_NAME = "VK_ANDROID_native_buffer"; 2060 } 2061 version(DVulkan_VK_EXT_debug_report) { 2062 enum VkDebugReportObjectTypeEXT { 2063 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, 2064 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, 2065 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, 2066 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, 2067 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, 2068 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, 2069 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, 2070 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, 2071 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, 2072 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, 2073 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, 2074 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, 2075 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, 2076 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, 2077 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, 2078 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, 2079 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, 2080 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, 2081 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, 2082 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, 2083 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, 2084 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, 2085 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, 2086 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, 2087 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, 2088 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, 2089 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, 2090 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, 2091 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, 2092 } 2093 enum VkDebugReportErrorEXT { 2094 VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, 2095 VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, 2096 } 2097 enum VK_EXT_DEBUG_REPORT_SPEC_VERSION = 2; 2098 enum VK_EXT_DEBUG_REPORT_EXTENSION_NAME = "VK_EXT_debug_report"; 2099 enum VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; 2100 enum VkDebugReportFlagBitsEXT { 2101 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, 2102 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, 2103 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, 2104 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, 2105 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, 2106 } 2107 alias VkDebugReportFlagsEXT = VkFlags; 2108 alias PFN_vkDebugReportCallbackEXT = VkBool32 function( 2109 VkDebugReportFlagsEXT flags, 2110 VkDebugReportObjectTypeEXT objectType, 2111 uint64_t object, 2112 size_t location, 2113 int32_t messageCode, 2114 const char* pLayerPrefix, 2115 const char* pMessage, 2116 void* pUserData); 2117 struct VkDebugReportCallbackCreateInfoEXT { 2118 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; 2119 const(void)* pNext; 2120 VkDebugReportFlagsEXT flags; 2121 PFN_vkDebugReportCallbackEXT pfnCallback; 2122 void* pUserData; 2123 } 2124 mixin(VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDebugReportCallbackEXT}); 2125 } 2126 version(DVulkan_VK_NV_glsl_shader) { 2127 enum VK_NV_GLSL_SHADER_SPEC_VERSION = 1; 2128 enum VK_NV_GLSL_SHADER_EXTENSION_NAME = "VK_NV_glsl_shader"; 2129 } 2130 version(DVulkan_VK_NV_extension_1) { 2131 enum VK_NV_EXTENSION_1_SPEC_VERSION = 0; 2132 enum VK_NV_EXTENSION_1_EXTENSION_NAME = "VK_NV_extension_1"; 2133 } 2134 version(DVulkan_VK_IMG_filter_cubic) { 2135 enum VK_IMG_FILTER_CUBIC_SPEC_VERSION = 1; 2136 enum VK_IMG_FILTER_CUBIC_EXTENSION_NAME = "VK_IMG_filter_cubic"; 2137 } 2138 version(DVulkan_VK_AMD_extension_1) { 2139 enum VK_AMD_EXTENSION_1_SPEC_VERSION = 0; 2140 enum VK_AMD_EXTENSION_1_EXTENSION_NAME = "VK_AMD_extension_1"; 2141 } 2142 version(DVulkan_VK_AMD_extension_2) { 2143 enum VK_AMD_EXTENSION_2_SPEC_VERSION = 0; 2144 enum VK_AMD_EXTENSION_2_EXTENSION_NAME = "VK_AMD_extension_2"; 2145 } 2146 version(DVulkan_VK_AMD_rasterization_order) { 2147 enum VkRasterizationOrderAMD { 2148 VK_RASTERIZATION_ORDER_STRICT_AMD = 0, 2149 VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, 2150 } 2151 struct VkPipelineRasterizationStateRasterizationOrderAMD { 2152 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; 2153 const(void)* pNext; 2154 VkRasterizationOrderAMD rasterizationOrder; 2155 } 2156 enum VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION = 1; 2157 enum VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME = "VK_AMD_rasterization_order"; 2158 } 2159 version(DVulkan_VK_AMD_extension_4) { 2160 enum VK_AMD_EXTENSION_4_SPEC_VERSION = 0; 2161 enum VK_AMD_EXTENSION_4_EXTENSION_NAME = "VK_AMD_extension_4"; 2162 } 2163 version(DVulkan_VK_AMD_extension_5) { 2164 enum VK_AMD_EXTENSION_5_SPEC_VERSION = 0; 2165 enum VK_AMD_EXTENSION_5_EXTENSION_NAME = "VK_AMD_extension_5"; 2166 } 2167 version(DVulkan_VK_AMD_extension_6) { 2168 enum VK_AMD_EXTENSION_6_SPEC_VERSION = 0; 2169 enum VK_AMD_EXTENSION_6_EXTENSION_NAME = "VK_AMD_extension_6"; 2170 } 2171 version(DVulkan_VK_EXT_debug_marker) { 2172 struct VkDebugMarkerObjectNameInfoEXT { 2173 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; 2174 const(void)* pNext; 2175 VkDebugReportObjectTypeEXT objectType; 2176 uint64_t object; 2177 const(char)* pObjectName; 2178 } 2179 struct VkDebugMarkerObjectTagInfoEXT { 2180 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT; 2181 const(void)* pNext; 2182 VkDebugReportObjectTypeEXT objectType; 2183 uint64_t object; 2184 uint64_t tagName; 2185 size_t tagSize; 2186 const(void)* pTag; 2187 } 2188 struct VkDebugMarkerMarkerInfoEXT { 2189 VkStructureType sType = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; 2190 const(void)* pNext; 2191 const(char)* pMarkerName; 2192 float[4] color; 2193 } 2194 enum VK_EXT_DEBUG_MARKER_SPEC_VERSION = 3; 2195 enum VK_EXT_DEBUG_MARKER_EXTENSION_NAME = "VK_EXT_debug_marker"; 2196 } 2197 version(DVulkanGlobalEnums) { 2198 version(DVulkan_VK_VERSION_1_0) { 2199 enum VK_PIPELINE_CACHE_HEADER_VERSION_ONE = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_ONE; 2200 enum VK_SUCCESS = VkResult.VK_SUCCESS; 2201 enum VK_NOT_READY = VkResult.VK_NOT_READY; 2202 enum VK_TIMEOUT = VkResult.VK_TIMEOUT; 2203 enum VK_EVENT_SET = VkResult.VK_EVENT_SET; 2204 enum VK_EVENT_RESET = VkResult.VK_EVENT_RESET; 2205 enum VK_INCOMPLETE = VkResult.VK_INCOMPLETE; 2206 enum VK_ERROR_OUT_OF_HOST_MEMORY = VkResult.VK_ERROR_OUT_OF_HOST_MEMORY; 2207 enum VK_ERROR_OUT_OF_DEVICE_MEMORY = VkResult.VK_ERROR_OUT_OF_DEVICE_MEMORY; 2208 enum VK_ERROR_INITIALIZATION_FAILED = VkResult.VK_ERROR_INITIALIZATION_FAILED; 2209 enum VK_ERROR_DEVICE_LOST = VkResult.VK_ERROR_DEVICE_LOST; 2210 enum VK_ERROR_MEMORY_MAP_FAILED = VkResult.VK_ERROR_MEMORY_MAP_FAILED; 2211 enum VK_ERROR_LAYER_NOT_PRESENT = VkResult.VK_ERROR_LAYER_NOT_PRESENT; 2212 enum VK_ERROR_EXTENSION_NOT_PRESENT = VkResult.VK_ERROR_EXTENSION_NOT_PRESENT; 2213 enum VK_ERROR_FEATURE_NOT_PRESENT = VkResult.VK_ERROR_FEATURE_NOT_PRESENT; 2214 enum VK_ERROR_INCOMPATIBLE_DRIVER = VkResult.VK_ERROR_INCOMPATIBLE_DRIVER; 2215 enum VK_ERROR_TOO_MANY_OBJECTS = VkResult.VK_ERROR_TOO_MANY_OBJECTS; 2216 enum VK_ERROR_FORMAT_NOT_SUPPORTED = VkResult.VK_ERROR_FORMAT_NOT_SUPPORTED; 2217 enum VK_ERROR_SURFACE_LOST_KHR = VkResult.VK_ERROR_SURFACE_LOST_KHR; 2218 enum VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = VkResult.VK_ERROR_NATIVE_WINDOW_IN_USE_KHR; 2219 enum VK_SUBOPTIMAL_KHR = VkResult.VK_SUBOPTIMAL_KHR; 2220 enum VK_ERROR_OUT_OF_DATE_KHR = VkResult.VK_ERROR_OUT_OF_DATE_KHR; 2221 enum VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = VkResult.VK_ERROR_INCOMPATIBLE_DISPLAY_KHR; 2222 enum VK_ERROR_VALIDATION_FAILED_EXT = VkResult.VK_ERROR_VALIDATION_FAILED_EXT; 2223 enum VK_ERROR_INVALID_SHADER_NV = VkResult.VK_ERROR_INVALID_SHADER_NV; 2224 enum VK_NV_EXTENSION_1_ERROR = VkResult.VK_NV_EXTENSION_1_ERROR; 2225 enum VK_STRUCTURE_TYPE_APPLICATION_INFO = VkStructureType.VK_STRUCTURE_TYPE_APPLICATION_INFO; 2226 enum VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; 2227 enum VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; 2228 enum VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; 2229 enum VK_STRUCTURE_TYPE_SUBMIT_INFO = VkStructureType.VK_STRUCTURE_TYPE_SUBMIT_INFO; 2230 enum VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; 2231 enum VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = VkStructureType.VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; 2232 enum VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = VkStructureType.VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; 2233 enum VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; 2234 enum VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; 2235 enum VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; 2236 enum VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; 2237 enum VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; 2238 enum VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; 2239 enum VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; 2240 enum VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; 2241 enum VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; 2242 enum VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; 2243 enum VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; 2244 enum VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; 2245 enum VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; 2246 enum VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; 2247 enum VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; 2248 enum VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; 2249 enum VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; 2250 enum VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; 2251 enum VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; 2252 enum VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; 2253 enum VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; 2254 enum VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; 2255 enum VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; 2256 enum VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; 2257 enum VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; 2258 enum VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; 2259 enum VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; 2260 enum VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = VkStructureType.VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; 2261 enum VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = VkStructureType.VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; 2262 enum VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; 2263 enum VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; 2264 enum VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; 2265 enum VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; 2266 enum VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; 2267 enum VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; 2268 enum VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; 2269 enum VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; 2270 enum VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; 2271 enum VK_STRUCTURE_TYPE_MEMORY_BARRIER = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_BARRIER; 2272 enum VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO; 2273 enum VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO; 2274 enum VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; 2275 enum VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; 2276 enum VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR; 2277 enum VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR; 2278 enum VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR; 2279 enum VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; 2280 enum VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; 2281 enum VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; 2282 enum VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR; 2283 enum VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; 2284 enum VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; 2285 enum VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; 2286 enum VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; 2287 enum VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; 2288 enum VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT; 2289 enum VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; 2290 enum VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_COMMAND; 2291 enum VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_OBJECT; 2292 enum VK_SYSTEM_ALLOCATION_SCOPE_CACHE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_CACHE; 2293 enum VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_DEVICE; 2294 enum VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE; 2295 enum VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE; 2296 enum VK_FORMAT_UNDEFINED = VkFormat.VK_FORMAT_UNDEFINED; 2297 enum VK_FORMAT_R4G4_UNORM_PACK8 = VkFormat.VK_FORMAT_R4G4_UNORM_PACK8; 2298 enum VK_FORMAT_R4G4B4A4_UNORM_PACK16 = VkFormat.VK_FORMAT_R4G4B4A4_UNORM_PACK16; 2299 enum VK_FORMAT_B4G4R4A4_UNORM_PACK16 = VkFormat.VK_FORMAT_B4G4R4A4_UNORM_PACK16; 2300 enum VK_FORMAT_R5G6B5_UNORM_PACK16 = VkFormat.VK_FORMAT_R5G6B5_UNORM_PACK16; 2301 enum VK_FORMAT_B5G6R5_UNORM_PACK16 = VkFormat.VK_FORMAT_B5G6R5_UNORM_PACK16; 2302 enum VK_FORMAT_R5G5B5A1_UNORM_PACK16 = VkFormat.VK_FORMAT_R5G5B5A1_UNORM_PACK16; 2303 enum VK_FORMAT_B5G5R5A1_UNORM_PACK16 = VkFormat.VK_FORMAT_B5G5R5A1_UNORM_PACK16; 2304 enum VK_FORMAT_A1R5G5B5_UNORM_PACK16 = VkFormat.VK_FORMAT_A1R5G5B5_UNORM_PACK16; 2305 enum VK_FORMAT_R8_UNORM = VkFormat.VK_FORMAT_R8_UNORM; 2306 enum VK_FORMAT_R8_SNORM = VkFormat.VK_FORMAT_R8_SNORM; 2307 enum VK_FORMAT_R8_USCALED = VkFormat.VK_FORMAT_R8_USCALED; 2308 enum VK_FORMAT_R8_SSCALED = VkFormat.VK_FORMAT_R8_SSCALED; 2309 enum VK_FORMAT_R8_UINT = VkFormat.VK_FORMAT_R8_UINT; 2310 enum VK_FORMAT_R8_SINT = VkFormat.VK_FORMAT_R8_SINT; 2311 enum VK_FORMAT_R8_SRGB = VkFormat.VK_FORMAT_R8_SRGB; 2312 enum VK_FORMAT_R8G8_UNORM = VkFormat.VK_FORMAT_R8G8_UNORM; 2313 enum VK_FORMAT_R8G8_SNORM = VkFormat.VK_FORMAT_R8G8_SNORM; 2314 enum VK_FORMAT_R8G8_USCALED = VkFormat.VK_FORMAT_R8G8_USCALED; 2315 enum VK_FORMAT_R8G8_SSCALED = VkFormat.VK_FORMAT_R8G8_SSCALED; 2316 enum VK_FORMAT_R8G8_UINT = VkFormat.VK_FORMAT_R8G8_UINT; 2317 enum VK_FORMAT_R8G8_SINT = VkFormat.VK_FORMAT_R8G8_SINT; 2318 enum VK_FORMAT_R8G8_SRGB = VkFormat.VK_FORMAT_R8G8_SRGB; 2319 enum VK_FORMAT_R8G8B8_UNORM = VkFormat.VK_FORMAT_R8G8B8_UNORM; 2320 enum VK_FORMAT_R8G8B8_SNORM = VkFormat.VK_FORMAT_R8G8B8_SNORM; 2321 enum VK_FORMAT_R8G8B8_USCALED = VkFormat.VK_FORMAT_R8G8B8_USCALED; 2322 enum VK_FORMAT_R8G8B8_SSCALED = VkFormat.VK_FORMAT_R8G8B8_SSCALED; 2323 enum VK_FORMAT_R8G8B8_UINT = VkFormat.VK_FORMAT_R8G8B8_UINT; 2324 enum VK_FORMAT_R8G8B8_SINT = VkFormat.VK_FORMAT_R8G8B8_SINT; 2325 enum VK_FORMAT_R8G8B8_SRGB = VkFormat.VK_FORMAT_R8G8B8_SRGB; 2326 enum VK_FORMAT_B8G8R8_UNORM = VkFormat.VK_FORMAT_B8G8R8_UNORM; 2327 enum VK_FORMAT_B8G8R8_SNORM = VkFormat.VK_FORMAT_B8G8R8_SNORM; 2328 enum VK_FORMAT_B8G8R8_USCALED = VkFormat.VK_FORMAT_B8G8R8_USCALED; 2329 enum VK_FORMAT_B8G8R8_SSCALED = VkFormat.VK_FORMAT_B8G8R8_SSCALED; 2330 enum VK_FORMAT_B8G8R8_UINT = VkFormat.VK_FORMAT_B8G8R8_UINT; 2331 enum VK_FORMAT_B8G8R8_SINT = VkFormat.VK_FORMAT_B8G8R8_SINT; 2332 enum VK_FORMAT_B8G8R8_SRGB = VkFormat.VK_FORMAT_B8G8R8_SRGB; 2333 enum VK_FORMAT_R8G8B8A8_UNORM = VkFormat.VK_FORMAT_R8G8B8A8_UNORM; 2334 enum VK_FORMAT_R8G8B8A8_SNORM = VkFormat.VK_FORMAT_R8G8B8A8_SNORM; 2335 enum VK_FORMAT_R8G8B8A8_USCALED = VkFormat.VK_FORMAT_R8G8B8A8_USCALED; 2336 enum VK_FORMAT_R8G8B8A8_SSCALED = VkFormat.VK_FORMAT_R8G8B8A8_SSCALED; 2337 enum VK_FORMAT_R8G8B8A8_UINT = VkFormat.VK_FORMAT_R8G8B8A8_UINT; 2338 enum VK_FORMAT_R8G8B8A8_SINT = VkFormat.VK_FORMAT_R8G8B8A8_SINT; 2339 enum VK_FORMAT_R8G8B8A8_SRGB = VkFormat.VK_FORMAT_R8G8B8A8_SRGB; 2340 enum VK_FORMAT_B8G8R8A8_UNORM = VkFormat.VK_FORMAT_B8G8R8A8_UNORM; 2341 enum VK_FORMAT_B8G8R8A8_SNORM = VkFormat.VK_FORMAT_B8G8R8A8_SNORM; 2342 enum VK_FORMAT_B8G8R8A8_USCALED = VkFormat.VK_FORMAT_B8G8R8A8_USCALED; 2343 enum VK_FORMAT_B8G8R8A8_SSCALED = VkFormat.VK_FORMAT_B8G8R8A8_SSCALED; 2344 enum VK_FORMAT_B8G8R8A8_UINT = VkFormat.VK_FORMAT_B8G8R8A8_UINT; 2345 enum VK_FORMAT_B8G8R8A8_SINT = VkFormat.VK_FORMAT_B8G8R8A8_SINT; 2346 enum VK_FORMAT_B8G8R8A8_SRGB = VkFormat.VK_FORMAT_B8G8R8A8_SRGB; 2347 enum VK_FORMAT_A8B8G8R8_UNORM_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_UNORM_PACK32; 2348 enum VK_FORMAT_A8B8G8R8_SNORM_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SNORM_PACK32; 2349 enum VK_FORMAT_A8B8G8R8_USCALED_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_USCALED_PACK32; 2350 enum VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SSCALED_PACK32; 2351 enum VK_FORMAT_A8B8G8R8_UINT_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_UINT_PACK32; 2352 enum VK_FORMAT_A8B8G8R8_SINT_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SINT_PACK32; 2353 enum VK_FORMAT_A8B8G8R8_SRGB_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SRGB_PACK32; 2354 enum VK_FORMAT_A2R10G10B10_UNORM_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_UNORM_PACK32; 2355 enum VK_FORMAT_A2R10G10B10_SNORM_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_SNORM_PACK32; 2356 enum VK_FORMAT_A2R10G10B10_USCALED_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_USCALED_PACK32; 2357 enum VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_SSCALED_PACK32; 2358 enum VK_FORMAT_A2R10G10B10_UINT_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_UINT_PACK32; 2359 enum VK_FORMAT_A2R10G10B10_SINT_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_SINT_PACK32; 2360 enum VK_FORMAT_A2B10G10R10_UNORM_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_UNORM_PACK32; 2361 enum VK_FORMAT_A2B10G10R10_SNORM_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_SNORM_PACK32; 2362 enum VK_FORMAT_A2B10G10R10_USCALED_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_USCALED_PACK32; 2363 enum VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_SSCALED_PACK32; 2364 enum VK_FORMAT_A2B10G10R10_UINT_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_UINT_PACK32; 2365 enum VK_FORMAT_A2B10G10R10_SINT_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_SINT_PACK32; 2366 enum VK_FORMAT_R16_UNORM = VkFormat.VK_FORMAT_R16_UNORM; 2367 enum VK_FORMAT_R16_SNORM = VkFormat.VK_FORMAT_R16_SNORM; 2368 enum VK_FORMAT_R16_USCALED = VkFormat.VK_FORMAT_R16_USCALED; 2369 enum VK_FORMAT_R16_SSCALED = VkFormat.VK_FORMAT_R16_SSCALED; 2370 enum VK_FORMAT_R16_UINT = VkFormat.VK_FORMAT_R16_UINT; 2371 enum VK_FORMAT_R16_SINT = VkFormat.VK_FORMAT_R16_SINT; 2372 enum VK_FORMAT_R16_SFLOAT = VkFormat.VK_FORMAT_R16_SFLOAT; 2373 enum VK_FORMAT_R16G16_UNORM = VkFormat.VK_FORMAT_R16G16_UNORM; 2374 enum VK_FORMAT_R16G16_SNORM = VkFormat.VK_FORMAT_R16G16_SNORM; 2375 enum VK_FORMAT_R16G16_USCALED = VkFormat.VK_FORMAT_R16G16_USCALED; 2376 enum VK_FORMAT_R16G16_SSCALED = VkFormat.VK_FORMAT_R16G16_SSCALED; 2377 enum VK_FORMAT_R16G16_UINT = VkFormat.VK_FORMAT_R16G16_UINT; 2378 enum VK_FORMAT_R16G16_SINT = VkFormat.VK_FORMAT_R16G16_SINT; 2379 enum VK_FORMAT_R16G16_SFLOAT = VkFormat.VK_FORMAT_R16G16_SFLOAT; 2380 enum VK_FORMAT_R16G16B16_UNORM = VkFormat.VK_FORMAT_R16G16B16_UNORM; 2381 enum VK_FORMAT_R16G16B16_SNORM = VkFormat.VK_FORMAT_R16G16B16_SNORM; 2382 enum VK_FORMAT_R16G16B16_USCALED = VkFormat.VK_FORMAT_R16G16B16_USCALED; 2383 enum VK_FORMAT_R16G16B16_SSCALED = VkFormat.VK_FORMAT_R16G16B16_SSCALED; 2384 enum VK_FORMAT_R16G16B16_UINT = VkFormat.VK_FORMAT_R16G16B16_UINT; 2385 enum VK_FORMAT_R16G16B16_SINT = VkFormat.VK_FORMAT_R16G16B16_SINT; 2386 enum VK_FORMAT_R16G16B16_SFLOAT = VkFormat.VK_FORMAT_R16G16B16_SFLOAT; 2387 enum VK_FORMAT_R16G16B16A16_UNORM = VkFormat.VK_FORMAT_R16G16B16A16_UNORM; 2388 enum VK_FORMAT_R16G16B16A16_SNORM = VkFormat.VK_FORMAT_R16G16B16A16_SNORM; 2389 enum VK_FORMAT_R16G16B16A16_USCALED = VkFormat.VK_FORMAT_R16G16B16A16_USCALED; 2390 enum VK_FORMAT_R16G16B16A16_SSCALED = VkFormat.VK_FORMAT_R16G16B16A16_SSCALED; 2391 enum VK_FORMAT_R16G16B16A16_UINT = VkFormat.VK_FORMAT_R16G16B16A16_UINT; 2392 enum VK_FORMAT_R16G16B16A16_SINT = VkFormat.VK_FORMAT_R16G16B16A16_SINT; 2393 enum VK_FORMAT_R16G16B16A16_SFLOAT = VkFormat.VK_FORMAT_R16G16B16A16_SFLOAT; 2394 enum VK_FORMAT_R32_UINT = VkFormat.VK_FORMAT_R32_UINT; 2395 enum VK_FORMAT_R32_SINT = VkFormat.VK_FORMAT_R32_SINT; 2396 enum VK_FORMAT_R32_SFLOAT = VkFormat.VK_FORMAT_R32_SFLOAT; 2397 enum VK_FORMAT_R32G32_UINT = VkFormat.VK_FORMAT_R32G32_UINT; 2398 enum VK_FORMAT_R32G32_SINT = VkFormat.VK_FORMAT_R32G32_SINT; 2399 enum VK_FORMAT_R32G32_SFLOAT = VkFormat.VK_FORMAT_R32G32_SFLOAT; 2400 enum VK_FORMAT_R32G32B32_UINT = VkFormat.VK_FORMAT_R32G32B32_UINT; 2401 enum VK_FORMAT_R32G32B32_SINT = VkFormat.VK_FORMAT_R32G32B32_SINT; 2402 enum VK_FORMAT_R32G32B32_SFLOAT = VkFormat.VK_FORMAT_R32G32B32_SFLOAT; 2403 enum VK_FORMAT_R32G32B32A32_UINT = VkFormat.VK_FORMAT_R32G32B32A32_UINT; 2404 enum VK_FORMAT_R32G32B32A32_SINT = VkFormat.VK_FORMAT_R32G32B32A32_SINT; 2405 enum VK_FORMAT_R32G32B32A32_SFLOAT = VkFormat.VK_FORMAT_R32G32B32A32_SFLOAT; 2406 enum VK_FORMAT_R64_UINT = VkFormat.VK_FORMAT_R64_UINT; 2407 enum VK_FORMAT_R64_SINT = VkFormat.VK_FORMAT_R64_SINT; 2408 enum VK_FORMAT_R64_SFLOAT = VkFormat.VK_FORMAT_R64_SFLOAT; 2409 enum VK_FORMAT_R64G64_UINT = VkFormat.VK_FORMAT_R64G64_UINT; 2410 enum VK_FORMAT_R64G64_SINT = VkFormat.VK_FORMAT_R64G64_SINT; 2411 enum VK_FORMAT_R64G64_SFLOAT = VkFormat.VK_FORMAT_R64G64_SFLOAT; 2412 enum VK_FORMAT_R64G64B64_UINT = VkFormat.VK_FORMAT_R64G64B64_UINT; 2413 enum VK_FORMAT_R64G64B64_SINT = VkFormat.VK_FORMAT_R64G64B64_SINT; 2414 enum VK_FORMAT_R64G64B64_SFLOAT = VkFormat.VK_FORMAT_R64G64B64_SFLOAT; 2415 enum VK_FORMAT_R64G64B64A64_UINT = VkFormat.VK_FORMAT_R64G64B64A64_UINT; 2416 enum VK_FORMAT_R64G64B64A64_SINT = VkFormat.VK_FORMAT_R64G64B64A64_SINT; 2417 enum VK_FORMAT_R64G64B64A64_SFLOAT = VkFormat.VK_FORMAT_R64G64B64A64_SFLOAT; 2418 enum VK_FORMAT_B10G11R11_UFLOAT_PACK32 = VkFormat.VK_FORMAT_B10G11R11_UFLOAT_PACK32; 2419 enum VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = VkFormat.VK_FORMAT_E5B9G9R9_UFLOAT_PACK32; 2420 enum VK_FORMAT_D16_UNORM = VkFormat.VK_FORMAT_D16_UNORM; 2421 enum VK_FORMAT_X8_D24_UNORM_PACK32 = VkFormat.VK_FORMAT_X8_D24_UNORM_PACK32; 2422 enum VK_FORMAT_D32_SFLOAT = VkFormat.VK_FORMAT_D32_SFLOAT; 2423 enum VK_FORMAT_S8_UINT = VkFormat.VK_FORMAT_S8_UINT; 2424 enum VK_FORMAT_D16_UNORM_S8_UINT = VkFormat.VK_FORMAT_D16_UNORM_S8_UINT; 2425 enum VK_FORMAT_D24_UNORM_S8_UINT = VkFormat.VK_FORMAT_D24_UNORM_S8_UINT; 2426 enum VK_FORMAT_D32_SFLOAT_S8_UINT = VkFormat.VK_FORMAT_D32_SFLOAT_S8_UINT; 2427 enum VK_FORMAT_BC1_RGB_UNORM_BLOCK = VkFormat.VK_FORMAT_BC1_RGB_UNORM_BLOCK; 2428 enum VK_FORMAT_BC1_RGB_SRGB_BLOCK = VkFormat.VK_FORMAT_BC1_RGB_SRGB_BLOCK; 2429 enum VK_FORMAT_BC1_RGBA_UNORM_BLOCK = VkFormat.VK_FORMAT_BC1_RGBA_UNORM_BLOCK; 2430 enum VK_FORMAT_BC1_RGBA_SRGB_BLOCK = VkFormat.VK_FORMAT_BC1_RGBA_SRGB_BLOCK; 2431 enum VK_FORMAT_BC2_UNORM_BLOCK = VkFormat.VK_FORMAT_BC2_UNORM_BLOCK; 2432 enum VK_FORMAT_BC2_SRGB_BLOCK = VkFormat.VK_FORMAT_BC2_SRGB_BLOCK; 2433 enum VK_FORMAT_BC3_UNORM_BLOCK = VkFormat.VK_FORMAT_BC3_UNORM_BLOCK; 2434 enum VK_FORMAT_BC3_SRGB_BLOCK = VkFormat.VK_FORMAT_BC3_SRGB_BLOCK; 2435 enum VK_FORMAT_BC4_UNORM_BLOCK = VkFormat.VK_FORMAT_BC4_UNORM_BLOCK; 2436 enum VK_FORMAT_BC4_SNORM_BLOCK = VkFormat.VK_FORMAT_BC4_SNORM_BLOCK; 2437 enum VK_FORMAT_BC5_UNORM_BLOCK = VkFormat.VK_FORMAT_BC5_UNORM_BLOCK; 2438 enum VK_FORMAT_BC5_SNORM_BLOCK = VkFormat.VK_FORMAT_BC5_SNORM_BLOCK; 2439 enum VK_FORMAT_BC6H_UFLOAT_BLOCK = VkFormat.VK_FORMAT_BC6H_UFLOAT_BLOCK; 2440 enum VK_FORMAT_BC6H_SFLOAT_BLOCK = VkFormat.VK_FORMAT_BC6H_SFLOAT_BLOCK; 2441 enum VK_FORMAT_BC7_UNORM_BLOCK = VkFormat.VK_FORMAT_BC7_UNORM_BLOCK; 2442 enum VK_FORMAT_BC7_SRGB_BLOCK = VkFormat.VK_FORMAT_BC7_SRGB_BLOCK; 2443 enum VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; 2444 enum VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK; 2445 enum VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK; 2446 enum VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK; 2447 enum VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; 2448 enum VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK; 2449 enum VK_FORMAT_EAC_R11_UNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11_UNORM_BLOCK; 2450 enum VK_FORMAT_EAC_R11_SNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11_SNORM_BLOCK; 2451 enum VK_FORMAT_EAC_R11G11_UNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11G11_UNORM_BLOCK; 2452 enum VK_FORMAT_EAC_R11G11_SNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11G11_SNORM_BLOCK; 2453 enum VK_FORMAT_ASTC_4x4_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_4x4_UNORM_BLOCK; 2454 enum VK_FORMAT_ASTC_4x4_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_4x4_SRGB_BLOCK; 2455 enum VK_FORMAT_ASTC_5x4_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_5x4_UNORM_BLOCK; 2456 enum VK_FORMAT_ASTC_5x4_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_5x4_SRGB_BLOCK; 2457 enum VK_FORMAT_ASTC_5x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_5x5_UNORM_BLOCK; 2458 enum VK_FORMAT_ASTC_5x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_5x5_SRGB_BLOCK; 2459 enum VK_FORMAT_ASTC_6x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_6x5_UNORM_BLOCK; 2460 enum VK_FORMAT_ASTC_6x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_6x5_SRGB_BLOCK; 2461 enum VK_FORMAT_ASTC_6x6_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_6x6_UNORM_BLOCK; 2462 enum VK_FORMAT_ASTC_6x6_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_6x6_SRGB_BLOCK; 2463 enum VK_FORMAT_ASTC_8x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_8x5_UNORM_BLOCK; 2464 enum VK_FORMAT_ASTC_8x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_8x5_SRGB_BLOCK; 2465 enum VK_FORMAT_ASTC_8x6_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_8x6_UNORM_BLOCK; 2466 enum VK_FORMAT_ASTC_8x6_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_8x6_SRGB_BLOCK; 2467 enum VK_FORMAT_ASTC_8x8_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_8x8_UNORM_BLOCK; 2468 enum VK_FORMAT_ASTC_8x8_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_8x8_SRGB_BLOCK; 2469 enum VK_FORMAT_ASTC_10x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x5_UNORM_BLOCK; 2470 enum VK_FORMAT_ASTC_10x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x5_SRGB_BLOCK; 2471 enum VK_FORMAT_ASTC_10x6_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x6_UNORM_BLOCK; 2472 enum VK_FORMAT_ASTC_10x6_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x6_SRGB_BLOCK; 2473 enum VK_FORMAT_ASTC_10x8_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x8_UNORM_BLOCK; 2474 enum VK_FORMAT_ASTC_10x8_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x8_SRGB_BLOCK; 2475 enum VK_FORMAT_ASTC_10x10_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x10_UNORM_BLOCK; 2476 enum VK_FORMAT_ASTC_10x10_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x10_SRGB_BLOCK; 2477 enum VK_FORMAT_ASTC_12x10_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_12x10_UNORM_BLOCK; 2478 enum VK_FORMAT_ASTC_12x10_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_12x10_SRGB_BLOCK; 2479 enum VK_FORMAT_ASTC_12x12_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_12x12_UNORM_BLOCK; 2480 enum VK_FORMAT_ASTC_12x12_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_12x12_SRGB_BLOCK; 2481 enum VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; 2482 enum VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; 2483 enum VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT; 2484 enum VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT; 2485 enum VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT; 2486 enum VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT; 2487 enum VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT; 2488 enum VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; 2489 enum VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT; 2490 enum VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; 2491 enum VK_FORMAT_FEATURE_BLIT_SRC_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_BLIT_SRC_BIT; 2492 enum VK_FORMAT_FEATURE_BLIT_DST_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_BLIT_DST_BIT; 2493 enum VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT; 2494 enum VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG; 2495 enum VK_IMAGE_TYPE_1D = VkImageType.VK_IMAGE_TYPE_1D; 2496 enum VK_IMAGE_TYPE_2D = VkImageType.VK_IMAGE_TYPE_2D; 2497 enum VK_IMAGE_TYPE_3D = VkImageType.VK_IMAGE_TYPE_3D; 2498 enum VK_IMAGE_TILING_OPTIMAL = VkImageTiling.VK_IMAGE_TILING_OPTIMAL; 2499 enum VK_IMAGE_TILING_LINEAR = VkImageTiling.VK_IMAGE_TILING_LINEAR; 2500 enum VK_IMAGE_USAGE_TRANSFER_SRC_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_TRANSFER_SRC_BIT; 2501 enum VK_IMAGE_USAGE_TRANSFER_DST_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_TRANSFER_DST_BIT; 2502 enum VK_IMAGE_USAGE_SAMPLED_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_SAMPLED_BIT; 2503 enum VK_IMAGE_USAGE_STORAGE_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_STORAGE_BIT; 2504 enum VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; 2505 enum VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; 2506 enum VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; 2507 enum VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; 2508 enum VK_IMAGE_CREATE_SPARSE_BINDING_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_SPARSE_BINDING_BIT; 2509 enum VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT; 2510 enum VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_SPARSE_ALIASED_BIT; 2511 enum VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; 2512 enum VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; 2513 enum VK_SAMPLE_COUNT_1_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_1_BIT; 2514 enum VK_SAMPLE_COUNT_2_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_2_BIT; 2515 enum VK_SAMPLE_COUNT_4_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_4_BIT; 2516 enum VK_SAMPLE_COUNT_8_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_8_BIT; 2517 enum VK_SAMPLE_COUNT_16_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_16_BIT; 2518 enum VK_SAMPLE_COUNT_32_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_32_BIT; 2519 enum VK_SAMPLE_COUNT_64_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_64_BIT; 2520 enum VK_PHYSICAL_DEVICE_TYPE_OTHER = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_OTHER; 2521 enum VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU; 2522 enum VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 2523 enum VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU; 2524 enum VK_PHYSICAL_DEVICE_TYPE_CPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_CPU; 2525 enum VK_QUEUE_GRAPHICS_BIT = VkQueueFlagBits.VK_QUEUE_GRAPHICS_BIT; 2526 enum VK_QUEUE_COMPUTE_BIT = VkQueueFlagBits.VK_QUEUE_COMPUTE_BIT; 2527 enum VK_QUEUE_TRANSFER_BIT = VkQueueFlagBits.VK_QUEUE_TRANSFER_BIT; 2528 enum VK_QUEUE_SPARSE_BINDING_BIT = VkQueueFlagBits.VK_QUEUE_SPARSE_BINDING_BIT; 2529 enum VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; 2530 enum VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; 2531 enum VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; 2532 enum VK_MEMORY_PROPERTY_HOST_CACHED_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_CACHED_BIT; 2533 enum VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT; 2534 enum VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = VkMemoryHeapFlagBits.VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; 2535 enum VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; 2536 enum VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT; 2537 enum VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; 2538 enum VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; 2539 enum VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT; 2540 enum VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT; 2541 enum VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT; 2542 enum VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; 2543 enum VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; 2544 enum VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; 2545 enum VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; 2546 enum VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; 2547 enum VK_PIPELINE_STAGE_TRANSFER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TRANSFER_BIT; 2548 enum VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; 2549 enum VK_PIPELINE_STAGE_HOST_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_HOST_BIT; 2550 enum VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT; 2551 enum VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; 2552 enum VK_IMAGE_ASPECT_COLOR_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_COLOR_BIT; 2553 enum VK_IMAGE_ASPECT_DEPTH_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_DEPTH_BIT; 2554 enum VK_IMAGE_ASPECT_STENCIL_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_STENCIL_BIT; 2555 enum VK_IMAGE_ASPECT_METADATA_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_METADATA_BIT; 2556 enum VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; 2557 enum VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT; 2558 enum VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT; 2559 enum VK_SPARSE_MEMORY_BIND_METADATA_BIT = VkSparseMemoryBindFlagBits.VK_SPARSE_MEMORY_BIND_METADATA_BIT; 2560 enum VK_FENCE_CREATE_SIGNALED_BIT = VkFenceCreateFlagBits.VK_FENCE_CREATE_SIGNALED_BIT; 2561 enum VK_QUERY_TYPE_OCCLUSION = VkQueryType.VK_QUERY_TYPE_OCCLUSION; 2562 enum VK_QUERY_TYPE_PIPELINE_STATISTICS = VkQueryType.VK_QUERY_TYPE_PIPELINE_STATISTICS; 2563 enum VK_QUERY_TYPE_TIMESTAMP = VkQueryType.VK_QUERY_TYPE_TIMESTAMP; 2564 enum VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT; 2565 enum VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT; 2566 enum VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT; 2567 enum VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT; 2568 enum VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT; 2569 enum VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT; 2570 enum VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT; 2571 enum VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT; 2572 enum VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT; 2573 enum VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT; 2574 enum VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT; 2575 enum VK_QUERY_RESULT_64_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_64_BIT; 2576 enum VK_QUERY_RESULT_WAIT_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_WAIT_BIT; 2577 enum VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_WITH_AVAILABILITY_BIT; 2578 enum VK_QUERY_RESULT_PARTIAL_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_PARTIAL_BIT; 2579 enum VK_BUFFER_CREATE_SPARSE_BINDING_BIT = VkBufferCreateFlagBits.VK_BUFFER_CREATE_SPARSE_BINDING_BIT; 2580 enum VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = VkBufferCreateFlagBits.VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT; 2581 enum VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = VkBufferCreateFlagBits.VK_BUFFER_CREATE_SPARSE_ALIASED_BIT; 2582 enum VK_BUFFER_USAGE_TRANSFER_SRC_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_TRANSFER_SRC_BIT; 2583 enum VK_BUFFER_USAGE_TRANSFER_DST_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_TRANSFER_DST_BIT; 2584 enum VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT; 2585 enum VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT; 2586 enum VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; 2587 enum VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; 2588 enum VK_BUFFER_USAGE_INDEX_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_INDEX_BUFFER_BIT; 2589 enum VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; 2590 enum VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; 2591 enum VK_SHARING_MODE_EXCLUSIVE = VkSharingMode.VK_SHARING_MODE_EXCLUSIVE; 2592 enum VK_SHARING_MODE_CONCURRENT = VkSharingMode.VK_SHARING_MODE_CONCURRENT; 2593 enum VK_IMAGE_LAYOUT_UNDEFINED = VkImageLayout.VK_IMAGE_LAYOUT_UNDEFINED; 2594 enum VK_IMAGE_LAYOUT_GENERAL = VkImageLayout.VK_IMAGE_LAYOUT_GENERAL; 2595 enum VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; 2596 enum VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; 2597 enum VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; 2598 enum VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; 2599 enum VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; 2600 enum VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; 2601 enum VK_IMAGE_LAYOUT_PREINITIALIZED = VkImageLayout.VK_IMAGE_LAYOUT_PREINITIALIZED; 2602 enum VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = VkImageLayout.VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; 2603 enum VK_IMAGE_VIEW_TYPE_1D = VkImageViewType.VK_IMAGE_VIEW_TYPE_1D; 2604 enum VK_IMAGE_VIEW_TYPE_2D = VkImageViewType.VK_IMAGE_VIEW_TYPE_2D; 2605 enum VK_IMAGE_VIEW_TYPE_3D = VkImageViewType.VK_IMAGE_VIEW_TYPE_3D; 2606 enum VK_IMAGE_VIEW_TYPE_CUBE = VkImageViewType.VK_IMAGE_VIEW_TYPE_CUBE; 2607 enum VK_IMAGE_VIEW_TYPE_1D_ARRAY = VkImageViewType.VK_IMAGE_VIEW_TYPE_1D_ARRAY; 2608 enum VK_IMAGE_VIEW_TYPE_2D_ARRAY = VkImageViewType.VK_IMAGE_VIEW_TYPE_2D_ARRAY; 2609 enum VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = VkImageViewType.VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; 2610 enum VK_COMPONENT_SWIZZLE_IDENTITY = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_IDENTITY; 2611 enum VK_COMPONENT_SWIZZLE_ZERO = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_ZERO; 2612 enum VK_COMPONENT_SWIZZLE_ONE = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_ONE; 2613 enum VK_COMPONENT_SWIZZLE_R = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_R; 2614 enum VK_COMPONENT_SWIZZLE_G = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_G; 2615 enum VK_COMPONENT_SWIZZLE_B = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_B; 2616 enum VK_COMPONENT_SWIZZLE_A = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_A; 2617 enum VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT; 2618 enum VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT; 2619 enum VK_PIPELINE_CREATE_DERIVATIVE_BIT = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_DERIVATIVE_BIT; 2620 enum VK_SHADER_STAGE_VERTEX_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_VERTEX_BIT; 2621 enum VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; 2622 enum VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; 2623 enum VK_SHADER_STAGE_GEOMETRY_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_GEOMETRY_BIT; 2624 enum VK_SHADER_STAGE_FRAGMENT_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_FRAGMENT_BIT; 2625 enum VK_SHADER_STAGE_COMPUTE_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_COMPUTE_BIT; 2626 enum VK_SHADER_STAGE_ALL_GRAPHICS = VkShaderStageFlagBits.VK_SHADER_STAGE_ALL_GRAPHICS; 2627 enum VK_SHADER_STAGE_ALL = VkShaderStageFlagBits.VK_SHADER_STAGE_ALL; 2628 enum VK_VERTEX_INPUT_RATE_VERTEX = VkVertexInputRate.VK_VERTEX_INPUT_RATE_VERTEX; 2629 enum VK_VERTEX_INPUT_RATE_INSTANCE = VkVertexInputRate.VK_VERTEX_INPUT_RATE_INSTANCE; 2630 enum VK_PRIMITIVE_TOPOLOGY_POINT_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_POINT_LIST; 2631 enum VK_PRIMITIVE_TOPOLOGY_LINE_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_LIST; 2632 enum VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_STRIP; 2633 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; 2634 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; 2635 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN; 2636 enum VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY; 2637 enum VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY; 2638 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY; 2639 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY; 2640 enum VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; 2641 enum VK_POLYGON_MODE_FILL = VkPolygonMode.VK_POLYGON_MODE_FILL; 2642 enum VK_POLYGON_MODE_LINE = VkPolygonMode.VK_POLYGON_MODE_LINE; 2643 enum VK_POLYGON_MODE_POINT = VkPolygonMode.VK_POLYGON_MODE_POINT; 2644 enum VK_CULL_MODE_NONE = VkCullModeFlagBits.VK_CULL_MODE_NONE; 2645 enum VK_CULL_MODE_FRONT_BIT = VkCullModeFlagBits.VK_CULL_MODE_FRONT_BIT; 2646 enum VK_CULL_MODE_BACK_BIT = VkCullModeFlagBits.VK_CULL_MODE_BACK_BIT; 2647 enum VK_CULL_MODE_FRONT_AND_BACK = VkCullModeFlagBits.VK_CULL_MODE_FRONT_AND_BACK; 2648 enum VK_FRONT_FACE_COUNTER_CLOCKWISE = VkFrontFace.VK_FRONT_FACE_COUNTER_CLOCKWISE; 2649 enum VK_FRONT_FACE_CLOCKWISE = VkFrontFace.VK_FRONT_FACE_CLOCKWISE; 2650 enum VK_COMPARE_OP_NEVER = VkCompareOp.VK_COMPARE_OP_NEVER; 2651 enum VK_COMPARE_OP_LESS = VkCompareOp.VK_COMPARE_OP_LESS; 2652 enum VK_COMPARE_OP_EQUAL = VkCompareOp.VK_COMPARE_OP_EQUAL; 2653 enum VK_COMPARE_OP_LESS_OR_EQUAL = VkCompareOp.VK_COMPARE_OP_LESS_OR_EQUAL; 2654 enum VK_COMPARE_OP_GREATER = VkCompareOp.VK_COMPARE_OP_GREATER; 2655 enum VK_COMPARE_OP_NOT_EQUAL = VkCompareOp.VK_COMPARE_OP_NOT_EQUAL; 2656 enum VK_COMPARE_OP_GREATER_OR_EQUAL = VkCompareOp.VK_COMPARE_OP_GREATER_OR_EQUAL; 2657 enum VK_COMPARE_OP_ALWAYS = VkCompareOp.VK_COMPARE_OP_ALWAYS; 2658 enum VK_STENCIL_OP_KEEP = VkStencilOp.VK_STENCIL_OP_KEEP; 2659 enum VK_STENCIL_OP_ZERO = VkStencilOp.VK_STENCIL_OP_ZERO; 2660 enum VK_STENCIL_OP_REPLACE = VkStencilOp.VK_STENCIL_OP_REPLACE; 2661 enum VK_STENCIL_OP_INCREMENT_AND_CLAMP = VkStencilOp.VK_STENCIL_OP_INCREMENT_AND_CLAMP; 2662 enum VK_STENCIL_OP_DECREMENT_AND_CLAMP = VkStencilOp.VK_STENCIL_OP_DECREMENT_AND_CLAMP; 2663 enum VK_STENCIL_OP_INVERT = VkStencilOp.VK_STENCIL_OP_INVERT; 2664 enum VK_STENCIL_OP_INCREMENT_AND_WRAP = VkStencilOp.VK_STENCIL_OP_INCREMENT_AND_WRAP; 2665 enum VK_STENCIL_OP_DECREMENT_AND_WRAP = VkStencilOp.VK_STENCIL_OP_DECREMENT_AND_WRAP; 2666 enum VK_LOGIC_OP_CLEAR = VkLogicOp.VK_LOGIC_OP_CLEAR; 2667 enum VK_LOGIC_OP_AND = VkLogicOp.VK_LOGIC_OP_AND; 2668 enum VK_LOGIC_OP_AND_REVERSE = VkLogicOp.VK_LOGIC_OP_AND_REVERSE; 2669 enum VK_LOGIC_OP_COPY = VkLogicOp.VK_LOGIC_OP_COPY; 2670 enum VK_LOGIC_OP_AND_INVERTED = VkLogicOp.VK_LOGIC_OP_AND_INVERTED; 2671 enum VK_LOGIC_OP_NO_OP = VkLogicOp.VK_LOGIC_OP_NO_OP; 2672 enum VK_LOGIC_OP_XOR = VkLogicOp.VK_LOGIC_OP_XOR; 2673 enum VK_LOGIC_OP_OR = VkLogicOp.VK_LOGIC_OP_OR; 2674 enum VK_LOGIC_OP_NOR = VkLogicOp.VK_LOGIC_OP_NOR; 2675 enum VK_LOGIC_OP_EQUIVALENT = VkLogicOp.VK_LOGIC_OP_EQUIVALENT; 2676 enum VK_LOGIC_OP_INVERT = VkLogicOp.VK_LOGIC_OP_INVERT; 2677 enum VK_LOGIC_OP_OR_REVERSE = VkLogicOp.VK_LOGIC_OP_OR_REVERSE; 2678 enum VK_LOGIC_OP_COPY_INVERTED = VkLogicOp.VK_LOGIC_OP_COPY_INVERTED; 2679 enum VK_LOGIC_OP_OR_INVERTED = VkLogicOp.VK_LOGIC_OP_OR_INVERTED; 2680 enum VK_LOGIC_OP_NAND = VkLogicOp.VK_LOGIC_OP_NAND; 2681 enum VK_LOGIC_OP_SET = VkLogicOp.VK_LOGIC_OP_SET; 2682 enum VK_BLEND_FACTOR_ZERO = VkBlendFactor.VK_BLEND_FACTOR_ZERO; 2683 enum VK_BLEND_FACTOR_ONE = VkBlendFactor.VK_BLEND_FACTOR_ONE; 2684 enum VK_BLEND_FACTOR_SRC_COLOR = VkBlendFactor.VK_BLEND_FACTOR_SRC_COLOR; 2685 enum VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR; 2686 enum VK_BLEND_FACTOR_DST_COLOR = VkBlendFactor.VK_BLEND_FACTOR_DST_COLOR; 2687 enum VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR; 2688 enum VK_BLEND_FACTOR_SRC_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_SRC_ALPHA; 2689 enum VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; 2690 enum VK_BLEND_FACTOR_DST_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_DST_ALPHA; 2691 enum VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA; 2692 enum VK_BLEND_FACTOR_CONSTANT_COLOR = VkBlendFactor.VK_BLEND_FACTOR_CONSTANT_COLOR; 2693 enum VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR; 2694 enum VK_BLEND_FACTOR_CONSTANT_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_CONSTANT_ALPHA; 2695 enum VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA; 2696 enum VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = VkBlendFactor.VK_BLEND_FACTOR_SRC_ALPHA_SATURATE; 2697 enum VK_BLEND_FACTOR_SRC1_COLOR = VkBlendFactor.VK_BLEND_FACTOR_SRC1_COLOR; 2698 enum VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR; 2699 enum VK_BLEND_FACTOR_SRC1_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_SRC1_ALPHA; 2700 enum VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA; 2701 enum VK_BLEND_OP_ADD = VkBlendOp.VK_BLEND_OP_ADD; 2702 enum VK_BLEND_OP_SUBTRACT = VkBlendOp.VK_BLEND_OP_SUBTRACT; 2703 enum VK_BLEND_OP_REVERSE_SUBTRACT = VkBlendOp.VK_BLEND_OP_REVERSE_SUBTRACT; 2704 enum VK_BLEND_OP_MIN = VkBlendOp.VK_BLEND_OP_MIN; 2705 enum VK_BLEND_OP_MAX = VkBlendOp.VK_BLEND_OP_MAX; 2706 enum VK_COLOR_COMPONENT_R_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_R_BIT; 2707 enum VK_COLOR_COMPONENT_G_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_G_BIT; 2708 enum VK_COLOR_COMPONENT_B_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_B_BIT; 2709 enum VK_COLOR_COMPONENT_A_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_A_BIT; 2710 enum VK_DYNAMIC_STATE_VIEWPORT = VkDynamicState.VK_DYNAMIC_STATE_VIEWPORT; 2711 enum VK_DYNAMIC_STATE_SCISSOR = VkDynamicState.VK_DYNAMIC_STATE_SCISSOR; 2712 enum VK_DYNAMIC_STATE_LINE_WIDTH = VkDynamicState.VK_DYNAMIC_STATE_LINE_WIDTH; 2713 enum VK_DYNAMIC_STATE_DEPTH_BIAS = VkDynamicState.VK_DYNAMIC_STATE_DEPTH_BIAS; 2714 enum VK_DYNAMIC_STATE_BLEND_CONSTANTS = VkDynamicState.VK_DYNAMIC_STATE_BLEND_CONSTANTS; 2715 enum VK_DYNAMIC_STATE_DEPTH_BOUNDS = VkDynamicState.VK_DYNAMIC_STATE_DEPTH_BOUNDS; 2716 enum VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = VkDynamicState.VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK; 2717 enum VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = VkDynamicState.VK_DYNAMIC_STATE_STENCIL_WRITE_MASK; 2718 enum VK_DYNAMIC_STATE_STENCIL_REFERENCE = VkDynamicState.VK_DYNAMIC_STATE_STENCIL_REFERENCE; 2719 enum VK_FILTER_NEAREST = VkFilter.VK_FILTER_NEAREST; 2720 enum VK_FILTER_LINEAR = VkFilter.VK_FILTER_LINEAR; 2721 enum VK_FILTER_CUBIC_IMG = VkFilter.VK_FILTER_CUBIC_IMG; 2722 enum VK_SAMPLER_MIPMAP_MODE_NEAREST = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_NEAREST; 2723 enum VK_SAMPLER_MIPMAP_MODE_LINEAR = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_LINEAR; 2724 enum VK_SAMPLER_ADDRESS_MODE_REPEAT = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_REPEAT; 2725 enum VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; 2726 enum VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; 2727 enum VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; 2728 enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; 2729 enum VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = VkBorderColor.VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK; 2730 enum VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = VkBorderColor.VK_BORDER_COLOR_INT_TRANSPARENT_BLACK; 2731 enum VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = VkBorderColor.VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK; 2732 enum VK_BORDER_COLOR_INT_OPAQUE_BLACK = VkBorderColor.VK_BORDER_COLOR_INT_OPAQUE_BLACK; 2733 enum VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = VkBorderColor.VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; 2734 enum VK_BORDER_COLOR_INT_OPAQUE_WHITE = VkBorderColor.VK_BORDER_COLOR_INT_OPAQUE_WHITE; 2735 enum VK_DESCRIPTOR_TYPE_SAMPLER = VkDescriptorType.VK_DESCRIPTOR_TYPE_SAMPLER; 2736 enum VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = VkDescriptorType.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; 2737 enum VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = VkDescriptorType.VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE; 2738 enum VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; 2739 enum VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; 2740 enum VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; 2741 enum VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; 2742 enum VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; 2743 enum VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; 2744 enum VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; 2745 enum VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = VkDescriptorType.VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; 2746 enum VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = VkDescriptorPoolCreateFlagBits.VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; 2747 enum VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = VkAttachmentDescriptionFlagBits.VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT; 2748 enum VK_ATTACHMENT_LOAD_OP_LOAD = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_LOAD; 2749 enum VK_ATTACHMENT_LOAD_OP_CLEAR = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_CLEAR; 2750 enum VK_ATTACHMENT_LOAD_OP_DONT_CARE = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_DONT_CARE; 2751 enum VK_ATTACHMENT_STORE_OP_STORE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_STORE; 2752 enum VK_ATTACHMENT_STORE_OP_DONT_CARE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_DONT_CARE; 2753 enum VK_PIPELINE_BIND_POINT_GRAPHICS = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_GRAPHICS; 2754 enum VK_PIPELINE_BIND_POINT_COMPUTE = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_COMPUTE; 2755 enum VK_ACCESS_INDIRECT_COMMAND_READ_BIT = VkAccessFlagBits.VK_ACCESS_INDIRECT_COMMAND_READ_BIT; 2756 enum VK_ACCESS_INDEX_READ_BIT = VkAccessFlagBits.VK_ACCESS_INDEX_READ_BIT; 2757 enum VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = VkAccessFlagBits.VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT; 2758 enum VK_ACCESS_UNIFORM_READ_BIT = VkAccessFlagBits.VK_ACCESS_UNIFORM_READ_BIT; 2759 enum VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = VkAccessFlagBits.VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; 2760 enum VK_ACCESS_SHADER_READ_BIT = VkAccessFlagBits.VK_ACCESS_SHADER_READ_BIT; 2761 enum VK_ACCESS_SHADER_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_SHADER_WRITE_BIT; 2762 enum VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = VkAccessFlagBits.VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; 2763 enum VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; 2764 enum VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = VkAccessFlagBits.VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; 2765 enum VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; 2766 enum VK_ACCESS_TRANSFER_READ_BIT = VkAccessFlagBits.VK_ACCESS_TRANSFER_READ_BIT; 2767 enum VK_ACCESS_TRANSFER_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_TRANSFER_WRITE_BIT; 2768 enum VK_ACCESS_HOST_READ_BIT = VkAccessFlagBits.VK_ACCESS_HOST_READ_BIT; 2769 enum VK_ACCESS_HOST_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_HOST_WRITE_BIT; 2770 enum VK_ACCESS_MEMORY_READ_BIT = VkAccessFlagBits.VK_ACCESS_MEMORY_READ_BIT; 2771 enum VK_ACCESS_MEMORY_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_MEMORY_WRITE_BIT; 2772 enum VK_DEPENDENCY_BY_REGION_BIT = VkDependencyFlagBits.VK_DEPENDENCY_BY_REGION_BIT; 2773 enum VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = VkCommandPoolCreateFlagBits.VK_COMMAND_POOL_CREATE_TRANSIENT_BIT; 2774 enum VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = VkCommandPoolCreateFlagBits.VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; 2775 enum VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = VkCommandPoolResetFlagBits.VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT; 2776 enum VK_COMMAND_BUFFER_LEVEL_PRIMARY = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_PRIMARY; 2777 enum VK_COMMAND_BUFFER_LEVEL_SECONDARY = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_SECONDARY; 2778 enum VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; 2779 enum VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT; 2780 enum VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; 2781 enum VK_QUERY_CONTROL_PRECISE_BIT = VkQueryControlFlagBits.VK_QUERY_CONTROL_PRECISE_BIT; 2782 enum VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = VkCommandBufferResetFlagBits.VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT; 2783 enum VK_STENCIL_FACE_FRONT_BIT = VkStencilFaceFlagBits.VK_STENCIL_FACE_FRONT_BIT; 2784 enum VK_STENCIL_FACE_BACK_BIT = VkStencilFaceFlagBits.VK_STENCIL_FACE_BACK_BIT; 2785 enum VK_STENCIL_FRONT_AND_BACK = VkStencilFaceFlagBits.VK_STENCIL_FRONT_AND_BACK; 2786 enum VK_INDEX_TYPE_UINT16 = VkIndexType.VK_INDEX_TYPE_UINT16; 2787 enum VK_INDEX_TYPE_UINT32 = VkIndexType.VK_INDEX_TYPE_UINT32; 2788 enum VK_SUBPASS_CONTENTS_INLINE = VkSubpassContents.VK_SUBPASS_CONTENTS_INLINE; 2789 enum VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = VkSubpassContents.VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS; 2790 } 2791 version(DVulkan_VK_KHR_surface) { 2792 enum VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; 2793 enum VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR; 2794 enum VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR; 2795 enum VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR; 2796 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR; 2797 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR; 2798 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR; 2799 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR; 2800 enum VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR; 2801 enum VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; 2802 enum VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR; 2803 enum VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR; 2804 enum VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; 2805 enum VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; 2806 enum VK_COLORSPACE_SRGB_NONLINEAR_KHR = VkColorSpaceKHR.VK_COLORSPACE_SRGB_NONLINEAR_KHR; 2807 enum VK_PRESENT_MODE_IMMEDIATE_KHR = VkPresentModeKHR.VK_PRESENT_MODE_IMMEDIATE_KHR; 2808 enum VK_PRESENT_MODE_MAILBOX_KHR = VkPresentModeKHR.VK_PRESENT_MODE_MAILBOX_KHR; 2809 enum VK_PRESENT_MODE_FIFO_KHR = VkPresentModeKHR.VK_PRESENT_MODE_FIFO_KHR; 2810 enum VK_PRESENT_MODE_FIFO_RELAXED_KHR = VkPresentModeKHR.VK_PRESENT_MODE_FIFO_RELAXED_KHR; 2811 } 2812 version(DVulkan_VK_KHR_swapchain) { 2813 } 2814 version(DVulkan_VK_KHR_display) { 2815 enum VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR; 2816 enum VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR; 2817 enum VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR; 2818 enum VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR; 2819 } 2820 version(DVulkan_VK_KHR_display_swapchain) { 2821 } 2822 version(DVulkan_VK_KHR_sampler_mirror_clamp_to_edge) { 2823 } 2824 version(DVulkan_VK_ANDROID_native_buffer) { 2825 } 2826 version(DVulkan_VK_EXT_debug_report) { 2827 enum VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT; 2828 enum VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT; 2829 enum VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT; 2830 enum VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT; 2831 enum VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT; 2832 enum VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT; 2833 enum VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT; 2834 enum VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT; 2835 enum VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT; 2836 enum VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT; 2837 enum VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT; 2838 enum VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT; 2839 enum VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT; 2840 enum VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT; 2841 enum VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT; 2842 enum VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT; 2843 enum VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT; 2844 enum VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT; 2845 enum VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT; 2846 enum VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT; 2847 enum VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT; 2848 enum VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT; 2849 enum VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT; 2850 enum VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT; 2851 enum VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT; 2852 enum VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT; 2853 enum VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT; 2854 enum VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT; 2855 enum VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT; 2856 enum VK_DEBUG_REPORT_ERROR_NONE_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_NONE_EXT; 2857 enum VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT; 2858 enum VK_DEBUG_REPORT_INFORMATION_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_INFORMATION_BIT_EXT; 2859 enum VK_DEBUG_REPORT_WARNING_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_WARNING_BIT_EXT; 2860 enum VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT; 2861 enum VK_DEBUG_REPORT_ERROR_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_ERROR_BIT_EXT; 2862 enum VK_DEBUG_REPORT_DEBUG_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_DEBUG_BIT_EXT; 2863 } 2864 version(DVulkan_VK_NV_glsl_shader) { 2865 } 2866 version(DVulkan_VK_NV_extension_1) { 2867 } 2868 version(DVulkan_VK_IMG_filter_cubic) { 2869 } 2870 version(DVulkan_VK_AMD_extension_1) { 2871 } 2872 version(DVulkan_VK_AMD_extension_2) { 2873 } 2874 version(DVulkan_VK_AMD_rasterization_order) { 2875 enum VK_RASTERIZATION_ORDER_STRICT_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_STRICT_AMD; 2876 enum VK_RASTERIZATION_ORDER_RELAXED_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_RELAXED_AMD; 2877 } 2878 version(DVulkan_VK_AMD_extension_4) { 2879 } 2880 version(DVulkan_VK_AMD_extension_5) { 2881 } 2882 version(DVulkan_VK_AMD_extension_6) { 2883 } 2884 version(DVulkan_VK_EXT_debug_marker) { 2885 } 2886 }