HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
vulkan_core.h
Go to the documentation of this file.
1 #ifndef VULKAN_CORE_H_
2 #define VULKAN_CORE_H_ 1
3 
4 /*
5 ** Copyright 2015-2022 The Khronos Group Inc.
6 **
7 ** SPDX-License-Identifier: Apache-2.0
8 */
9 
10 /*
11 ** This header is generated from the Khronos Vulkan XML API Registry.
12 **
13 */
14 
15 
16 #ifdef __cplusplus
17 extern "C" {
18 #endif
19 
20 
21 
22 #define VK_VERSION_1_0 1
23 #include "vk_platform.h"
24 
25 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
26 
27 
28 #ifndef VK_USE_64_BIT_PTR_DEFINES
29  #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
30  #define VK_USE_64_BIT_PTR_DEFINES 1
31  #else
32  #define VK_USE_64_BIT_PTR_DEFINES 0
33  #endif
34 #endif
35 
36 
37 #ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
38  #if (VK_USE_64_BIT_PTR_DEFINES==1)
39  #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L))
40  #define VK_NULL_HANDLE nullptr
41  #else
42  #define VK_NULL_HANDLE ((void*)0)
43  #endif
44  #else
45  #define VK_NULL_HANDLE 0ULL
46  #endif
47 #endif
48 #ifndef VK_NULL_HANDLE
49  #define VK_NULL_HANDLE 0
50 #endif
51 
52 
53 #ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE
54  #if (VK_USE_64_BIT_PTR_DEFINES==1)
55  #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
56  #else
57  #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
58  #endif
59 #endif
60 
61 // DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead.
62 #define VK_MAKE_VERSION(major, minor, patch) \
63  ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
64 
65 // DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.
66 //#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
67 
68 #define VK_MAKE_API_VERSION(variant, major, minor, patch) \
69  ((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))
70 
71 // Vulkan 1.0 version number
72 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
73 
74 // Version of this file
75 #define VK_HEADER_VERSION 236
76 
77 // Complete version of this file
78 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
79 
80 // DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead.
81 #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
82 
83 // DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead.
84 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
85 
86 // DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead.
87 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)
88 
89 #define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29)
90 #define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU)
91 #define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)
92 #define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)
93 typedef uint32_t VkBool32;
94 typedef uint64_t VkDeviceAddress;
95 typedef uint64_t VkDeviceSize;
96 typedef uint32_t VkFlags;
97 typedef uint32_t VkSampleMask;
100 VK_DEFINE_HANDLE(VkInstance)
101 VK_DEFINE_HANDLE(VkPhysicalDevice)
102 VK_DEFINE_HANDLE(VkDevice)
103 VK_DEFINE_HANDLE(VkQueue)
105 VK_DEFINE_HANDLE(VkCommandBuffer)
107 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
112 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
113 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
114 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
117 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
119 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
120 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
123 #define VK_ATTACHMENT_UNUSED (~0U)
124 #define VK_FALSE 0U
125 #define VK_LOD_CLAMP_NONE 1000.0F
126 #define VK_QUEUE_FAMILY_IGNORED (~0U)
127 #define VK_REMAINING_ARRAY_LAYERS (~0U)
128 #define VK_REMAINING_MIP_LEVELS (~0U)
129 #define VK_SUBPASS_EXTERNAL (~0U)
130 #define VK_TRUE 1U
131 #define VK_WHOLE_SIZE (~0ULL)
132 #define VK_MAX_MEMORY_TYPES 32U
133 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256U
134 #define VK_UUID_SIZE 16U
135 #define VK_MAX_EXTENSION_NAME_SIZE 256U
136 #define VK_MAX_DESCRIPTION_SIZE 256U
137 #define VK_MAX_MEMORY_HEAPS 16U
138 
139 typedef enum VkResult {
161  VK_ERROR_FRAGMENTATION = -1000161000,
166  VK_SUBOPTIMAL_KHR = 1000001003,
171 #ifdef VK_ENABLE_BETA_EXTENSIONS
172  VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000,
173 #endif
174 #ifdef VK_ENABLE_BETA_EXTENSIONS
175  VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001,
176 #endif
177 #ifdef VK_ENABLE_BETA_EXTENSIONS
178  VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002,
179 #endif
180 #ifdef VK_ENABLE_BETA_EXTENSIONS
181  VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003,
182 #endif
183 #ifdef VK_ENABLE_BETA_EXTENSIONS
184  VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004,
185 #endif
186 #ifdef VK_ENABLE_BETA_EXTENSIONS
187  VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005,
188 #endif
192  VK_THREAD_IDLE_KHR = 1000268000,
193  VK_THREAD_DONE_KHR = 1000268001,
205  VK_RESULT_MAX_ENUM = 0x7FFFFFFF
206 } VkResult;
207 
208 typedef enum VkStructureType {
446 #ifdef VK_ENABLE_BETA_EXTENSIONS
447  VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000,
448 #endif
449 #ifdef VK_ENABLE_BETA_EXTENSIONS
450  VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001,
451 #endif
452 #ifdef VK_ENABLE_BETA_EXTENSIONS
453  VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002,
454 #endif
455 #ifdef VK_ENABLE_BETA_EXTENSIONS
456  VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003,
457 #endif
458 #ifdef VK_ENABLE_BETA_EXTENSIONS
459  VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004,
460 #endif
461 #ifdef VK_ENABLE_BETA_EXTENSIONS
462  VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005,
463 #endif
464 #ifdef VK_ENABLE_BETA_EXTENSIONS
465  VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006,
466 #endif
467 #ifdef VK_ENABLE_BETA_EXTENSIONS
468  VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007,
469 #endif
470 #ifdef VK_ENABLE_BETA_EXTENSIONS
471  VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008,
472 #endif
473 #ifdef VK_ENABLE_BETA_EXTENSIONS
474  VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009,
475 #endif
476 #ifdef VK_ENABLE_BETA_EXTENSIONS
477  VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010,
478 #endif
479 #ifdef VK_ENABLE_BETA_EXTENSIONS
480  VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011,
481 #endif
482 #ifdef VK_ENABLE_BETA_EXTENSIONS
483  VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012,
484 #endif
485 #ifdef VK_ENABLE_BETA_EXTENSIONS
486  VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013,
487 #endif
488 #ifdef VK_ENABLE_BETA_EXTENSIONS
489  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014,
490 #endif
491 #ifdef VK_ENABLE_BETA_EXTENSIONS
492  VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015,
493 #endif
494 #ifdef VK_ENABLE_BETA_EXTENSIONS
495  VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016,
496 #endif
497 #ifdef VK_ENABLE_BETA_EXTENSIONS
498  VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000,
499 #endif
500 #ifdef VK_ENABLE_BETA_EXTENSIONS
501  VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001,
502 #endif
503 #ifdef VK_ENABLE_BETA_EXTENSIONS
504  VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002,
505 #endif
517 #ifdef VK_ENABLE_BETA_EXTENSIONS
518  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000,
519 #endif
520 #ifdef VK_ENABLE_BETA_EXTENSIONS
521  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038001,
522 #endif
523 #ifdef VK_ENABLE_BETA_EXTENSIONS
524  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002,
525 #endif
526 #ifdef VK_ENABLE_BETA_EXTENSIONS
527  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038003,
528 #endif
529 #ifdef VK_ENABLE_BETA_EXTENSIONS
530  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004,
531 #endif
532 #ifdef VK_ENABLE_BETA_EXTENSIONS
533  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT = 1000038005,
534 #endif
535 #ifdef VK_ENABLE_BETA_EXTENSIONS
536  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT = 1000038006,
537 #endif
538 #ifdef VK_ENABLE_BETA_EXTENSIONS
539  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT = 1000038007,
540 #endif
541 #ifdef VK_ENABLE_BETA_EXTENSIONS
542  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008,
543 #endif
544 #ifdef VK_ENABLE_BETA_EXTENSIONS
545  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009,
546 #endif
547 #ifdef VK_ENABLE_BETA_EXTENSIONS
548  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT = 1000038010,
549 #endif
550 #ifdef VK_ENABLE_BETA_EXTENSIONS
551  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000,
552 #endif
553 #ifdef VK_ENABLE_BETA_EXTENSIONS
554  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039001,
555 #endif
556 #ifdef VK_ENABLE_BETA_EXTENSIONS
557  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002,
558 #endif
559 #ifdef VK_ENABLE_BETA_EXTENSIONS
560  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT = 1000039003,
561 #endif
562 #ifdef VK_ENABLE_BETA_EXTENSIONS
563  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004,
564 #endif
565 #ifdef VK_ENABLE_BETA_EXTENSIONS
566  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT = 1000039005,
567 #endif
568 #ifdef VK_ENABLE_BETA_EXTENSIONS
569  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT = 1000039006,
570 #endif
571 #ifdef VK_ENABLE_BETA_EXTENSIONS
572  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT = 1000039007,
573 #endif
574 #ifdef VK_ENABLE_BETA_EXTENSIONS
575  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT = 1000039008,
576 #endif
577 #ifdef VK_ENABLE_BETA_EXTENSIONS
578  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009,
579 #endif
580 #ifdef VK_ENABLE_BETA_EXTENSIONS
581  VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010,
582 #endif
583 #ifdef VK_ENABLE_BETA_EXTENSIONS
584  VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT = 1000040000,
585 #endif
586 #ifdef VK_ENABLE_BETA_EXTENSIONS
587  VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT = 1000040001,
588 #endif
589 #ifdef VK_ENABLE_BETA_EXTENSIONS
590  VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_EXT = 1000040003,
591 #endif
592 #ifdef VK_ENABLE_BETA_EXTENSIONS
593  VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000040004,
594 #endif
595 #ifdef VK_ENABLE_BETA_EXTENSIONS
596  VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000040005,
597 #endif
598 #ifdef VK_ENABLE_BETA_EXTENSIONS
599  VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT = 1000040006,
600 #endif
731 #ifdef VK_ENABLE_BETA_EXTENSIONS
732  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000,
733 #endif
734 #ifdef VK_ENABLE_BETA_EXTENSIONS
735  VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001,
736 #endif
763 #ifdef VK_ENABLE_BETA_EXTENSIONS
764  VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT = 1000187000,
765 #endif
766 #ifdef VK_ENABLE_BETA_EXTENSIONS
767  VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000187001,
768 #endif
769 #ifdef VK_ENABLE_BETA_EXTENSIONS
770  VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000187002,
771 #endif
772 #ifdef VK_ENABLE_BETA_EXTENSIONS
773  VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_EXT = 1000187003,
774 #endif
775 #ifdef VK_ENABLE_BETA_EXTENSIONS
776  VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT = 1000187004,
777 #endif
778 #ifdef VK_ENABLE_BETA_EXTENSIONS
779  VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT = 1000187005,
780 #endif
884 #ifdef VK_ENABLE_BETA_EXTENSIONS
885  VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000,
886 #endif
887 #ifdef VK_ENABLE_BETA_EXTENSIONS
888  VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001,
889 #endif
890 #ifdef VK_ENABLE_BETA_EXTENSIONS
891  VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002,
892 #endif
893 #ifdef VK_ENABLE_BETA_EXTENSIONS
894  VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003,
895 #endif
896 #ifdef VK_ENABLE_BETA_EXTENSIONS
897  VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004,
898 #endif
1243 } VkStructureType;
1244 
1249 
1250 typedef enum VkImageLayout {
1269 #ifdef VK_ENABLE_BETA_EXTENSIONS
1270  VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000,
1271 #endif
1272 #ifdef VK_ENABLE_BETA_EXTENSIONS
1273  VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001,
1274 #endif
1275 #ifdef VK_ENABLE_BETA_EXTENSIONS
1276  VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002,
1277 #endif
1281 #ifdef VK_ENABLE_BETA_EXTENSIONS
1282  VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000,
1283 #endif
1284 #ifdef VK_ENABLE_BETA_EXTENSIONS
1285  VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001,
1286 #endif
1287 #ifdef VK_ENABLE_BETA_EXTENSIONS
1288  VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002,
1289 #endif
1301 } VkImageLayout;
1302 
1303 typedef enum VkObjectType {
1338 #ifdef VK_ENABLE_BETA_EXTENSIONS
1339  VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000,
1340 #endif
1341 #ifdef VK_ENABLE_BETA_EXTENSIONS
1342  VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001,
1343 #endif
1360 } VkObjectType;
1361 
1362 typedef enum VkVendorId {
1363  VK_VENDOR_ID_VIV = 0x10001,
1364  VK_VENDOR_ID_VSI = 0x10002,
1370 } VkVendorId;
1371 
1380 
1385 
1386 typedef enum VkFormat {
1689  VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
1690 } VkFormat;
1691 
1692 typedef enum VkImageTiling {
1697 } VkImageTiling;
1698 
1699 typedef enum VkImageType {
1704 } VkImageType;
1705 
1706 typedef enum VkPhysicalDeviceType {
1714 
1715 typedef enum VkQueryType {
1719 #ifdef VK_ENABLE_BETA_EXTENSIONS
1720  VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000,
1721 #endif
1728 #ifdef VK_ENABLE_BETA_EXTENSIONS
1729  VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR = 1000299000,
1730 #endif
1738 } VkQueryType;
1739 
1740 typedef enum VkSharingMode {
1744 } VkSharingMode;
1745 
1746 typedef enum VkComponentSwizzle {
1756 
1757 typedef enum VkImageViewType {
1766 } VkImageViewType;
1767 
1768 typedef enum VkBlendFactor {
1789 } VkBlendFactor;
1790 
1791 typedef enum VkBlendOp {
1797  VK_BLEND_OP_ZERO_EXT = 1000148000,
1798  VK_BLEND_OP_SRC_EXT = 1000148001,
1799  VK_BLEND_OP_DST_EXT = 1000148002,
1808  VK_BLEND_OP_XOR_EXT = 1000148011,
1832  VK_BLEND_OP_PLUS_EXT = 1000148035,
1840  VK_BLEND_OP_RED_EXT = 1000148043,
1842  VK_BLEND_OP_BLUE_EXT = 1000148045,
1844 } VkBlendOp;
1845 
1846 typedef enum VkCompareOp {
1856 } VkCompareOp;
1857 
1858 typedef enum VkDynamicState {
1943 } VkDynamicState;
1944 
1945 typedef enum VkFrontFace {
1949 } VkFrontFace;
1950 
1951 typedef enum VkVertexInputRate {
1956 
1957 typedef enum VkPrimitiveTopology {
1971 
1972 typedef enum VkPolygonMode {
1978 } VkPolygonMode;
1979 
1980 typedef enum VkStencilOp {
1990 } VkStencilOp;
1991 
1992 typedef enum VkLogicOp {
2010 } VkLogicOp;
2011 
2012 typedef enum VkBorderColor {
2022 } VkBorderColor;
2023 
2024 typedef enum VkFilter {
2027  VK_FILTER_CUBIC_EXT = 1000015000,
2029  VK_FILTER_MAX_ENUM = 0x7FFFFFFF
2030 } VkFilter;
2031 
2032 typedef enum VkSamplerAddressMode {
2041 
2042 typedef enum VkSamplerMipmapMode {
2047 
2048 typedef enum VkDescriptorType {
2070 
2071 typedef enum VkAttachmentLoadOp {
2078 
2079 typedef enum VkAttachmentStoreOp {
2088 
2089 typedef enum VkPipelineBindPoint {
2097 
2098 typedef enum VkCommandBufferLevel {
2103 
2104 typedef enum VkIndexType {
2111 } VkIndexType;
2112 
2113 typedef enum VkSubpassContents {
2118 
2119 typedef enum VkAccessFlagBits {
2155 typedef VkFlags VkAccessFlags;
2156 
2176 typedef VkFlags VkImageAspectFlags;
2177 
2202 #ifdef VK_ENABLE_BETA_EXTENSIONS
2203  VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000,
2204 #endif
2205 #ifdef VK_ENABLE_BETA_EXTENSIONS
2206  VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000,
2207 #endif
2212 #ifdef VK_ENABLE_BETA_EXTENSIONS
2213  VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000,
2214 #endif
2215 #ifdef VK_ENABLE_BETA_EXTENSIONS
2216  VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000,
2217 #endif
2231 typedef VkFlags VkFormatFeatureFlags;
2232 
2261 typedef VkFlags VkImageCreateFlags;
2262 
2273 typedef VkFlags VkSampleCountFlags;
2274 
2275 typedef enum VkImageUsageFlagBits {
2284 #ifdef VK_ENABLE_BETA_EXTENSIONS
2285  VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400,
2286 #endif
2287 #ifdef VK_ENABLE_BETA_EXTENSIONS
2288  VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800,
2289 #endif
2290 #ifdef VK_ENABLE_BETA_EXTENSIONS
2291  VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000,
2292 #endif
2295 #ifdef VK_ENABLE_BETA_EXTENSIONS
2296  VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000,
2297 #endif
2298 #ifdef VK_ENABLE_BETA_EXTENSIONS
2299  VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000,
2300 #endif
2301 #ifdef VK_ENABLE_BETA_EXTENSIONS
2302  VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000,
2303 #endif
2311 typedef VkFlags VkImageUsageFlags;
2312 
2317 typedef VkFlags VkInstanceCreateFlags;
2318 
2319 typedef enum VkMemoryHeapFlagBits {
2325 typedef VkFlags VkMemoryHeapFlags;
2326 
2339 typedef VkFlags VkMemoryPropertyFlags;
2340 
2341 typedef enum VkQueueFlagBits {
2343  VK_QUEUE_COMPUTE_BIT = 0x00000002,
2347 #ifdef VK_ENABLE_BETA_EXTENSIONS
2348  VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020,
2349 #endif
2350 #ifdef VK_ENABLE_BETA_EXTENSIONS
2351  VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040,
2352 #endif
2355 } VkQueueFlagBits;
2356 typedef VkFlags VkQueueFlags;
2357 typedef VkFlags VkDeviceCreateFlags;
2358 
2364 
2401 typedef VkFlags VkPipelineStageFlags;
2402 typedef VkFlags VkMemoryMapFlags;
2403 
2408 typedef VkFlags VkSparseMemoryBindFlags;
2409 
2417 
2422 typedef VkFlags VkFenceCreateFlags;
2423 typedef VkFlags VkSemaphoreCreateFlags;
2424 
2430 typedef VkFlags VkEventCreateFlags;
2431 
2449 typedef VkFlags VkQueryPoolCreateFlags;
2450 
2456 #ifdef VK_ENABLE_BETA_EXTENSIONS
2457  VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010,
2458 #endif
2461 typedef VkFlags VkQueryResultFlags;
2462 
2474 typedef VkFlags VkBufferCreateFlags;
2475 
2487 #ifdef VK_ENABLE_BETA_EXTENSIONS
2488  VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000,
2489 #endif
2490 #ifdef VK_ENABLE_BETA_EXTENSIONS
2491  VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000,
2492 #endif
2499 #ifdef VK_ENABLE_BETA_EXTENSIONS
2500  VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000,
2501 #endif
2502 #ifdef VK_ENABLE_BETA_EXTENSIONS
2503  VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000,
2504 #endif
2515 typedef VkFlags VkBufferUsageFlags;
2516 typedef VkFlags VkBufferViewCreateFlags;
2517 
2524 typedef VkFlags VkImageViewCreateFlags;
2526 
2533 
2541 typedef VkFlags VkColorComponentFlags;
2542 
2583 typedef VkFlags VkPipelineCreateFlags;
2584 
2593 
2602  VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
2622 
2623 typedef enum VkCullModeFlagBits {
2630 typedef VkFlags VkCullModeFlags;
2637 
2646 
2654 
2660 typedef VkFlags VkShaderStageFlags;
2661 
2670 typedef VkFlags VkSamplerCreateFlags;
2671 
2682 
2694 
2700 
2701 typedef enum VkDependencyFlagBits {
2710 typedef VkFlags VkDependencyFlags;
2711 
2718 
2723 typedef VkFlags VkRenderPassCreateFlags;
2724 
2740 
2748 
2753 typedef VkFlags VkCommandPoolResetFlags;
2754 
2762 
2767 typedef VkFlags VkQueryControlFlags;
2768 
2774 
2782 typedef VkFlags VkStencilFaceFlags;
2783 typedef struct VkExtent2D {
2784  uint32_t width;
2785  uint32_t height;
2786 } VkExtent2D;
2787 
2788 typedef struct VkExtent3D {
2789  uint32_t width;
2790  uint32_t height;
2791  uint32_t depth;
2792 } VkExtent3D;
2793 
2794 typedef struct VkOffset2D {
2795  int32_t x;
2796  int32_t y;
2797 } VkOffset2D;
2798 
2799 typedef struct VkOffset3D {
2800  int32_t x;
2801  int32_t y;
2802  int32_t z;
2803 } VkOffset3D;
2804 
2805 typedef struct VkRect2D {
2808 } VkRect2D;
2809 
2810 typedef struct VkBaseInStructure {
2812  const struct VkBaseInStructure* pNext;
2814 
2815 typedef struct VkBaseOutStructure {
2819 
2820 typedef struct VkBufferMemoryBarrier {
2822  const void* pNext;
2823  VkAccessFlags srcAccessMask;
2824  VkAccessFlags dstAccessMask;
2827  VkBuffer buffer;
2828  VkDeviceSize offset;
2829  VkDeviceSize size;
2831 
2833  uint32_t x;
2834  uint32_t y;
2835  uint32_t z;
2837 
2839  uint32_t indexCount;
2840  uint32_t instanceCount;
2841  uint32_t firstIndex;
2842  int32_t vertexOffset;
2843  uint32_t firstInstance;
2845 
2846 typedef struct VkDrawIndirectCommand {
2847  uint32_t vertexCount;
2848  uint32_t instanceCount;
2849  uint32_t firstVertex;
2850  uint32_t firstInstance;
2852 
2853 typedef struct VkImageSubresourceRange {
2854  VkImageAspectFlags aspectMask;
2855  uint32_t baseMipLevel;
2856  uint32_t levelCount;
2857  uint32_t baseArrayLayer;
2858  uint32_t layerCount;
2860 
2861 typedef struct VkImageMemoryBarrier {
2863  const void* pNext;
2864  VkAccessFlags srcAccessMask;
2865  VkAccessFlags dstAccessMask;
2870  VkImage image;
2873 
2874 typedef struct VkMemoryBarrier {
2876  const void* pNext;
2877  VkAccessFlags srcAccessMask;
2878  VkAccessFlags dstAccessMask;
2879 } VkMemoryBarrier;
2880 
2882  uint32_t headerSize;
2884  uint32_t vendorID;
2885  uint32_t deviceID;
2888 
2890  void* pUserData,
2891  size_t size,
2892  size_t alignment,
2893  VkSystemAllocationScope allocationScope);
2894 
2896  void* pUserData,
2897  void* pMemory);
2898 
2900  void* pUserData,
2901  size_t size,
2902  VkInternalAllocationType allocationType,
2903  VkSystemAllocationScope allocationScope);
2904 
2906  void* pUserData,
2907  size_t size,
2908  VkInternalAllocationType allocationType,
2909  VkSystemAllocationScope allocationScope);
2910 
2912  void* pUserData,
2913  void* pOriginal,
2914  size_t size,
2915  size_t alignment,
2916  VkSystemAllocationScope allocationScope);
2917 
2919 typedef struct VkAllocationCallbacks {
2920  void* pUserData;
2927 
2928 typedef struct VkApplicationInfo {
2930  const void* pNext;
2931  const char* pApplicationName;
2933  const char* pEngineName;
2934  uint32_t engineVersion;
2935  uint32_t apiVersion;
2937 
2938 typedef struct VkFormatProperties {
2939  VkFormatFeatureFlags linearTilingFeatures;
2940  VkFormatFeatureFlags optimalTilingFeatures;
2941  VkFormatFeatureFlags bufferFeatures;
2943 
2944 typedef struct VkImageFormatProperties {
2946  uint32_t maxMipLevels;
2947  uint32_t maxArrayLayers;
2948  VkSampleCountFlags sampleCounts;
2949  VkDeviceSize maxResourceSize;
2951 
2952 typedef struct VkInstanceCreateInfo {
2954  const void* pNext;
2955  VkInstanceCreateFlags flags;
2958  const char* const* ppEnabledLayerNames;
2960  const char* const* ppEnabledExtensionNames;
2962 
2963 typedef struct VkMemoryHeap {
2964  VkDeviceSize size;
2965  VkMemoryHeapFlags flags;
2966 } VkMemoryHeap;
2967 
2968 typedef struct VkMemoryType {
2969  VkMemoryPropertyFlags propertyFlags;
2970  uint32_t heapIndex;
2971 } VkMemoryType;
2972 
2976  VkBool32 imageCubeArray;
2978  VkBool32 geometryShader;
2981  VkBool32 dualSrcBlend;
2982  VkBool32 logicOp;
2985  VkBool32 depthClamp;
2986  VkBool32 depthBiasClamp;
2988  VkBool32 depthBounds;
2989  VkBool32 wideLines;
2990  VkBool32 largePoints;
2991  VkBool32 alphaToOne;
2992  VkBool32 multiViewport;
3013  VkBool32 shaderFloat64;
3014  VkBool32 shaderInt64;
3015  VkBool32 shaderInt16;
3018  VkBool32 sparseBinding;
3030 
3031 typedef struct VkPhysicalDeviceLimits {
3094  uint32_t maxViewports;
3103  uint32_t maxTexelOffset;
3112  VkSampleCountFlags framebufferColorSampleCounts;
3113  VkSampleCountFlags framebufferDepthSampleCounts;
3117  VkSampleCountFlags sampledImageColorSampleCounts;
3119  VkSampleCountFlags sampledImageDepthSampleCounts;
3121  VkSampleCountFlags storageImageSampleCounts;
3129  float pointSizeRange[2];
3130  float lineWidthRange[2];
3133  VkBool32 strictLines;
3137  VkDeviceSize nonCoherentAtomSize;
3139 
3146 
3154 
3156  uint32_t apiVersion;
3157  uint32_t driverVersion;
3158  uint32_t vendorID;
3159  uint32_t deviceID;
3166 
3167 typedef struct VkQueueFamilyProperties {
3168  VkQueueFlags queueFlags;
3169  uint32_t queueCount;
3173 
3174 typedef struct VkDeviceQueueCreateInfo {
3176  const void* pNext;
3177  VkDeviceQueueCreateFlags flags;
3179  uint32_t queueCount;
3180  const float* pQueuePriorities;
3182 
3183 typedef struct VkDeviceCreateInfo {
3185  const void* pNext;
3186  VkDeviceCreateFlags flags;
3190  const char* const* ppEnabledLayerNames;
3192  const char* const* ppEnabledExtensionNames;
3195 
3196 typedef struct VkExtensionProperties {
3198  uint32_t specVersion;
3200 
3201 typedef struct VkLayerProperties {
3203  uint32_t specVersion;
3207 
3208 typedef struct VkSubmitInfo {
3210  const void* pNext;
3212  const VkSemaphore* pWaitSemaphores;
3213  const VkPipelineStageFlags* pWaitDstStageMask;
3215  const VkCommandBuffer* pCommandBuffers;
3217  const VkSemaphore* pSignalSemaphores;
3218 } VkSubmitInfo;
3219 
3220 typedef struct VkMappedMemoryRange {
3222  const void* pNext;
3223  VkDeviceMemory memory;
3224  VkDeviceSize offset;
3225  VkDeviceSize size;
3227 
3228 typedef struct VkMemoryAllocateInfo {
3230  const void* pNext;
3231  VkDeviceSize allocationSize;
3234 
3235 typedef struct VkMemoryRequirements {
3236  VkDeviceSize size;
3237  VkDeviceSize alignment;
3238  uint32_t memoryTypeBits;
3240 
3241 typedef struct VkSparseMemoryBind {
3242  VkDeviceSize resourceOffset;
3243  VkDeviceSize size;
3244  VkDeviceMemory memory;
3245  VkDeviceSize memoryOffset;
3246  VkSparseMemoryBindFlags flags;
3248 
3250  VkBuffer buffer;
3251  uint32_t bindCount;
3254 
3256  VkImage image;
3257  uint32_t bindCount;
3260 
3261 typedef struct VkImageSubresource {
3262  VkImageAspectFlags aspectMask;
3263  uint32_t mipLevel;
3264  uint32_t arrayLayer;
3266 
3267 typedef struct VkSparseImageMemoryBind {
3271  VkDeviceMemory memory;
3272  VkDeviceSize memoryOffset;
3273  VkSparseMemoryBindFlags flags;
3275 
3277  VkImage image;
3278  uint32_t bindCount;
3281 
3282 typedef struct VkBindSparseInfo {
3284  const void* pNext;
3286  const VkSemaphore* pWaitSemaphores;
3291  uint32_t imageBindCount;
3294  const VkSemaphore* pSignalSemaphores;
3296 
3298  VkImageAspectFlags aspectMask;
3300  VkSparseImageFormatFlags flags;
3302 
3306  VkDeviceSize imageMipTailSize;
3307  VkDeviceSize imageMipTailOffset;
3308  VkDeviceSize imageMipTailStride;
3310 
3311 typedef struct VkFenceCreateInfo {
3313  const void* pNext;
3314  VkFenceCreateFlags flags;
3316 
3317 typedef struct VkSemaphoreCreateInfo {
3319  const void* pNext;
3320  VkSemaphoreCreateFlags flags;
3322 
3323 typedef struct VkEventCreateInfo {
3325  const void* pNext;
3326  VkEventCreateFlags flags;
3328 
3329 typedef struct VkQueryPoolCreateInfo {
3331  const void* pNext;
3332  VkQueryPoolCreateFlags flags;
3334  uint32_t queryCount;
3335  VkQueryPipelineStatisticFlags pipelineStatistics;
3337 
3338 typedef struct VkBufferCreateInfo {
3340  const void* pNext;
3341  VkBufferCreateFlags flags;
3342  VkDeviceSize size;
3343  VkBufferUsageFlags usage;
3346  const uint32_t* pQueueFamilyIndices;
3348 
3349 typedef struct VkBufferViewCreateInfo {
3351  const void* pNext;
3352  VkBufferViewCreateFlags flags;
3353  VkBuffer buffer;
3355  VkDeviceSize offset;
3356  VkDeviceSize range;
3358 
3359 typedef struct VkImageCreateInfo {
3361  const void* pNext;
3362  VkImageCreateFlags flags;
3366  uint32_t mipLevels;
3367  uint32_t arrayLayers;
3370  VkImageUsageFlags usage;
3373  const uint32_t* pQueueFamilyIndices;
3376 
3377 typedef struct VkSubresourceLayout {
3378  VkDeviceSize offset;
3379  VkDeviceSize size;
3380  VkDeviceSize rowPitch;
3381  VkDeviceSize arrayPitch;
3382  VkDeviceSize depthPitch;
3384 
3385 typedef struct VkComponentMapping {
3391 
3392 typedef struct VkImageViewCreateInfo {
3394  const void* pNext;
3395  VkImageViewCreateFlags flags;
3396  VkImage image;
3402 
3405  const void* pNext;
3406  VkShaderModuleCreateFlags flags;
3407  size_t codeSize;
3408  const uint32_t* pCode;
3410 
3413  const void* pNext;
3414  VkPipelineCacheCreateFlags flags;
3416  const void* pInitialData;
3418 
3420  uint32_t constantID;
3421  uint32_t offset;
3422  size_t size;
3424 
3425 typedef struct VkSpecializationInfo {
3426  uint32_t mapEntryCount;
3428  size_t dataSize;
3429  const void* pData;
3431 
3434  const void* pNext;
3435  VkPipelineShaderStageCreateFlags flags;
3437  VkShaderModule module;
3438  const char* pName;
3441 
3444  const void* pNext;
3445  VkPipelineCreateFlags flags;
3447  VkPipelineLayout layout;
3451 
3453  uint32_t binding;
3454  uint32_t stride;
3457 
3459  uint32_t location;
3460  uint32_t binding;
3462  uint32_t offset;
3464 
3467  const void* pNext;
3468  VkPipelineVertexInputStateCreateFlags flags;
3474 
3477  const void* pNext;
3478  VkPipelineInputAssemblyStateCreateFlags flags;
3482 
3485  const void* pNext;
3486  VkPipelineTessellationStateCreateFlags flags;
3489 
3490 typedef struct VkViewport {
3491  float x;
3492  float y;
3493  float width;
3494  float height;
3495  float minDepth;
3496  float maxDepth;
3497 } VkViewport;
3498 
3501  const void* pNext;
3502  VkPipelineViewportStateCreateFlags flags;
3503  uint32_t viewportCount;
3505  uint32_t scissorCount;
3508 
3511  const void* pNext;
3512  VkPipelineRasterizationStateCreateFlags flags;
3516  VkCullModeFlags cullMode;
3522  float lineWidth;
3524 
3527  const void* pNext;
3528  VkPipelineMultisampleStateCreateFlags flags;
3532  const VkSampleMask* pSampleMask;
3536 
3537 typedef struct VkStencilOpState {
3542  uint32_t compareMask;
3543  uint32_t writeMask;
3544  uint32_t reference;
3546 
3549  const void* pNext;
3550  VkPipelineDepthStencilStateCreateFlags flags;
3561 
3563  VkBool32 blendEnable;
3570  VkColorComponentFlags colorWriteMask;
3572 
3575  const void* pNext;
3576  VkPipelineColorBlendStateCreateFlags flags;
3577  VkBool32 logicOpEnable;
3581  float blendConstants[4];
3583 
3586  const void* pNext;
3587  VkPipelineDynamicStateCreateFlags flags;
3591 
3594  const void* pNext;
3595  VkPipelineCreateFlags flags;
3596  uint32_t stageCount;
3607  VkPipelineLayout layout;
3608  VkRenderPass renderPass;
3609  uint32_t subpass;
3613 
3614 typedef struct VkPushConstantRange {
3615  VkShaderStageFlags stageFlags;
3616  uint32_t offset;
3617  uint32_t size;
3619 
3622  const void* pNext;
3623  VkPipelineLayoutCreateFlags flags;
3624  uint32_t setLayoutCount;
3625  const VkDescriptorSetLayout* pSetLayouts;
3629 
3630 typedef struct VkSamplerCreateInfo {
3632  const void* pNext;
3633  VkSamplerCreateFlags flags;
3640  float mipLodBias;
3643  VkBool32 compareEnable;
3645  float minLod;
3646  float maxLod;
3650 
3651 typedef struct VkCopyDescriptorSet {
3653  const void* pNext;
3654  VkDescriptorSet srcSet;
3655  uint32_t srcBinding;
3657  VkDescriptorSet dstSet;
3658  uint32_t dstBinding;
3662 
3663 typedef struct VkDescriptorBufferInfo {
3664  VkBuffer buffer;
3665  VkDeviceSize offset;
3666  VkDeviceSize range;
3668 
3669 typedef struct VkDescriptorImageInfo {
3670  VkSampler sampler;
3671  VkImageView imageView;
3674 
3675 typedef struct VkDescriptorPoolSize {
3679 
3682  const void* pNext;
3683  VkDescriptorPoolCreateFlags flags;
3684  uint32_t maxSets;
3685  uint32_t poolSizeCount;
3688 
3691  const void* pNext;
3692  VkDescriptorPool descriptorPool;
3694  const VkDescriptorSetLayout* pSetLayouts;
3696 
3698  uint32_t binding;
3701  VkShaderStageFlags stageFlags;
3702  const VkSampler* pImmutableSamplers;
3704 
3707  const void* pNext;
3708  VkDescriptorSetLayoutCreateFlags flags;
3709  uint32_t bindingCount;
3712 
3713 typedef struct VkWriteDescriptorSet {
3715  const void* pNext;
3716  VkDescriptorSet dstSet;
3717  uint32_t dstBinding;
3723  const VkBufferView* pTexelBufferView;
3725 
3726 typedef struct VkAttachmentDescription {
3727  VkAttachmentDescriptionFlags flags;
3737 
3738 typedef struct VkAttachmentReference {
3739  uint32_t attachment;
3742 
3743 typedef struct VkFramebufferCreateInfo {
3745  const void* pNext;
3746  VkFramebufferCreateFlags flags;
3747  VkRenderPass renderPass;
3749  const VkImageView* pAttachments;
3750  uint32_t width;
3751  uint32_t height;
3752  uint32_t layers;
3754 
3755 typedef struct VkSubpassDescription {
3756  VkSubpassDescriptionFlags flags;
3765  const uint32_t* pPreserveAttachments;
3767 
3768 typedef struct VkSubpassDependency {
3769  uint32_t srcSubpass;
3770  uint32_t dstSubpass;
3771  VkPipelineStageFlags srcStageMask;
3772  VkPipelineStageFlags dstStageMask;
3773  VkAccessFlags srcAccessMask;
3774  VkAccessFlags dstAccessMask;
3775  VkDependencyFlags dependencyFlags;
3777 
3778 typedef struct VkRenderPassCreateInfo {
3780  const void* pNext;
3781  VkRenderPassCreateFlags flags;
3784  uint32_t subpassCount;
3789 
3790 typedef struct VkCommandPoolCreateInfo {
3792  const void* pNext;
3793  VkCommandPoolCreateFlags flags;
3796 
3799  const void* pNext;
3800  VkCommandPool commandPool;
3804 
3807  const void* pNext;
3808  VkRenderPass renderPass;
3809  uint32_t subpass;
3810  VkFramebuffer framebuffer;
3812  VkQueryControlFlags queryFlags;
3813  VkQueryPipelineStatisticFlags pipelineStatistics;
3815 
3818  const void* pNext;
3819  VkCommandBufferUsageFlags flags;
3822 
3823 typedef struct VkBufferCopy {
3824  VkDeviceSize srcOffset;
3825  VkDeviceSize dstOffset;
3826  VkDeviceSize size;
3827 } VkBufferCopy;
3828 
3830  VkImageAspectFlags aspectMask;
3831  uint32_t mipLevel;
3832  uint32_t baseArrayLayer;
3833  uint32_t layerCount;
3835 
3836 typedef struct VkBufferImageCopy {
3837  VkDeviceSize bufferOffset;
3844 
3845 typedef union VkClearColorValue {
3846  float float32[4];
3847  int32_t int32[4];
3848  uint32_t uint32[4];
3850 
3852  float depth;
3853  uint32_t stencil;
3855 
3856 typedef union VkClearValue {
3859 } VkClearValue;
3860 
3861 typedef struct VkClearAttachment {
3862  VkImageAspectFlags aspectMask;
3866 
3867 typedef struct VkClearRect {
3869  uint32_t baseArrayLayer;
3870  uint32_t layerCount;
3871 } VkClearRect;
3872 
3873 typedef struct VkImageBlit {
3878 } VkImageBlit;
3879 
3880 typedef struct VkImageCopy {
3886 } VkImageCopy;
3887 
3888 typedef struct VkImageResolve {
3894 } VkImageResolve;
3895 
3896 typedef struct VkRenderPassBeginInfo {
3898  const void* pNext;
3899  VkRenderPass renderPass;
3900  VkFramebuffer framebuffer;
3905 
3906 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
3907 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
3908 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
3909 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
3910 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
3911 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
3912 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
3913 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
3914 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
3915 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
3916 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
3917 typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
3918 typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
3919 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
3920 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
3921 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
3922 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
3923 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
3924 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
3926 typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
3927 typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
3928 typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
3929 typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
3930 typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
3931 typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
3932 typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
3933 typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
3934 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
3935 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
3936 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
3937 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
3938 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
3939 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
3940 typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
3941 typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
3942 typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
3943 typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
3944 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
3945 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
3946 typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
3947 typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
3948 typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
3949 typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
3950 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
3951 typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
3952 typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
3953 typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
3954 typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
3955 typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
3956 typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
3957 typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
3958 typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
3959 typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
3960 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
3961 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
3962 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
3963 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
3964 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
3965 typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
3966 typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
3967 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
3968 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
3969 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
3970 typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
3971 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
3972 typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
3973 typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
3974 typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
3975 typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
3976 typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
3977 typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
3978 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
3979 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
3980 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
3981 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
3982 typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
3983 typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
3984 typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
3985 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
3986 typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
3987 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
3988 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
3989 typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
3990 typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
3991 typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
3992 typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
3993 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
3994 typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
3995 typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
3996 typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
3997 typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
3998 typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
3999 typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
4000 typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
4001 typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
4002 typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
4003 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
4004 typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
4005 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
4006 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
4007 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
4008 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
4009 typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
4010 typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
4011 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
4012 typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
4013 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
4014 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
4015 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
4016 typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
4017 typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
4018 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
4019 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
4020 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
4021 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
4022 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
4023 typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
4024 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
4025 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
4026 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
4027 typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
4028 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
4029 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
4030 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
4031 typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
4032 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
4033 typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
4034 typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
4035 typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
4036 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
4037 typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
4038 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
4039 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
4040 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
4041 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
4042 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
4043 
4044 #ifndef VK_NO_PROTOTYPES
4046  const VkInstanceCreateInfo* pCreateInfo,
4047  const VkAllocationCallbacks* pAllocator,
4048  VkInstance* pInstance);
4049 
4051  VkInstance instance,
4052  const VkAllocationCallbacks* pAllocator);
4053 
4055  VkInstance instance,
4056  uint32_t* pPhysicalDeviceCount,
4057  VkPhysicalDevice* pPhysicalDevices);
4058 
4060  VkPhysicalDevice physicalDevice,
4061  VkPhysicalDeviceFeatures* pFeatures);
4062 
4064  VkPhysicalDevice physicalDevice,
4065  VkFormat format,
4066  VkFormatProperties* pFormatProperties);
4067 
4069  VkPhysicalDevice physicalDevice,
4070  VkFormat format,
4071  VkImageType type,
4072  VkImageTiling tiling,
4073  VkImageUsageFlags usage,
4074  VkImageCreateFlags flags,
4075  VkImageFormatProperties* pImageFormatProperties);
4076 
4078  VkPhysicalDevice physicalDevice,
4079  VkPhysicalDeviceProperties* pProperties);
4080 
4082  VkPhysicalDevice physicalDevice,
4083  uint32_t* pQueueFamilyPropertyCount,
4084  VkQueueFamilyProperties* pQueueFamilyProperties);
4085 
4087  VkPhysicalDevice physicalDevice,
4088  VkPhysicalDeviceMemoryProperties* pMemoryProperties);
4089 
4091  VkInstance instance,
4092  const char* pName);
4093 
4095  VkDevice device,
4096  const char* pName);
4097 
4099  VkPhysicalDevice physicalDevice,
4100  const VkDeviceCreateInfo* pCreateInfo,
4101  const VkAllocationCallbacks* pAllocator,
4102  VkDevice* pDevice);
4103 
4105  VkDevice device,
4106  const VkAllocationCallbacks* pAllocator);
4107 
4109  const char* pLayerName,
4110  uint32_t* pPropertyCount,
4111  VkExtensionProperties* pProperties);
4112 
4114  VkPhysicalDevice physicalDevice,
4115  const char* pLayerName,
4116  uint32_t* pPropertyCount,
4117  VkExtensionProperties* pProperties);
4118 
4120  uint32_t* pPropertyCount,
4121  VkLayerProperties* pProperties);
4122 
4124  VkPhysicalDevice physicalDevice,
4125  uint32_t* pPropertyCount,
4126  VkLayerProperties* pProperties);
4127 
4129  VkDevice device,
4130  uint32_t queueFamilyIndex,
4131  uint32_t queueIndex,
4132  VkQueue* pQueue);
4133 
4135  VkQueue queue,
4136  uint32_t submitCount,
4137  const VkSubmitInfo* pSubmits,
4138  VkFence fence);
4139 
4141  VkQueue queue);
4142 
4144  VkDevice device);
4145 
4147  VkDevice device,
4148  const VkMemoryAllocateInfo* pAllocateInfo,
4149  const VkAllocationCallbacks* pAllocator,
4150  VkDeviceMemory* pMemory);
4151 
4153  VkDevice device,
4154  VkDeviceMemory memory,
4155  const VkAllocationCallbacks* pAllocator);
4156 
4158  VkDevice device,
4159  VkDeviceMemory memory,
4160  VkDeviceSize offset,
4161  VkDeviceSize size,
4162  VkMemoryMapFlags flags,
4163  void** ppData);
4164 
4166  VkDevice device,
4167  VkDeviceMemory memory);
4168 
4170  VkDevice device,
4171  uint32_t memoryRangeCount,
4172  const VkMappedMemoryRange* pMemoryRanges);
4173 
4175  VkDevice device,
4176  uint32_t memoryRangeCount,
4177  const VkMappedMemoryRange* pMemoryRanges);
4178 
4180  VkDevice device,
4181  VkDeviceMemory memory,
4182  VkDeviceSize* pCommittedMemoryInBytes);
4183 
4185  VkDevice device,
4186  VkBuffer buffer,
4187  VkDeviceMemory memory,
4188  VkDeviceSize memoryOffset);
4189 
4191  VkDevice device,
4192  VkImage image,
4193  VkDeviceMemory memory,
4194  VkDeviceSize memoryOffset);
4195 
4197  VkDevice device,
4198  VkBuffer buffer,
4199  VkMemoryRequirements* pMemoryRequirements);
4200 
4202  VkDevice device,
4203  VkImage image,
4204  VkMemoryRequirements* pMemoryRequirements);
4205 
4207  VkDevice device,
4208  VkImage image,
4209  uint32_t* pSparseMemoryRequirementCount,
4210  VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
4211 
4213  VkPhysicalDevice physicalDevice,
4214  VkFormat format,
4215  VkImageType type,
4216  VkSampleCountFlagBits samples,
4217  VkImageUsageFlags usage,
4218  VkImageTiling tiling,
4219  uint32_t* pPropertyCount,
4220  VkSparseImageFormatProperties* pProperties);
4221 
4223  VkQueue queue,
4224  uint32_t bindInfoCount,
4225  const VkBindSparseInfo* pBindInfo,
4226  VkFence fence);
4227 
4229  VkDevice device,
4230  const VkFenceCreateInfo* pCreateInfo,
4231  const VkAllocationCallbacks* pAllocator,
4232  VkFence* pFence);
4233 
4235  VkDevice device,
4236  VkFence fence,
4237  const VkAllocationCallbacks* pAllocator);
4238 
4240  VkDevice device,
4241  uint32_t fenceCount,
4242  const VkFence* pFences);
4243 
4245  VkDevice device,
4246  VkFence fence);
4247 
4249  VkDevice device,
4250  uint32_t fenceCount,
4251  const VkFence* pFences,
4252  VkBool32 waitAll,
4253  uint64_t timeout);
4254 
4256  VkDevice device,
4257  const VkSemaphoreCreateInfo* pCreateInfo,
4258  const VkAllocationCallbacks* pAllocator,
4259  VkSemaphore* pSemaphore);
4260 
4262  VkDevice device,
4263  VkSemaphore semaphore,
4264  const VkAllocationCallbacks* pAllocator);
4265 
4267  VkDevice device,
4268  const VkEventCreateInfo* pCreateInfo,
4269  const VkAllocationCallbacks* pAllocator,
4270  VkEvent* pEvent);
4271 
4273  VkDevice device,
4274  VkEvent event,
4275  const VkAllocationCallbacks* pAllocator);
4276 
4278  VkDevice device,
4279  VkEvent event);
4280 
4282  VkDevice device,
4283  VkEvent event);
4284 
4286  VkDevice device,
4287  VkEvent event);
4288 
4290  VkDevice device,
4291  const VkQueryPoolCreateInfo* pCreateInfo,
4292  const VkAllocationCallbacks* pAllocator,
4293  VkQueryPool* pQueryPool);
4294 
4296  VkDevice device,
4297  VkQueryPool queryPool,
4298  const VkAllocationCallbacks* pAllocator);
4299 
4301  VkDevice device,
4302  VkQueryPool queryPool,
4303  uint32_t firstQuery,
4304  uint32_t queryCount,
4305  size_t dataSize,
4306  void* pData,
4307  VkDeviceSize stride,
4308  VkQueryResultFlags flags);
4309 
4311  VkDevice device,
4312  const VkBufferCreateInfo* pCreateInfo,
4313  const VkAllocationCallbacks* pAllocator,
4314  VkBuffer* pBuffer);
4315 
4317  VkDevice device,
4318  VkBuffer buffer,
4319  const VkAllocationCallbacks* pAllocator);
4320 
4322  VkDevice device,
4323  const VkBufferViewCreateInfo* pCreateInfo,
4324  const VkAllocationCallbacks* pAllocator,
4325  VkBufferView* pView);
4326 
4328  VkDevice device,
4329  VkBufferView bufferView,
4330  const VkAllocationCallbacks* pAllocator);
4331 
4333  VkDevice device,
4334  const VkImageCreateInfo* pCreateInfo,
4335  const VkAllocationCallbacks* pAllocator,
4336  VkImage* pImage);
4337 
4339  VkDevice device,
4340  VkImage image,
4341  const VkAllocationCallbacks* pAllocator);
4342 
4344  VkDevice device,
4345  VkImage image,
4346  const VkImageSubresource* pSubresource,
4347  VkSubresourceLayout* pLayout);
4348 
4350  VkDevice device,
4351  const VkImageViewCreateInfo* pCreateInfo,
4352  const VkAllocationCallbacks* pAllocator,
4353  VkImageView* pView);
4354 
4356  VkDevice device,
4357  VkImageView imageView,
4358  const VkAllocationCallbacks* pAllocator);
4359 
4361  VkDevice device,
4362  const VkShaderModuleCreateInfo* pCreateInfo,
4363  const VkAllocationCallbacks* pAllocator,
4364  VkShaderModule* pShaderModule);
4365 
4367  VkDevice device,
4368  VkShaderModule shaderModule,
4369  const VkAllocationCallbacks* pAllocator);
4370 
4372  VkDevice device,
4373  const VkPipelineCacheCreateInfo* pCreateInfo,
4374  const VkAllocationCallbacks* pAllocator,
4375  VkPipelineCache* pPipelineCache);
4376 
4378  VkDevice device,
4379  VkPipelineCache pipelineCache,
4380  const VkAllocationCallbacks* pAllocator);
4381 
4383  VkDevice device,
4384  VkPipelineCache pipelineCache,
4385  size_t* pDataSize,
4386  void* pData);
4387 
4389  VkDevice device,
4390  VkPipelineCache dstCache,
4391  uint32_t srcCacheCount,
4392  const VkPipelineCache* pSrcCaches);
4393 
4395  VkDevice device,
4396  VkPipelineCache pipelineCache,
4397  uint32_t createInfoCount,
4398  const VkGraphicsPipelineCreateInfo* pCreateInfos,
4399  const VkAllocationCallbacks* pAllocator,
4400  VkPipeline* pPipelines);
4401 
4403  VkDevice device,
4404  VkPipelineCache pipelineCache,
4405  uint32_t createInfoCount,
4406  const VkComputePipelineCreateInfo* pCreateInfos,
4407  const VkAllocationCallbacks* pAllocator,
4408  VkPipeline* pPipelines);
4409 
4411  VkDevice device,
4412  VkPipeline pipeline,
4413  const VkAllocationCallbacks* pAllocator);
4414 
4416  VkDevice device,
4417  const VkPipelineLayoutCreateInfo* pCreateInfo,
4418  const VkAllocationCallbacks* pAllocator,
4419  VkPipelineLayout* pPipelineLayout);
4420 
4422  VkDevice device,
4423  VkPipelineLayout pipelineLayout,
4424  const VkAllocationCallbacks* pAllocator);
4425 
4427  VkDevice device,
4428  const VkSamplerCreateInfo* pCreateInfo,
4429  const VkAllocationCallbacks* pAllocator,
4430  VkSampler* pSampler);
4431 
4433  VkDevice device,
4434  VkSampler sampler,
4435  const VkAllocationCallbacks* pAllocator);
4436 
4438  VkDevice device,
4439  const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
4440  const VkAllocationCallbacks* pAllocator,
4441  VkDescriptorSetLayout* pSetLayout);
4442 
4444  VkDevice device,
4445  VkDescriptorSetLayout descriptorSetLayout,
4446  const VkAllocationCallbacks* pAllocator);
4447 
4449  VkDevice device,
4450  const VkDescriptorPoolCreateInfo* pCreateInfo,
4451  const VkAllocationCallbacks* pAllocator,
4452  VkDescriptorPool* pDescriptorPool);
4453 
4455  VkDevice device,
4456  VkDescriptorPool descriptorPool,
4457  const VkAllocationCallbacks* pAllocator);
4458 
4460  VkDevice device,
4461  VkDescriptorPool descriptorPool,
4462  VkDescriptorPoolResetFlags flags);
4463 
4465  VkDevice device,
4466  const VkDescriptorSetAllocateInfo* pAllocateInfo,
4467  VkDescriptorSet* pDescriptorSets);
4468 
4470  VkDevice device,
4471  VkDescriptorPool descriptorPool,
4472  uint32_t descriptorSetCount,
4473  const VkDescriptorSet* pDescriptorSets);
4474 
4476  VkDevice device,
4477  uint32_t descriptorWriteCount,
4478  const VkWriteDescriptorSet* pDescriptorWrites,
4479  uint32_t descriptorCopyCount,
4480  const VkCopyDescriptorSet* pDescriptorCopies);
4481 
4483  VkDevice device,
4484  const VkFramebufferCreateInfo* pCreateInfo,
4485  const VkAllocationCallbacks* pAllocator,
4486  VkFramebuffer* pFramebuffer);
4487 
4489  VkDevice device,
4490  VkFramebuffer framebuffer,
4491  const VkAllocationCallbacks* pAllocator);
4492 
4494  VkDevice device,
4495  const VkRenderPassCreateInfo* pCreateInfo,
4496  const VkAllocationCallbacks* pAllocator,
4497  VkRenderPass* pRenderPass);
4498 
4500  VkDevice device,
4501  VkRenderPass renderPass,
4502  const VkAllocationCallbacks* pAllocator);
4503 
4505  VkDevice device,
4506  VkRenderPass renderPass,
4507  VkExtent2D* pGranularity);
4508 
4510  VkDevice device,
4511  const VkCommandPoolCreateInfo* pCreateInfo,
4512  const VkAllocationCallbacks* pAllocator,
4513  VkCommandPool* pCommandPool);
4514 
4516  VkDevice device,
4517  VkCommandPool commandPool,
4518  const VkAllocationCallbacks* pAllocator);
4519 
4521  VkDevice device,
4522  VkCommandPool commandPool,
4523  VkCommandPoolResetFlags flags);
4524 
4526  VkDevice device,
4527  const VkCommandBufferAllocateInfo* pAllocateInfo,
4528  VkCommandBuffer* pCommandBuffers);
4529 
4531  VkDevice device,
4532  VkCommandPool commandPool,
4533  uint32_t commandBufferCount,
4534  const VkCommandBuffer* pCommandBuffers);
4535 
4537  VkCommandBuffer commandBuffer,
4538  const VkCommandBufferBeginInfo* pBeginInfo);
4539 
4541  VkCommandBuffer commandBuffer);
4542 
4544  VkCommandBuffer commandBuffer,
4545  VkCommandBufferResetFlags flags);
4546 
4548  VkCommandBuffer commandBuffer,
4549  VkPipelineBindPoint pipelineBindPoint,
4550  VkPipeline pipeline);
4551 
4553  VkCommandBuffer commandBuffer,
4554  uint32_t firstViewport,
4555  uint32_t viewportCount,
4556  const VkViewport* pViewports);
4557 
4559  VkCommandBuffer commandBuffer,
4560  uint32_t firstScissor,
4561  uint32_t scissorCount,
4562  const VkRect2D* pScissors);
4563 
4565  VkCommandBuffer commandBuffer,
4566  float lineWidth);
4567 
4569  VkCommandBuffer commandBuffer,
4570  float depthBiasConstantFactor,
4571  float depthBiasClamp,
4572  float depthBiasSlopeFactor);
4573 
4575  VkCommandBuffer commandBuffer,
4576  const float blendConstants[4]);
4577 
4579  VkCommandBuffer commandBuffer,
4580  float minDepthBounds,
4581  float maxDepthBounds);
4582 
4584  VkCommandBuffer commandBuffer,
4585  VkStencilFaceFlags faceMask,
4586  uint32_t compareMask);
4587 
4589  VkCommandBuffer commandBuffer,
4590  VkStencilFaceFlags faceMask,
4591  uint32_t writeMask);
4592 
4594  VkCommandBuffer commandBuffer,
4595  VkStencilFaceFlags faceMask,
4596  uint32_t reference);
4597 
4599  VkCommandBuffer commandBuffer,
4600  VkPipelineBindPoint pipelineBindPoint,
4601  VkPipelineLayout layout,
4602  uint32_t firstSet,
4603  uint32_t descriptorSetCount,
4604  const VkDescriptorSet* pDescriptorSets,
4605  uint32_t dynamicOffsetCount,
4606  const uint32_t* pDynamicOffsets);
4607 
4609  VkCommandBuffer commandBuffer,
4610  VkBuffer buffer,
4611  VkDeviceSize offset,
4612  VkIndexType indexType);
4613 
4615  VkCommandBuffer commandBuffer,
4616  uint32_t firstBinding,
4617  uint32_t bindingCount,
4618  const VkBuffer* pBuffers,
4619  const VkDeviceSize* pOffsets);
4620 
4622  VkCommandBuffer commandBuffer,
4623  uint32_t vertexCount,
4624  uint32_t instanceCount,
4625  uint32_t firstVertex,
4626  uint32_t firstInstance);
4627 
4629  VkCommandBuffer commandBuffer,
4630  uint32_t indexCount,
4631  uint32_t instanceCount,
4632  uint32_t firstIndex,
4633  int32_t vertexOffset,
4634  uint32_t firstInstance);
4635 
4637  VkCommandBuffer commandBuffer,
4638  VkBuffer buffer,
4639  VkDeviceSize offset,
4640  uint32_t drawCount,
4641  uint32_t stride);
4642 
4644  VkCommandBuffer commandBuffer,
4645  VkBuffer buffer,
4646  VkDeviceSize offset,
4647  uint32_t drawCount,
4648  uint32_t stride);
4649 
4651  VkCommandBuffer commandBuffer,
4652  uint32_t groupCountX,
4653  uint32_t groupCountY,
4654  uint32_t groupCountZ);
4655 
4657  VkCommandBuffer commandBuffer,
4658  VkBuffer buffer,
4659  VkDeviceSize offset);
4660 
4662  VkCommandBuffer commandBuffer,
4663  VkBuffer srcBuffer,
4664  VkBuffer dstBuffer,
4665  uint32_t regionCount,
4666  const VkBufferCopy* pRegions);
4667 
4669  VkCommandBuffer commandBuffer,
4670  VkImage srcImage,
4671  VkImageLayout srcImageLayout,
4672  VkImage dstImage,
4673  VkImageLayout dstImageLayout,
4674  uint32_t regionCount,
4675  const VkImageCopy* pRegions);
4676 
4678  VkCommandBuffer commandBuffer,
4679  VkImage srcImage,
4680  VkImageLayout srcImageLayout,
4681  VkImage dstImage,
4682  VkImageLayout dstImageLayout,
4683  uint32_t regionCount,
4684  const VkImageBlit* pRegions,
4685  VkFilter filter);
4686 
4688  VkCommandBuffer commandBuffer,
4689  VkBuffer srcBuffer,
4690  VkImage dstImage,
4691  VkImageLayout dstImageLayout,
4692  uint32_t regionCount,
4693  const VkBufferImageCopy* pRegions);
4694 
4696  VkCommandBuffer commandBuffer,
4697  VkImage srcImage,
4698  VkImageLayout srcImageLayout,
4699  VkBuffer dstBuffer,
4700  uint32_t regionCount,
4701  const VkBufferImageCopy* pRegions);
4702 
4704  VkCommandBuffer commandBuffer,
4705  VkBuffer dstBuffer,
4706  VkDeviceSize dstOffset,
4707  VkDeviceSize dataSize,
4708  const void* pData);
4709 
4711  VkCommandBuffer commandBuffer,
4712  VkBuffer dstBuffer,
4713  VkDeviceSize dstOffset,
4714  VkDeviceSize size,
4715  uint32_t data);
4716 
4718  VkCommandBuffer commandBuffer,
4719  VkImage image,
4720  VkImageLayout imageLayout,
4721  const VkClearColorValue* pColor,
4722  uint32_t rangeCount,
4723  const VkImageSubresourceRange* pRanges);
4724 
4726  VkCommandBuffer commandBuffer,
4727  VkImage image,
4728  VkImageLayout imageLayout,
4729  const VkClearDepthStencilValue* pDepthStencil,
4730  uint32_t rangeCount,
4731  const VkImageSubresourceRange* pRanges);
4732 
4734  VkCommandBuffer commandBuffer,
4735  uint32_t attachmentCount,
4736  const VkClearAttachment* pAttachments,
4737  uint32_t rectCount,
4738  const VkClearRect* pRects);
4739 
4741  VkCommandBuffer commandBuffer,
4742  VkImage srcImage,
4743  VkImageLayout srcImageLayout,
4744  VkImage dstImage,
4745  VkImageLayout dstImageLayout,
4746  uint32_t regionCount,
4747  const VkImageResolve* pRegions);
4748 
4750  VkCommandBuffer commandBuffer,
4751  VkEvent event,
4752  VkPipelineStageFlags stageMask);
4753 
4755  VkCommandBuffer commandBuffer,
4756  VkEvent event,
4757  VkPipelineStageFlags stageMask);
4758 
4760  VkCommandBuffer commandBuffer,
4761  uint32_t eventCount,
4762  const VkEvent* pEvents,
4763  VkPipelineStageFlags srcStageMask,
4764  VkPipelineStageFlags dstStageMask,
4765  uint32_t memoryBarrierCount,
4766  const VkMemoryBarrier* pMemoryBarriers,
4767  uint32_t bufferMemoryBarrierCount,
4768  const VkBufferMemoryBarrier* pBufferMemoryBarriers,
4769  uint32_t imageMemoryBarrierCount,
4770  const VkImageMemoryBarrier* pImageMemoryBarriers);
4771 
4773  VkCommandBuffer commandBuffer,
4774  VkPipelineStageFlags srcStageMask,
4775  VkPipelineStageFlags dstStageMask,
4776  VkDependencyFlags dependencyFlags,
4777  uint32_t memoryBarrierCount,
4778  const VkMemoryBarrier* pMemoryBarriers,
4779  uint32_t bufferMemoryBarrierCount,
4780  const VkBufferMemoryBarrier* pBufferMemoryBarriers,
4781  uint32_t imageMemoryBarrierCount,
4782  const VkImageMemoryBarrier* pImageMemoryBarriers);
4783 
4785  VkCommandBuffer commandBuffer,
4786  VkQueryPool queryPool,
4787  uint32_t query,
4788  VkQueryControlFlags flags);
4789 
4791  VkCommandBuffer commandBuffer,
4792  VkQueryPool queryPool,
4793  uint32_t query);
4794 
4796  VkCommandBuffer commandBuffer,
4797  VkQueryPool queryPool,
4798  uint32_t firstQuery,
4799  uint32_t queryCount);
4800 
4802  VkCommandBuffer commandBuffer,
4803  VkPipelineStageFlagBits pipelineStage,
4804  VkQueryPool queryPool,
4805  uint32_t query);
4806 
4808  VkCommandBuffer commandBuffer,
4809  VkQueryPool queryPool,
4810  uint32_t firstQuery,
4811  uint32_t queryCount,
4812  VkBuffer dstBuffer,
4813  VkDeviceSize dstOffset,
4814  VkDeviceSize stride,
4815  VkQueryResultFlags flags);
4816 
4818  VkCommandBuffer commandBuffer,
4819  VkPipelineLayout layout,
4820  VkShaderStageFlags stageFlags,
4821  uint32_t offset,
4822  uint32_t size,
4823  const void* pValues);
4824 
4826  VkCommandBuffer commandBuffer,
4827  const VkRenderPassBeginInfo* pRenderPassBegin,
4828  VkSubpassContents contents);
4829 
4831  VkCommandBuffer commandBuffer,
4832  VkSubpassContents contents);
4833 
4835  VkCommandBuffer commandBuffer);
4836 
4838  VkCommandBuffer commandBuffer,
4839  uint32_t commandBufferCount,
4840  const VkCommandBuffer* pCommandBuffers);
4841 #endif
4842 
4843 
4844 #define VK_VERSION_1_1 1
4845 // Vulkan 1.1 version number
4846 #define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0
4847 
4848 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)
4849 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)
4850 #define VK_MAX_DEVICE_GROUP_SIZE 32U
4851 #define VK_LUID_SIZE 8U
4852 #define VK_QUEUE_FAMILY_EXTERNAL (~1U)
4853 
4861 
4869 
4883 
4884 typedef enum VkSamplerYcbcrRange {
4891 
4892 typedef enum VkChromaLocation {
4899 
4906 
4919 typedef VkFlags VkSubgroupFeatureFlags;
4920 
4933 
4943 typedef VkFlags VkMemoryAllocateFlags;
4944 typedef VkFlags VkCommandPoolTrimFlags;
4946 
4971 
4982 
4995 
5004 
5010 typedef VkFlags VkFenceImportFlags;
5011 
5017 typedef VkFlags VkSemaphoreImportFlags;
5018 
5035 
5046  void* pNext;
5047  uint32_t subgroupSize;
5048  VkShaderStageFlags supportedStages;
5049  VkSubgroupFeatureFlags supportedOperations;
5052 
5053 typedef struct VkBindBufferMemoryInfo {
5055  const void* pNext;
5056  VkBuffer buffer;
5057  VkDeviceMemory memory;
5058  VkDeviceSize memoryOffset;
5060 
5061 typedef struct VkBindImageMemoryInfo {
5063  const void* pNext;
5064  VkImage image;
5065  VkDeviceMemory memory;
5066  VkDeviceSize memoryOffset;
5068 
5071  void* pNext;
5077 
5080  void* pNext;
5084 
5087  const void* pNext;
5088  VkImage image;
5089  VkBuffer buffer;
5091 
5094  const void* pNext;
5095  VkMemoryAllocateFlags flags;
5096  uint32_t deviceMask;
5098 
5101  const void* pNext;
5102  uint32_t deviceMask;
5106 
5109  const void* pNext;
5110  uint32_t deviceMask;
5112 
5113 typedef struct VkDeviceGroupSubmitInfo {
5115  const void* pNext;
5119  const uint32_t* pCommandBufferDeviceMasks;
5123 
5126  const void* pNext;
5130 
5133  const void* pNext;
5135  const uint32_t* pDeviceIndices;
5137 
5140  const void* pNext;
5142  const uint32_t* pDeviceIndices;
5146 
5149  void* pNext;
5154 
5157  const void* pNext;
5159  const VkPhysicalDevice* pPhysicalDevices;
5161 
5164  const void* pNext;
5165  VkBuffer buffer;
5167 
5170  const void* pNext;
5171  VkImage image;
5173 
5176  const void* pNext;
5177  VkImage image;
5179 
5180 typedef struct VkMemoryRequirements2 {
5182  void* pNext;
5185 
5188  void* pNext;
5191 
5194  void* pNext;
5197 
5200  void* pNext;
5203 
5204 typedef struct VkFormatProperties2 {
5206  void* pNext;
5209 
5212  void* pNext;
5215 
5218  const void* pNext;
5222  VkImageUsageFlags usage;
5223  VkImageCreateFlags flags;
5225 
5228  void* pNext;
5231 
5234  void* pNext;
5237 
5240  void* pNext;
5243 
5246  const void* pNext;
5250  VkImageUsageFlags usage;
5253 
5256  void* pNext;
5259 
5261  uint32_t subpass;
5263  VkImageAspectFlags aspectMask;
5265 
5268  const void* pNext;
5272 
5275  const void* pNext;
5276  VkImageUsageFlags usage;
5278 
5281  const void* pNext;
5284 
5287  const void* pNext;
5288  uint32_t subpassCount;
5289  const uint32_t* pViewMasks;
5291  const int32_t* pViewOffsets;
5293  const uint32_t* pCorrelationMasks;
5295 
5298  void* pNext;
5299  VkBool32 multiview;
5303 
5306  void* pNext;
5310 
5313  void* pNext;
5317 
5319 
5322  void* pNext;
5325 
5328  void* pNext;
5331 
5332 typedef struct VkDeviceQueueInfo2 {
5334  const void* pNext;
5335  VkDeviceQueueCreateFlags flags;
5337  uint32_t queueIndex;
5339 
5340 typedef struct VkProtectedSubmitInfo {
5342  const void* pNext;
5345 
5348  const void* pNext;
5358 
5361  const void* pNext;
5362  VkSamplerYcbcrConversion conversion;
5364 
5367  const void* pNext;
5370 
5373  const void* pNext;
5376 
5379  void* pNext;
5382 
5385  void* pNext;
5388 
5390  uint32_t dstBinding;
5394  size_t offset;
5395  size_t stride;
5397 
5400  const void* pNext;
5401  VkDescriptorUpdateTemplateCreateFlags flags;
5405  VkDescriptorSetLayout descriptorSetLayout;
5407  VkPipelineLayout pipelineLayout;
5408  uint32_t set;
5410 
5412  VkExternalMemoryFeatureFlags externalMemoryFeatures;
5413  VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
5414  VkExternalMemoryHandleTypeFlags compatibleHandleTypes;
5416 
5419  const void* pNext;
5422 
5425  void* pNext;
5428 
5431  const void* pNext;
5432  VkBufferCreateFlags flags;
5433  VkBufferUsageFlags usage;
5436 
5439  void* pNext;
5442 
5445  void* pNext;
5449  uint32_t deviceNodeMask;
5452 
5455  const void* pNext;
5456  VkExternalMemoryHandleTypeFlags handleTypes;
5458 
5461  const void* pNext;
5462  VkExternalMemoryHandleTypeFlags handleTypes;
5464 
5467  const void* pNext;
5468  VkExternalMemoryHandleTypeFlags handleTypes;
5470 
5473  const void* pNext;
5476 
5479  void* pNext;
5480  VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
5481  VkExternalFenceHandleTypeFlags compatibleHandleTypes;
5482  VkExternalFenceFeatureFlags externalFenceFeatures;
5484 
5485 typedef struct VkExportFenceCreateInfo {
5487  const void* pNext;
5488  VkExternalFenceHandleTypeFlags handleTypes;
5490 
5493  const void* pNext;
5494  VkExternalSemaphoreHandleTypeFlags handleTypes;
5496 
5499  const void* pNext;
5502 
5505  void* pNext;
5506  VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
5507  VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
5508  VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
5510 
5513  void* pNext;
5517 
5520  void* pNext;
5521  VkBool32 supported;
5523 
5526  void* pNext;
5529 
5531 
5532 typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion);
5533 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
5534 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
5535 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
5536 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
5537 typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
5538 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
5539 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
5540 typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
5541 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
5542 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
5543 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
5544 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
5545 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
5546 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
5547 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
5548 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
5549 typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
5550 typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
5551 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
5552 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
5553 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
5554 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
5555 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
5556 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
5557 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
5558 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
5560 
5561 #ifndef VK_NO_PROTOTYPES
5563  uint32_t* pApiVersion);
5564 
5566  VkDevice device,
5567  uint32_t bindInfoCount,
5568  const VkBindBufferMemoryInfo* pBindInfos);
5569 
5571  VkDevice device,
5572  uint32_t bindInfoCount,
5573  const VkBindImageMemoryInfo* pBindInfos);
5574 
5576  VkDevice device,
5577  uint32_t heapIndex,
5578  uint32_t localDeviceIndex,
5579  uint32_t remoteDeviceIndex,
5580  VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
5581 
5583  VkCommandBuffer commandBuffer,
5584  uint32_t deviceMask);
5585 
5587  VkCommandBuffer commandBuffer,
5588  uint32_t baseGroupX,
5589  uint32_t baseGroupY,
5590  uint32_t baseGroupZ,
5591  uint32_t groupCountX,
5592  uint32_t groupCountY,
5593  uint32_t groupCountZ);
5594 
5596  VkInstance instance,
5597  uint32_t* pPhysicalDeviceGroupCount,
5598  VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
5599 
5601  VkDevice device,
5602  const VkImageMemoryRequirementsInfo2* pInfo,
5603  VkMemoryRequirements2* pMemoryRequirements);
5604 
5606  VkDevice device,
5607  const VkBufferMemoryRequirementsInfo2* pInfo,
5608  VkMemoryRequirements2* pMemoryRequirements);
5609 
5611  VkDevice device,
5613  uint32_t* pSparseMemoryRequirementCount,
5614  VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
5615 
5617  VkPhysicalDevice physicalDevice,
5618  VkPhysicalDeviceFeatures2* pFeatures);
5619 
5621  VkPhysicalDevice physicalDevice,
5622  VkPhysicalDeviceProperties2* pProperties);
5623 
5625  VkPhysicalDevice physicalDevice,
5626  VkFormat format,
5627  VkFormatProperties2* pFormatProperties);
5628 
5630  VkPhysicalDevice physicalDevice,
5631  const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
5632  VkImageFormatProperties2* pImageFormatProperties);
5633 
5635  VkPhysicalDevice physicalDevice,
5636  uint32_t* pQueueFamilyPropertyCount,
5637  VkQueueFamilyProperties2* pQueueFamilyProperties);
5638 
5640  VkPhysicalDevice physicalDevice,
5641  VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
5642 
5644  VkPhysicalDevice physicalDevice,
5645  const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
5646  uint32_t* pPropertyCount,
5647  VkSparseImageFormatProperties2* pProperties);
5648 
5650  VkDevice device,
5651  VkCommandPool commandPool,
5652  VkCommandPoolTrimFlags flags);
5653 
5655  VkDevice device,
5656  const VkDeviceQueueInfo2* pQueueInfo,
5657  VkQueue* pQueue);
5658 
5660  VkDevice device,
5661  const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
5662  const VkAllocationCallbacks* pAllocator,
5663  VkSamplerYcbcrConversion* pYcbcrConversion);
5664 
5666  VkDevice device,
5667  VkSamplerYcbcrConversion ycbcrConversion,
5668  const VkAllocationCallbacks* pAllocator);
5669 
5671  VkDevice device,
5672  const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
5673  const VkAllocationCallbacks* pAllocator,
5674  VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
5675 
5677  VkDevice device,
5678  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
5679  const VkAllocationCallbacks* pAllocator);
5680 
5682  VkDevice device,
5683  VkDescriptorSet descriptorSet,
5684  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
5685  const void* pData);
5686 
5688  VkPhysicalDevice physicalDevice,
5689  const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
5690  VkExternalBufferProperties* pExternalBufferProperties);
5691 
5693  VkPhysicalDevice physicalDevice,
5694  const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
5695  VkExternalFenceProperties* pExternalFenceProperties);
5696 
5698  VkPhysicalDevice physicalDevice,
5699  const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
5700  VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
5701 
5703  VkDevice device,
5704  const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
5705  VkDescriptorSetLayoutSupport* pSupport);
5706 #endif
5707 
5708 
5709 #define VK_VERSION_1_2 1
5710 // Vulkan 1.2 version number
5711 #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0
5712 
5713 #define VK_MAX_DRIVER_NAME_SIZE 256U
5714 #define VK_MAX_DRIVER_INFO_SIZE 256U
5715 
5716 typedef enum VkDriverId {
5754 } VkDriverId;
5755 
5765 
5775 
5776 typedef enum VkSemaphoreType {
5782 } VkSemaphoreType;
5783 
5797 typedef VkFlags VkResolveModeFlags;
5798 
5811 
5817 typedef VkFlags VkSemaphoreWaitFlags;
5820  void* pNext;
5825  VkBool32 multiview;
5834 
5837  void* pNext;
5841  uint32_t deviceNodeMask;
5843  uint32_t subgroupSize;
5844  VkShaderStageFlags subgroupSupportedStages;
5845  VkSubgroupFeatureFlags subgroupSupportedOperations;
5854 
5857  void* pNext;
5865  VkBool32 shaderFloat16;
5866  VkBool32 shaderInt8;
5894  VkBool32 hostQueryReset;
5906 
5907 typedef struct VkConformanceVersion {
5908  uint8_t major;
5909  uint8_t minor;
5910  uint8_t subminor;
5911  uint8_t patch;
5913 
5916  void* pNext;
5961  VkResolveModeFlags supportedDepthResolveModes;
5962  VkResolveModeFlags supportedStencilResolveModes;
5970 
5973  const void* pNext;
5977 
5980  const void* pNext;
5981  VkAttachmentDescriptionFlags flags;
5991 
5992 typedef struct VkAttachmentReference2 {
5994  const void* pNext;
5995  uint32_t attachment;
5997  VkImageAspectFlags aspectMask;
5999 
6000 typedef struct VkSubpassDescription2 {
6002  const void* pNext;
6003  VkSubpassDescriptionFlags flags;
6005  uint32_t viewMask;
6013  const uint32_t* pPreserveAttachments;
6015 
6016 typedef struct VkSubpassDependency2 {
6018  const void* pNext;
6019  uint32_t srcSubpass;
6020  uint32_t dstSubpass;
6021  VkPipelineStageFlags srcStageMask;
6022  VkPipelineStageFlags dstStageMask;
6023  VkAccessFlags srcAccessMask;
6024  VkAccessFlags dstAccessMask;
6025  VkDependencyFlags dependencyFlags;
6026  int32_t viewOffset;
6028 
6029 typedef struct VkRenderPassCreateInfo2 {
6031  const void* pNext;
6032  VkRenderPassCreateFlags flags;
6035  uint32_t subpassCount;
6040  const uint32_t* pCorrelatedViewMasks;
6042 
6043 typedef struct VkSubpassBeginInfo {
6045  const void* pNext;
6048 
6049 typedef struct VkSubpassEndInfo {
6051  const void* pNext;
6053 
6056  void* pNext;
6061 
6064  void* pNext;
6070 
6073  void* pNext;
6077 
6080  void* pNext;
6081  VkBool32 shaderFloat16;
6082  VkBool32 shaderInt8;
6084 
6087  void* pNext;
6106 
6109  const void* pNext;
6110  uint32_t bindingCount;
6111  const VkDescriptorBindingFlags* pBindingFlags;
6113 
6116  void* pNext;
6138 
6141  void* pNext;
6166 
6169  const void* pNext;
6171  const uint32_t* pDescriptorCounts;
6173 
6176  void* pNext;
6179 
6182  const void* pNext;
6187 
6190  void* pNext;
6191  VkResolveModeFlags supportedDepthResolveModes;
6192  VkResolveModeFlags supportedStencilResolveModes;
6196 
6199  void* pNext;
6202 
6205  const void* pNext;
6206  VkImageUsageFlags stencilUsage;
6208 
6211  const void* pNext;
6214 
6217  void* pNext;
6221 
6224  void* pNext;
6229 
6232  void* pNext;
6235 
6238  const void* pNext;
6239  VkImageCreateFlags flags;
6240  VkImageUsageFlags usage;
6241  uint32_t width;
6242  uint32_t height;
6243  uint32_t layerCount;
6247 
6250  const void* pNext;
6254 
6257  const void* pNext;
6259  const VkImageView* pAttachments;
6261 
6264  void* pNext;
6267 
6270  void* pNext;
6273 
6276  void* pNext;
6279 
6282  void* pNext;
6285 
6288  void* pNext;
6292 
6295  void* pNext;
6296  VkBool32 hostQueryReset;
6298 
6301  void* pNext;
6304 
6307  void* pNext;
6310 
6313  const void* pNext;
6315  uint64_t initialValue;
6317 
6320  const void* pNext;
6322  const uint64_t* pWaitSemaphoreValues;
6324  const uint64_t* pSignalSemaphoreValues;
6326 
6327 typedef struct VkSemaphoreWaitInfo {
6329  const void* pNext;
6330  VkSemaphoreWaitFlags flags;
6331  uint32_t semaphoreCount;
6332  const VkSemaphore* pSemaphores;
6333  const uint64_t* pValues;
6335 
6336 typedef struct VkSemaphoreSignalInfo {
6338  const void* pNext;
6339  VkSemaphore semaphore;
6340  uint64_t value;
6342 
6345  void* pNext;
6350 
6353  const void* pNext;
6354  VkBuffer buffer;
6356 
6359  const void* pNext;
6362 
6365  const void* pNext;
6368 
6371  const void* pNext;
6372  VkDeviceMemory memory;
6374 
6375 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
6376 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
6377 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
6378 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo);
6379 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo);
6380 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo);
6381 typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
6382 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
6383 typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
6384 typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
6386 typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
6388 
6389 #ifndef VK_NO_PROTOTYPES
6391  VkCommandBuffer commandBuffer,
6392  VkBuffer buffer,
6393  VkDeviceSize offset,
6394  VkBuffer countBuffer,
6395  VkDeviceSize countBufferOffset,
6396  uint32_t maxDrawCount,
6397  uint32_t stride);
6398 
6400  VkCommandBuffer commandBuffer,
6401  VkBuffer buffer,
6402  VkDeviceSize offset,
6403  VkBuffer countBuffer,
6404  VkDeviceSize countBufferOffset,
6405  uint32_t maxDrawCount,
6406  uint32_t stride);
6407 
6409  VkDevice device,
6410  const VkRenderPassCreateInfo2* pCreateInfo,
6411  const VkAllocationCallbacks* pAllocator,
6412  VkRenderPass* pRenderPass);
6413 
6415  VkCommandBuffer commandBuffer,
6416  const VkRenderPassBeginInfo* pRenderPassBegin,
6417  const VkSubpassBeginInfo* pSubpassBeginInfo);
6418 
6420  VkCommandBuffer commandBuffer,
6421  const VkSubpassBeginInfo* pSubpassBeginInfo,
6422  const VkSubpassEndInfo* pSubpassEndInfo);
6423 
6425  VkCommandBuffer commandBuffer,
6426  const VkSubpassEndInfo* pSubpassEndInfo);
6427 
6429  VkDevice device,
6430  VkQueryPool queryPool,
6431  uint32_t firstQuery,
6432  uint32_t queryCount);
6433 
6435  VkDevice device,
6436  VkSemaphore semaphore,
6437  uint64_t* pValue);
6438 
6440  VkDevice device,
6441  const VkSemaphoreWaitInfo* pWaitInfo,
6442  uint64_t timeout);
6443 
6445  VkDevice device,
6446  const VkSemaphoreSignalInfo* pSignalInfo);
6447 
6449  VkDevice device,
6450  const VkBufferDeviceAddressInfo* pInfo);
6451 
6453  VkDevice device,
6454  const VkBufferDeviceAddressInfo* pInfo);
6455 
6457  VkDevice device,
6459 #endif
6460 
6461 
6462 #define VK_VERSION_1_3 1
6463 // Vulkan 1.3 version number
6464 #define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0)// Patch version should always be set to 0
6465 
6466 typedef uint64_t VkFlags64;
6467 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot)
6468 
6479 
6495 typedef VkFlags VkToolPurposeFlags;
6497 typedef VkFlags64 VkPipelineStageFlags2;
6498 
6499 // Flag bits for VkPipelineStageFlagBits2
6500 typedef VkFlags64 VkPipelineStageFlagBits2;
6501 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE = 0ULL;
6502 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL;
6503 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 0x00000001ULL;
6504 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL;
6505 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 0x00000002ULL;
6506 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL;
6507 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 0x00000004ULL;
6508 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL;
6509 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 0x00000008ULL;
6510 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL;
6511 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010ULL;
6512 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL;
6513 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020ULL;
6514 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL;
6515 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 0x00000040ULL;
6516 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL;
6517 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 0x00000080ULL;
6518 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL;
6519 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 0x00000100ULL;
6520 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL;
6521 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 0x00000200ULL;
6522 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL;
6523 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400ULL;
6524 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL;
6525 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 0x00000800ULL;
6526 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL;
6527 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 0x00001000ULL;
6528 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL;
6529 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT = 0x00001000ULL;
6530 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL;
6531 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 0x00002000ULL;
6532 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL;
6533 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT = 0x00004000ULL;
6534 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL;
6535 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 0x00008000ULL;
6536 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL;
6537 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0x00010000ULL;
6538 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL;
6539 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT = 0x100000000ULL;
6540 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL;
6541 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 0x200000000ULL;
6542 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL;
6543 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT = 0x400000000ULL;
6544 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL;
6545 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT = 0x800000000ULL;
6546 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL;
6547 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 0x1000000000ULL;
6548 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL;
6549 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 0x2000000000ULL;
6550 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL;
6551 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ULL;
6552 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL;
6553 #ifdef VK_ENABLE_BETA_EXTENSIONS
6554 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL;
6555 #endif
6556 #ifdef VK_ENABLE_BETA_EXTENSIONS
6557 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL;
6558 #endif
6559 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL;
6560 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL;
6561 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL;
6562 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL;
6563 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL;
6564 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL;
6565 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL;
6566 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL;
6567 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL;
6568 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL;
6569 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL;
6570 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL;
6571 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0x00080000ULL;
6572 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT = 0x00100000ULL;
6573 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL;
6574 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL;
6575 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 0x10000000ULL;
6576 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0x40000000ULL;
6577 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0x20000000ULL;
6578 
6579 typedef VkFlags64 VkAccessFlags2;
6580 
6581 // Flag bits for VkAccessFlagBits2
6582 typedef VkFlags64 VkAccessFlagBits2;
6583 static const VkAccessFlagBits2 VK_ACCESS_2_NONE = 0ULL;
6584 static const VkAccessFlagBits2 VK_ACCESS_2_NONE_KHR = 0ULL;
6585 static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 0x00000001ULL;
6586 static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL;
6587 static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT = 0x00000002ULL;
6588 static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL;
6589 static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004ULL;
6590 static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL;
6591 static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT = 0x00000008ULL;
6592 static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL;
6593 static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 0x00000010ULL;
6594 static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL;
6595 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT = 0x00000020ULL;
6596 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL;
6597 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT = 0x00000040ULL;
6598 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL;
6599 static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 0x00000080ULL;
6600 static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL;
6601 static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100ULL;
6602 static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL;
6603 static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200ULL;
6604 static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL;
6605 static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400ULL;
6606 static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL;
6607 static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT = 0x00000800ULL;
6608 static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL;
6609 static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT = 0x00001000ULL;
6610 static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL;
6611 static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT = 0x00002000ULL;
6612 static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL;
6613 static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT = 0x00004000ULL;
6614 static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL;
6615 static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT = 0x00008000ULL;
6616 static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL;
6617 static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT = 0x00010000ULL;
6618 static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL;
6619 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 0x100000000ULL;
6620 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL;
6621 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0x200000000ULL;
6622 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL;
6623 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x400000000ULL;
6624 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL;
6625 #ifdef VK_ENABLE_BETA_EXTENSIONS
6626 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL;
6627 #endif
6628 #ifdef VK_ENABLE_BETA_EXTENSIONS
6629 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL;
6630 #endif
6631 #ifdef VK_ENABLE_BETA_EXTENSIONS
6632 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL;
6633 #endif
6634 #ifdef VK_ENABLE_BETA_EXTENSIONS
6635 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL;
6636 #endif
6637 static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL;
6638 static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL;
6639 static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL;
6640 static const VkAccessFlagBits2 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL;
6641 static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL;
6642 static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL;
6643 static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL;
6644 static const VkAccessFlagBits2 VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL;
6645 static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL;
6646 static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL;
6647 static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL;
6648 static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL;
6649 static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL;
6650 static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL;
6651 static const VkAccessFlagBits2 VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 0x20000000000ULL;
6652 static const VkAccessFlagBits2 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL;
6653 static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0x10000000000ULL;
6654 static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x100000000000ULL;
6655 static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0x200000000000ULL;
6656 static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0x40000000000ULL;
6657 static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0x80000000000ULL;
6658 
6659 
6660 typedef enum VkSubmitFlagBits {
6665 typedef VkFlags VkSubmitFlags;
6666 
6667 typedef enum VkRenderingFlagBits {
6677 typedef VkFlags VkRenderingFlags;
6678 typedef VkFlags64 VkFormatFeatureFlags2;
6679 
6680 // Flag bits for VkFormatFeatureFlagBits2
6681 typedef VkFlags64 VkFormatFeatureFlagBits2;
6682 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 0x00000001ULL;
6683 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL;
6684 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 0x00000002ULL;
6685 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL;
6686 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004ULL;
6687 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL;
6688 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008ULL;
6689 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL;
6690 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 0x00000010ULL;
6691 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000010ULL;
6692 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020ULL;
6693 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 0x00000020ULL;
6694 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 0x00000040ULL;
6695 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 0x00000040ULL;
6696 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 0x00000080ULL;
6697 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000080ULL;
6698 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100ULL;
6699 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 0x00000100ULL;
6700 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200ULL;
6701 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000200ULL;
6702 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 0x00000400ULL;
6703 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 0x00000400ULL;
6704 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 0x00000800ULL;
6705 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 0x00000800ULL;
6706 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000ULL;
6707 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 0x00001000ULL;
6708 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 0x00002000ULL;
6709 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL;
6710 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 0x00004000ULL;
6711 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 0x00004000ULL;
6712 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 0x00008000ULL;
6713 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 0x00008000ULL;
6714 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000ULL;
6715 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL;
6716 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000ULL;
6717 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000ULL;
6718 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000ULL;
6719 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000ULL;
6720 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000ULL;
6721 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000ULL;
6722 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000ULL;
6723 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000ULL;
6724 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000ULL;
6725 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000ULL;
6726 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 0x00400000ULL;
6727 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 0x00400000ULL;
6728 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 0x00800000ULL;
6729 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000ULL;
6730 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 0x80000000ULL;
6731 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 0x80000000ULL;
6732 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 0x100000000ULL;
6733 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL;
6734 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0x200000000ULL;
6735 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL;
6736 #ifdef VK_ENABLE_BETA_EXTENSIONS
6737 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000ULL;
6738 #endif
6739 #ifdef VK_ENABLE_BETA_EXTENSIONS
6740 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000ULL;
6741 #endif
6742 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000ULL;
6743 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL;
6744 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL;
6745 #ifdef VK_ENABLE_BETA_EXTENSIONS
6746 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000ULL;
6747 #endif
6748 #ifdef VK_ENABLE_BETA_EXTENSIONS
6749 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL;
6750 #endif
6751 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL;
6752 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0x400000000ULL;
6753 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0x800000000ULL;
6754 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0x1000000000ULL;
6755 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0x2000000000ULL;
6756 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ULL;
6757 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ULL;
6758 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ULL;
6759 
6762  void* pNext;
6767  VkBool32 privateData;
6777  VkBool32 maintenance4;
6779 
6782  void* pNext;
6786  VkShaderStageFlags requiredSubgroupSizeStages;
6827  VkDeviceSize maxBufferSize;
6829 
6831  VkPipelineCreationFeedbackFlags flags;
6832  uint64_t duration;
6834 
6837  const void* pNext;
6842 
6845  void* pNext;
6848 
6851  void* pNext;
6854  VkToolPurposeFlags purposes;
6858 
6861  void* pNext;
6864 
6867  void* pNext;
6868  VkBool32 privateData;
6870 
6873  const void* pNext;
6876 
6879  const void* pNext;
6880  VkPrivateDataSlotCreateFlags flags;
6882 
6885  void* pNext;
6888 
6889 typedef struct VkMemoryBarrier2 {
6891  const void* pNext;
6892  VkPipelineStageFlags2 srcStageMask;
6893  VkAccessFlags2 srcAccessMask;
6894  VkPipelineStageFlags2 dstStageMask;
6895  VkAccessFlags2 dstAccessMask;
6897 
6898 typedef struct VkBufferMemoryBarrier2 {
6900  const void* pNext;
6901  VkPipelineStageFlags2 srcStageMask;
6902  VkAccessFlags2 srcAccessMask;
6903  VkPipelineStageFlags2 dstStageMask;
6904  VkAccessFlags2 dstAccessMask;
6907  VkBuffer buffer;
6908  VkDeviceSize offset;
6909  VkDeviceSize size;
6911 
6912 typedef struct VkImageMemoryBarrier2 {
6914  const void* pNext;
6915  VkPipelineStageFlags2 srcStageMask;
6916  VkAccessFlags2 srcAccessMask;
6917  VkPipelineStageFlags2 dstStageMask;
6918  VkAccessFlags2 dstAccessMask;
6923  VkImage image;
6926 
6927 typedef struct VkDependencyInfo {
6929  const void* pNext;
6930  VkDependencyFlags dependencyFlags;
6938 
6939 typedef struct VkSemaphoreSubmitInfo {
6941  const void* pNext;
6942  VkSemaphore semaphore;
6943  uint64_t value;
6944  VkPipelineStageFlags2 stageMask;
6945  uint32_t deviceIndex;
6947 
6950  const void* pNext;
6951  VkCommandBuffer commandBuffer;
6952  uint32_t deviceMask;
6954 
6955 typedef struct VkSubmitInfo2 {
6957  const void* pNext;
6958  VkSubmitFlags flags;
6965 } VkSubmitInfo2;
6966 
6969  void* pNext;
6972 
6975  void* pNext;
6978 
6981  void* pNext;
6984 
6985 typedef struct VkBufferCopy2 {
6987  const void* pNext;
6988  VkDeviceSize srcOffset;
6989  VkDeviceSize dstOffset;
6990  VkDeviceSize size;
6991 } VkBufferCopy2;
6992 
6993 typedef struct VkCopyBufferInfo2 {
6995  const void* pNext;
6996  VkBuffer srcBuffer;
6997  VkBuffer dstBuffer;
6998  uint32_t regionCount;
7001 
7002 typedef struct VkImageCopy2 {
7004  const void* pNext;
7010 } VkImageCopy2;
7011 
7012 typedef struct VkCopyImageInfo2 {
7014  const void* pNext;
7015  VkImage srcImage;
7017  VkImage dstImage;
7019  uint32_t regionCount;
7022 
7023 typedef struct VkBufferImageCopy2 {
7025  const void* pNext;
7026  VkDeviceSize bufferOffset;
7033 
7036  const void* pNext;
7037  VkBuffer srcBuffer;
7038  VkImage dstImage;
7040  uint32_t regionCount;
7043 
7046  const void* pNext;
7047  VkImage srcImage;
7049  VkBuffer dstBuffer;
7050  uint32_t regionCount;
7053 
7054 typedef struct VkImageBlit2 {
7056  const void* pNext;
7061 } VkImageBlit2;
7062 
7063 typedef struct VkBlitImageInfo2 {
7065  const void* pNext;
7066  VkImage srcImage;
7068  VkImage dstImage;
7070  uint32_t regionCount;
7074 
7075 typedef struct VkImageResolve2 {
7077  const void* pNext;
7083 } VkImageResolve2;
7084 
7085 typedef struct VkResolveImageInfo2 {
7087  const void* pNext;
7088  VkImage srcImage;
7090  VkImage dstImage;
7092  uint32_t regionCount;
7095 
7098  void* pNext;
7102 
7105  void* pNext;
7109  VkShaderStageFlags requiredSubgroupSizeStages;
7111 
7114  void* pNext;
7117 
7120  void* pNext;
7124 
7127  void* pNext;
7134 
7137  const void* pNext;
7138  uint32_t dataSize;
7139  const void* pData;
7141 
7144  const void* pNext;
7147 
7150  void* pNext;
7153 
7156  const void* pNext;
7157  VkImageView imageView;
7160  VkImageView resolveImageView;
7166 
7167 typedef struct VkRenderingInfo {
7169  const void* pNext;
7170  VkRenderingFlags flags;
7172  uint32_t layerCount;
7173  uint32_t viewMask;
7178 } VkRenderingInfo;
7179 
7182  const void* pNext;
7183  uint32_t viewMask;
7189 
7192  void* pNext;
7195 
7198  const void* pNext;
7199  VkRenderingFlags flags;
7200  uint32_t viewMask;
7207 
7210  void* pNext;
7213 
7216  void* pNext;
7248 
7251  void* pNext;
7257 
7258 typedef struct VkFormatProperties3 {
7260  void* pNext;
7261  VkFormatFeatureFlags2 linearTilingFeatures;
7262  VkFormatFeatureFlags2 optimalTilingFeatures;
7263  VkFormatFeatureFlags2 bufferFeatures;
7265 
7268  void* pNext;
7269  VkBool32 maintenance4;
7271 
7274  void* pNext;
7275  VkDeviceSize maxBufferSize;
7277 
7280  const void* pNext;
7283 
7286  const void* pNext;
7290 
7291 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties);
7292 typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot);
7293 typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator);
7294 typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data);
7295 typedef void (VKAPI_PTR *PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData);
7296 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo);
7297 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask);
7298 typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos);
7299 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo);
7300 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query);
7301 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
7302 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo);
7303 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo);
7304 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
7305 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
7306 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo);
7307 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo);
7308 typedef void (VKAPI_PTR *PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo);
7309 typedef void (VKAPI_PTR *PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer);
7310 typedef void (VKAPI_PTR *PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);
7311 typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace);
7312 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);
7313 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
7314 typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
7315 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides);
7316 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);
7317 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable);
7318 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
7319 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);
7320 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);
7321 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);
7322 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
7323 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);
7324 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
7327 typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
7328 
7329 #ifndef VK_NO_PROTOTYPES
7331  VkPhysicalDevice physicalDevice,
7332  uint32_t* pToolCount,
7333  VkPhysicalDeviceToolProperties* pToolProperties);
7334 
7336  VkDevice device,
7337  const VkPrivateDataSlotCreateInfo* pCreateInfo,
7338  const VkAllocationCallbacks* pAllocator,
7339  VkPrivateDataSlot* pPrivateDataSlot);
7340 
7342  VkDevice device,
7343  VkPrivateDataSlot privateDataSlot,
7344  const VkAllocationCallbacks* pAllocator);
7345 
7347  VkDevice device,
7348  VkObjectType objectType,
7349  uint64_t objectHandle,
7350  VkPrivateDataSlot privateDataSlot,
7351  uint64_t data);
7352 
7354  VkDevice device,
7355  VkObjectType objectType,
7356  uint64_t objectHandle,
7357  VkPrivateDataSlot privateDataSlot,
7358  uint64_t* pData);
7359 
7361  VkCommandBuffer commandBuffer,
7362  VkEvent event,
7363  const VkDependencyInfo* pDependencyInfo);
7364 
7366  VkCommandBuffer commandBuffer,
7367  VkEvent event,
7368  VkPipelineStageFlags2 stageMask);
7369 
7371  VkCommandBuffer commandBuffer,
7372  uint32_t eventCount,
7373  const VkEvent* pEvents,
7374  const VkDependencyInfo* pDependencyInfos);
7375 
7377  VkCommandBuffer commandBuffer,
7378  const VkDependencyInfo* pDependencyInfo);
7379 
7381  VkCommandBuffer commandBuffer,
7382  VkPipelineStageFlags2 stage,
7383  VkQueryPool queryPool,
7384  uint32_t query);
7385 
7387  VkQueue queue,
7388  uint32_t submitCount,
7389  const VkSubmitInfo2* pSubmits,
7390  VkFence fence);
7391 
7393  VkCommandBuffer commandBuffer,
7394  const VkCopyBufferInfo2* pCopyBufferInfo);
7395 
7397  VkCommandBuffer commandBuffer,
7398  const VkCopyImageInfo2* pCopyImageInfo);
7399 
7401  VkCommandBuffer commandBuffer,
7402  const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
7403 
7405  VkCommandBuffer commandBuffer,
7406  const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
7407 
7409  VkCommandBuffer commandBuffer,
7410  const VkBlitImageInfo2* pBlitImageInfo);
7411 
7413  VkCommandBuffer commandBuffer,
7414  const VkResolveImageInfo2* pResolveImageInfo);
7415 
7417  VkCommandBuffer commandBuffer,
7418  const VkRenderingInfo* pRenderingInfo);
7419 
7421  VkCommandBuffer commandBuffer);
7422 
7424  VkCommandBuffer commandBuffer,
7425  VkCullModeFlags cullMode);
7426 
7428  VkCommandBuffer commandBuffer,
7429  VkFrontFace frontFace);
7430 
7432  VkCommandBuffer commandBuffer,
7433  VkPrimitiveTopology primitiveTopology);
7434 
7436  VkCommandBuffer commandBuffer,
7437  uint32_t viewportCount,
7438  const VkViewport* pViewports);
7439 
7441  VkCommandBuffer commandBuffer,
7442  uint32_t scissorCount,
7443  const VkRect2D* pScissors);
7444 
7446  VkCommandBuffer commandBuffer,
7447  uint32_t firstBinding,
7448  uint32_t bindingCount,
7449  const VkBuffer* pBuffers,
7450  const VkDeviceSize* pOffsets,
7451  const VkDeviceSize* pSizes,
7452  const VkDeviceSize* pStrides);
7453 
7455  VkCommandBuffer commandBuffer,
7456  VkBool32 depthTestEnable);
7457 
7459  VkCommandBuffer commandBuffer,
7460  VkBool32 depthWriteEnable);
7461 
7463  VkCommandBuffer commandBuffer,
7464  VkCompareOp depthCompareOp);
7465 
7467  VkCommandBuffer commandBuffer,
7468  VkBool32 depthBoundsTestEnable);
7469 
7471  VkCommandBuffer commandBuffer,
7472  VkBool32 stencilTestEnable);
7473 
7475  VkCommandBuffer commandBuffer,
7476  VkStencilFaceFlags faceMask,
7477  VkStencilOp failOp,
7478  VkStencilOp passOp,
7479  VkStencilOp depthFailOp,
7480  VkCompareOp compareOp);
7481 
7483  VkCommandBuffer commandBuffer,
7484  VkBool32 rasterizerDiscardEnable);
7485 
7487  VkCommandBuffer commandBuffer,
7488  VkBool32 depthBiasEnable);
7489 
7491  VkCommandBuffer commandBuffer,
7492  VkBool32 primitiveRestartEnable);
7493 
7495  VkDevice device,
7496  const VkDeviceBufferMemoryRequirements* pInfo,
7497  VkMemoryRequirements2* pMemoryRequirements);
7498 
7500  VkDevice device,
7501  const VkDeviceImageMemoryRequirements* pInfo,
7502  VkMemoryRequirements2* pMemoryRequirements);
7503 
7505  VkDevice device,
7506  const VkDeviceImageMemoryRequirements* pInfo,
7507  uint32_t* pSparseMemoryRequirementCount,
7508  VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
7509 #endif
7510 
7511 
7512 #define VK_KHR_surface 1
7514 #define VK_KHR_SURFACE_SPEC_VERSION 25
7515 #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
7516 
7517 typedef enum VkPresentModeKHR {
7526 
7527 typedef enum VkColorSpaceKHR {
7547 } VkColorSpaceKHR;
7548 
7561 
7572  uint32_t minImageCount;
7573  uint32_t maxImageCount;
7578  VkSurfaceTransformFlagsKHR supportedTransforms;
7580  VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
7581  VkImageUsageFlags supportedUsageFlags;
7583 
7584 typedef struct VkSurfaceFormatKHR {
7588 
7589 typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
7590 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
7591 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
7592 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
7593 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
7594 
7595 #ifndef VK_NO_PROTOTYPES
7597  VkInstance instance,
7598  VkSurfaceKHR surface,
7599  const VkAllocationCallbacks* pAllocator);
7600 
7602  VkPhysicalDevice physicalDevice,
7603  uint32_t queueFamilyIndex,
7604  VkSurfaceKHR surface,
7605  VkBool32* pSupported);
7606 
7608  VkPhysicalDevice physicalDevice,
7609  VkSurfaceKHR surface,
7610  VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
7611 
7613  VkPhysicalDevice physicalDevice,
7614  VkSurfaceKHR surface,
7615  uint32_t* pSurfaceFormatCount,
7616  VkSurfaceFormatKHR* pSurfaceFormats);
7617 
7619  VkPhysicalDevice physicalDevice,
7620  VkSurfaceKHR surface,
7621  uint32_t* pPresentModeCount,
7622  VkPresentModeKHR* pPresentModes);
7623 #endif
7624 
7625 
7626 #define VK_KHR_swapchain 1
7627 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
7628 #define VK_KHR_SWAPCHAIN_SPEC_VERSION 70
7629 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"
7630 
7638 
7649  const void* pNext;
7650  VkSwapchainCreateFlagsKHR flags;
7651  VkSurfaceKHR surface;
7652  uint32_t minImageCount;
7657  VkImageUsageFlags imageUsage;
7660  const uint32_t* pQueueFamilyIndices;
7664  VkBool32 clipped;
7665  VkSwapchainKHR oldSwapchain;
7667 
7668 typedef struct VkPresentInfoKHR {
7670  const void* pNext;
7672  const VkSemaphore* pWaitSemaphores;
7673  uint32_t swapchainCount;
7674  const VkSwapchainKHR* pSwapchains;
7675  const uint32_t* pImageIndices;
7678 
7681  const void* pNext;
7682  VkSwapchainKHR swapchain;
7684 
7687  const void* pNext;
7688  VkSwapchainKHR swapchain;
7689  uint32_t imageIndex;
7691 
7694  const void* pNext;
7695  VkSwapchainKHR swapchain;
7696  uint64_t timeout;
7697  VkSemaphore semaphore;
7698  VkFence fence;
7699  uint32_t deviceMask;
7701 
7704  void* pNext;
7706  VkDeviceGroupPresentModeFlagsKHR modes;
7708 
7711  const void* pNext;
7712  uint32_t swapchainCount;
7713  const uint32_t* pDeviceMasks;
7716 
7719  const void* pNext;
7720  VkDeviceGroupPresentModeFlagsKHR modes;
7722 
7723 typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
7724 typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
7725 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
7726 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
7727 typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
7728 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
7729 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);
7730 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
7731 typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);
7732 
7733 #ifndef VK_NO_PROTOTYPES
7735  VkDevice device,
7736  const VkSwapchainCreateInfoKHR* pCreateInfo,
7737  const VkAllocationCallbacks* pAllocator,
7738  VkSwapchainKHR* pSwapchain);
7739 
7741  VkDevice device,
7742  VkSwapchainKHR swapchain,
7743  const VkAllocationCallbacks* pAllocator);
7744 
7746  VkDevice device,
7747  VkSwapchainKHR swapchain,
7748  uint32_t* pSwapchainImageCount,
7749  VkImage* pSwapchainImages);
7750 
7752  VkDevice device,
7753  VkSwapchainKHR swapchain,
7754  uint64_t timeout,
7755  VkSemaphore semaphore,
7756  VkFence fence,
7757  uint32_t* pImageIndex);
7758 
7760  VkQueue queue,
7761  const VkPresentInfoKHR* pPresentInfo);
7762 
7764  VkDevice device,
7765  VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
7766 
7768  VkDevice device,
7769  VkSurfaceKHR surface,
7770  VkDeviceGroupPresentModeFlagsKHR* pModes);
7771 
7773  VkPhysicalDevice physicalDevice,
7774  VkSurfaceKHR surface,
7775  uint32_t* pRectCount,
7776  VkRect2D* pRects);
7777 
7779  VkDevice device,
7780  const VkAcquireNextImageInfoKHR* pAcquireInfo,
7781  uint32_t* pImageIndex);
7782 #endif
7783 
7784 
7785 #define VK_KHR_display 1
7787 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
7788 #define VK_KHR_DISPLAY_SPEC_VERSION 23
7789 #define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"
7791 
7803  uint32_t refreshRate;
7805 
7808  const void* pNext;
7809  VkDisplayModeCreateFlagsKHR flags;
7812 
7814  VkDisplayModeKHR displayMode;
7817 
7819  VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
7829 
7831  VkDisplayKHR currentDisplay;
7834 
7835 typedef struct VkDisplayPropertiesKHR {
7836  VkDisplayKHR display;
7837  const char* displayName;
7840  VkSurfaceTransformFlagsKHR supportedTransforms;
7844 
7847  const void* pNext;
7848  VkDisplaySurfaceCreateFlagsKHR flags;
7849  VkDisplayModeKHR displayMode;
7850  uint32_t planeIndex;
7857 
7858 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
7859 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
7860 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
7861 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
7862 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
7863 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
7864 typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
7865 
7866 #ifndef VK_NO_PROTOTYPES
7868  VkPhysicalDevice physicalDevice,
7869  uint32_t* pPropertyCount,
7870  VkDisplayPropertiesKHR* pProperties);
7871 
7873  VkPhysicalDevice physicalDevice,
7874  uint32_t* pPropertyCount,
7875  VkDisplayPlanePropertiesKHR* pProperties);
7876 
7878  VkPhysicalDevice physicalDevice,
7879  uint32_t planeIndex,
7880  uint32_t* pDisplayCount,
7881  VkDisplayKHR* pDisplays);
7882 
7884  VkPhysicalDevice physicalDevice,
7885  VkDisplayKHR display,
7886  uint32_t* pPropertyCount,
7887  VkDisplayModePropertiesKHR* pProperties);
7888 
7890  VkPhysicalDevice physicalDevice,
7891  VkDisplayKHR display,
7892  const VkDisplayModeCreateInfoKHR* pCreateInfo,
7893  const VkAllocationCallbacks* pAllocator,
7894  VkDisplayModeKHR* pMode);
7895 
7897  VkPhysicalDevice physicalDevice,
7898  VkDisplayModeKHR mode,
7899  uint32_t planeIndex,
7900  VkDisplayPlaneCapabilitiesKHR* pCapabilities);
7901 
7903  VkInstance instance,
7904  const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
7905  const VkAllocationCallbacks* pAllocator,
7906  VkSurfaceKHR* pSurface);
7907 #endif
7908 
7909 
7910 #define VK_KHR_display_swapchain 1
7911 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10
7912 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
7913 typedef struct VkDisplayPresentInfoKHR {
7915  const void* pNext;
7918  VkBool32 persistent;
7920 
7921 typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
7922 
7923 #ifndef VK_NO_PROTOTYPES
7925  VkDevice device,
7926  uint32_t swapchainCount,
7927  const VkSwapchainCreateInfoKHR* pCreateInfos,
7928  const VkAllocationCallbacks* pAllocator,
7929  VkSwapchainKHR* pSwapchains);
7930 #endif
7931 
7932 
7933 #define VK_KHR_sampler_mirror_clamp_to_edge 1
7934 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3
7935 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
7936 
7937 
7938 #define VK_KHR_dynamic_rendering 1
7939 #define VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION 1
7940 #define VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME "VK_KHR_dynamic_rendering"
7941 typedef VkRenderingFlags VkRenderingFlagsKHR;
7942 
7944 
7946 
7948 
7950 
7952 
7954 
7957  const void* pNext;
7958  VkImageView imageView;
7962 
7965  const void* pNext;
7966  VkImageView imageView;
7969 
7972  const void* pNext;
7977 
7979 
7982  const void* pNext;
7986 
7987 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo);
7988 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer);
7989 
7990 #ifndef VK_NO_PROTOTYPES
7992  VkCommandBuffer commandBuffer,
7993  const VkRenderingInfo* pRenderingInfo);
7994 
7996  VkCommandBuffer commandBuffer);
7997 #endif
7998 
7999 
8000 #define VK_KHR_multiview 1
8001 #define VK_KHR_MULTIVIEW_SPEC_VERSION 1
8002 #define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview"
8004 
8006 
8008 
8009 
8010 
8011 #define VK_KHR_get_physical_device_properties2 1
8012 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2
8013 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
8015 
8017 
8019 
8021 
8023 
8025 
8027 
8029 
8031 
8032 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
8033 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
8034 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
8035 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
8036 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
8037 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
8038 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
8039 
8040 #ifndef VK_NO_PROTOTYPES
8042  VkPhysicalDevice physicalDevice,
8043  VkPhysicalDeviceFeatures2* pFeatures);
8044 
8046  VkPhysicalDevice physicalDevice,
8047  VkPhysicalDeviceProperties2* pProperties);
8048 
8050  VkPhysicalDevice physicalDevice,
8051  VkFormat format,
8052  VkFormatProperties2* pFormatProperties);
8053 
8055  VkPhysicalDevice physicalDevice,
8056  const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
8057  VkImageFormatProperties2* pImageFormatProperties);
8058 
8060  VkPhysicalDevice physicalDevice,
8061  uint32_t* pQueueFamilyPropertyCount,
8062  VkQueueFamilyProperties2* pQueueFamilyProperties);
8063 
8065  VkPhysicalDevice physicalDevice,
8066  VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
8067 
8069  VkPhysicalDevice physicalDevice,
8070  const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
8071  uint32_t* pPropertyCount,
8072  VkSparseImageFormatProperties2* pProperties);
8073 #endif
8074 
8075 
8076 #define VK_KHR_device_group 1
8077 #define VK_KHR_DEVICE_GROUP_SPEC_VERSION 4
8078 #define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"
8079 typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
8080 
8082 
8083 typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;
8084 
8086 
8088 
8090 
8092 
8094 
8096 
8098 
8100 
8101 typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
8102 typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
8103 typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
8104 
8105 #ifndef VK_NO_PROTOTYPES
8107  VkDevice device,
8108  uint32_t heapIndex,
8109  uint32_t localDeviceIndex,
8110  uint32_t remoteDeviceIndex,
8111  VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
8112 
8114  VkCommandBuffer commandBuffer,
8115  uint32_t deviceMask);
8116 
8118  VkCommandBuffer commandBuffer,
8119  uint32_t baseGroupX,
8120  uint32_t baseGroupY,
8121  uint32_t baseGroupZ,
8122  uint32_t groupCountX,
8123  uint32_t groupCountY,
8124  uint32_t groupCountZ);
8125 #endif
8126 
8127 
8128 #define VK_KHR_shader_draw_parameters 1
8129 #define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
8130 #define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
8131 
8132 
8133 #define VK_KHR_maintenance1 1
8134 #define VK_KHR_MAINTENANCE_1_SPEC_VERSION 2
8135 #define VK_KHR_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_maintenance1"
8136 #define VK_KHR_MAINTENANCE1_SPEC_VERSION VK_KHR_MAINTENANCE_1_SPEC_VERSION
8137 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME VK_KHR_MAINTENANCE_1_EXTENSION_NAME
8138 typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;
8139 
8140 typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
8141 
8142 #ifndef VK_NO_PROTOTYPES
8144  VkDevice device,
8145  VkCommandPool commandPool,
8146  VkCommandPoolTrimFlags flags);
8147 #endif
8148 
8149 
8150 #define VK_KHR_device_group_creation 1
8151 #define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1
8152 #define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation"
8153 #define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE
8155 
8157 
8158 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
8159 
8160 #ifndef VK_NO_PROTOTYPES
8162  VkInstance instance,
8163  uint32_t* pPhysicalDeviceGroupCount,
8164  VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
8165 #endif
8166 
8167 
8168 #define VK_KHR_external_memory_capabilities 1
8169 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
8170 #define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
8171 #define VK_LUID_SIZE_KHR VK_LUID_SIZE
8172 typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;
8173 
8175 
8176 typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;
8177 
8179 
8181 
8183 
8185 
8187 
8189 
8191 
8192 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
8193 
8194 #ifndef VK_NO_PROTOTYPES
8196  VkPhysicalDevice physicalDevice,
8197  const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
8198  VkExternalBufferProperties* pExternalBufferProperties);
8199 #endif
8200 
8201 
8202 #define VK_KHR_external_memory 1
8203 #define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
8204 #define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
8205 #define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL
8207 
8209 
8211 
8212 
8213 
8214 #define VK_KHR_external_memory_fd 1
8215 #define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
8216 #define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
8217 typedef struct VkImportMemoryFdInfoKHR {
8219  const void* pNext;
8221  int fd;
8223 
8224 typedef struct VkMemoryFdPropertiesKHR {
8226  void* pNext;
8227  uint32_t memoryTypeBits;
8229 
8230 typedef struct VkMemoryGetFdInfoKHR {
8232  const void* pNext;
8233  VkDeviceMemory memory;
8236 
8237 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
8239 
8240 #ifndef VK_NO_PROTOTYPES
8242  VkDevice device,
8243  const VkMemoryGetFdInfoKHR* pGetFdInfo,
8244  int* pFd);
8245 
8247  VkDevice device,
8249  int fd,
8250  VkMemoryFdPropertiesKHR* pMemoryFdProperties);
8251 #endif
8252 
8253 
8254 #define VK_KHR_external_semaphore_capabilities 1
8255 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
8256 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
8257 typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR;
8258 
8260 
8261 typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;
8262 
8264 
8266 
8268 
8269 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
8270 
8271 #ifndef VK_NO_PROTOTYPES
8273  VkPhysicalDevice physicalDevice,
8274  const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
8275  VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
8276 #endif
8277 
8278 
8279 #define VK_KHR_external_semaphore 1
8280 #define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
8281 #define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
8282 typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;
8283 
8285 
8287 
8288 
8289 
8290 #define VK_KHR_external_semaphore_fd 1
8291 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
8292 #define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
8295  const void* pNext;
8296  VkSemaphore semaphore;
8297  VkSemaphoreImportFlags flags;
8299  int fd;
8301 
8302 typedef struct VkSemaphoreGetFdInfoKHR {
8304  const void* pNext;
8305  VkSemaphore semaphore;
8308 
8309 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
8310 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
8311 
8312 #ifndef VK_NO_PROTOTYPES
8314  VkDevice device,
8315  const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
8316 
8318  VkDevice device,
8319  const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
8320  int* pFd);
8321 #endif
8322 
8323 
8324 #define VK_KHR_push_descriptor 1
8325 #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2
8326 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
8329  void* pNext;
8332 
8333 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
8334 typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
8335 
8336 #ifndef VK_NO_PROTOTYPES
8338  VkCommandBuffer commandBuffer,
8339  VkPipelineBindPoint pipelineBindPoint,
8340  VkPipelineLayout layout,
8341  uint32_t set,
8342  uint32_t descriptorWriteCount,
8343  const VkWriteDescriptorSet* pDescriptorWrites);
8344 
8346  VkCommandBuffer commandBuffer,
8347  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
8348  VkPipelineLayout layout,
8349  uint32_t set,
8350  const void* pData);
8351 #endif
8352 
8353 
8354 #define VK_KHR_shader_float16_int8 1
8355 #define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1
8356 #define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
8358 
8360 
8361 
8362 
8363 #define VK_KHR_16bit_storage 1
8364 #define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
8365 #define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
8367 
8368 
8369 
8370 #define VK_KHR_incremental_present 1
8371 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2
8372 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
8373 typedef struct VkRectLayerKHR {
8376  uint32_t layer;
8377 } VkRectLayerKHR;
8378 
8379 typedef struct VkPresentRegionKHR {
8380  uint32_t rectangleCount;
8383 
8384 typedef struct VkPresentRegionsKHR {
8386  const void* pNext;
8387  uint32_t swapchainCount;
8390 
8391 
8392 
8393 #define VK_KHR_descriptor_update_template 1
8394 typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;
8395 
8396 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
8397 #define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
8399 
8400 typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
8401 
8403 
8405 
8406 typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
8407 typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
8408 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
8409 
8410 #ifndef VK_NO_PROTOTYPES
8412  VkDevice device,
8413  const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
8414  const VkAllocationCallbacks* pAllocator,
8415  VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
8416 
8418  VkDevice device,
8419  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
8420  const VkAllocationCallbacks* pAllocator);
8421 
8423  VkDevice device,
8424  VkDescriptorSet descriptorSet,
8425  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
8426  const void* pData);
8427 #endif
8428 
8429 
8430 #define VK_KHR_imageless_framebuffer 1
8431 #define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1
8432 #define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer"
8434 
8436 
8438 
8440 
8441 
8442 
8443 #define VK_KHR_create_renderpass2 1
8444 #define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1
8445 #define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2"
8447 
8449 
8451 
8453 
8455 
8457 
8459 
8460 typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
8461 typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo);
8462 typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo);
8463 typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo);
8464 
8465 #ifndef VK_NO_PROTOTYPES
8467  VkDevice device,
8468  const VkRenderPassCreateInfo2* pCreateInfo,
8469  const VkAllocationCallbacks* pAllocator,
8470  VkRenderPass* pRenderPass);
8471 
8473  VkCommandBuffer commandBuffer,
8474  const VkRenderPassBeginInfo* pRenderPassBegin,
8475  const VkSubpassBeginInfo* pSubpassBeginInfo);
8476 
8478  VkCommandBuffer commandBuffer,
8479  const VkSubpassBeginInfo* pSubpassBeginInfo,
8480  const VkSubpassEndInfo* pSubpassEndInfo);
8481 
8483  VkCommandBuffer commandBuffer,
8484  const VkSubpassEndInfo* pSubpassEndInfo);
8485 #endif
8486 
8487 
8488 #define VK_KHR_shared_presentable_image 1
8489 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
8490 #define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
8493  void* pNext;
8496 
8497 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
8498 
8499 #ifndef VK_NO_PROTOTYPES
8501  VkDevice device,
8502  VkSwapchainKHR swapchain);
8503 #endif
8504 
8505 
8506 #define VK_KHR_external_fence_capabilities 1
8507 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
8508 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
8509 typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;
8510 
8512 
8513 typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;
8514 
8516 
8518 
8520 
8521 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
8522 
8523 #ifndef VK_NO_PROTOTYPES
8525  VkPhysicalDevice physicalDevice,
8526  const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
8527  VkExternalFenceProperties* pExternalFenceProperties);
8528 #endif
8529 
8530 
8531 #define VK_KHR_external_fence 1
8532 #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
8533 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
8534 typedef VkFenceImportFlags VkFenceImportFlagsKHR;
8535 
8537 
8539 
8540 
8541 
8542 #define VK_KHR_external_fence_fd 1
8543 #define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
8544 #define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
8545 typedef struct VkImportFenceFdInfoKHR {
8547  const void* pNext;
8548  VkFence fence;
8549  VkFenceImportFlags flags;
8551  int fd;
8553 
8554 typedef struct VkFenceGetFdInfoKHR {
8556  const void* pNext;
8557  VkFence fence;
8560 
8561 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
8562 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
8563 
8564 #ifndef VK_NO_PROTOTYPES
8566  VkDevice device,
8567  const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
8568 
8570  VkDevice device,
8571  const VkFenceGetFdInfoKHR* pGetFdInfo,
8572  int* pFd);
8573 #endif
8574 
8575 
8576 #define VK_KHR_performance_query 1
8577 #define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1
8578 #define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query"
8579 
8594 
8604 
8614 
8623 
8630  void* pNext;
8634 
8637  void* pNext;
8640 
8641 typedef struct VkPerformanceCounterKHR {
8643  void* pNext;
8647  uint8_t uuid[VK_UUID_SIZE];
8649 
8652  void* pNext;
8653  VkPerformanceCounterDescriptionFlagsKHR flags;
8658 
8661  const void* pNext;
8664  const uint32_t* pCounterIndices;
8666 
8668  int32_t int32;
8669  int64_t int64;
8670  uint32_t uint32;
8671  uint64_t uint64;
8672  float float32;
8673  double float64;
8675 
8678  const void* pNext;
8679  VkAcquireProfilingLockFlagsKHR flags;
8680  uint64_t timeout;
8682 
8685  const void* pNext;
8688 
8689 typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
8690 typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses);
8692 typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device);
8693 
8694 #ifndef VK_NO_PROTOTYPES
8696  VkPhysicalDevice physicalDevice,
8697  uint32_t queueFamilyIndex,
8698  uint32_t* pCounterCount,
8699  VkPerformanceCounterKHR* pCounters,
8700  VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
8701 
8703  VkPhysicalDevice physicalDevice,
8704  const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
8705  uint32_t* pNumPasses);
8706 
8708  VkDevice device,
8709  const VkAcquireProfilingLockInfoKHR* pInfo);
8710 
8712  VkDevice device);
8713 #endif
8714 
8715 
8716 #define VK_KHR_maintenance2 1
8717 #define VK_KHR_MAINTENANCE_2_SPEC_VERSION 1
8718 #define VK_KHR_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_maintenance2"
8719 #define VK_KHR_MAINTENANCE2_SPEC_VERSION VK_KHR_MAINTENANCE_2_SPEC_VERSION
8720 #define VK_KHR_MAINTENANCE2_EXTENSION_NAME VK_KHR_MAINTENANCE_2_EXTENSION_NAME
8722 
8724 
8726 
8728 
8730 
8732 
8734 
8735 
8736 
8737 #define VK_KHR_get_surface_capabilities2 1
8738 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
8739 #define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
8742  const void* pNext;
8743  VkSurfaceKHR surface;
8745 
8748  void* pNext;
8751 
8752 typedef struct VkSurfaceFormat2KHR {
8754  void* pNext;
8757 
8758 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
8759 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
8760 
8761 #ifndef VK_NO_PROTOTYPES
8763  VkPhysicalDevice physicalDevice,
8764  const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
8765  VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
8766 
8768  VkPhysicalDevice physicalDevice,
8769  const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
8770  uint32_t* pSurfaceFormatCount,
8771  VkSurfaceFormat2KHR* pSurfaceFormats);
8772 #endif
8773 
8774 
8775 #define VK_KHR_variable_pointers 1
8776 #define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
8777 #define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
8779 
8781 
8782 
8783 
8784 #define VK_KHR_get_display_properties2 1
8785 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1
8786 #define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2"
8787 typedef struct VkDisplayProperties2KHR {
8789  void* pNext;
8792 
8795  void* pNext;
8798 
8801  void* pNext;
8804 
8805 typedef struct VkDisplayPlaneInfo2KHR {
8807  const void* pNext;
8808  VkDisplayModeKHR mode;
8809  uint32_t planeIndex;
8811 
8814  void* pNext;
8817 
8818 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties);
8819 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties);
8820 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties);
8821 typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities);
8822 
8823 #ifndef VK_NO_PROTOTYPES
8825  VkPhysicalDevice physicalDevice,
8826  uint32_t* pPropertyCount,
8827  VkDisplayProperties2KHR* pProperties);
8828 
8830  VkPhysicalDevice physicalDevice,
8831  uint32_t* pPropertyCount,
8832  VkDisplayPlaneProperties2KHR* pProperties);
8833 
8835  VkPhysicalDevice physicalDevice,
8836  VkDisplayKHR display,
8837  uint32_t* pPropertyCount,
8838  VkDisplayModeProperties2KHR* pProperties);
8839 
8841  VkPhysicalDevice physicalDevice,
8842  const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
8843  VkDisplayPlaneCapabilities2KHR* pCapabilities);
8844 #endif
8845 
8846 
8847 #define VK_KHR_dedicated_allocation 1
8848 #define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
8849 #define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
8851 
8853 
8854 
8855 
8856 #define VK_KHR_storage_buffer_storage_class 1
8857 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
8858 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
8859 
8860 
8861 #define VK_KHR_relaxed_block_layout 1
8862 #define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
8863 #define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"
8864 
8865 
8866 #define VK_KHR_get_memory_requirements2 1
8867 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
8868 #define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
8870 
8872 
8874 
8876 
8878 
8879 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
8881 typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
8882 
8883 #ifndef VK_NO_PROTOTYPES
8885  VkDevice device,
8886  const VkImageMemoryRequirementsInfo2* pInfo,
8887  VkMemoryRequirements2* pMemoryRequirements);
8888 
8890  VkDevice device,
8891  const VkBufferMemoryRequirementsInfo2* pInfo,
8892  VkMemoryRequirements2* pMemoryRequirements);
8893 
8895  VkDevice device,
8897  uint32_t* pSparseMemoryRequirementCount,
8898  VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
8899 #endif
8900 
8901 
8902 #define VK_KHR_image_format_list 1
8903 #define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
8904 #define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"
8906 
8907 
8908 
8909 #define VK_KHR_sampler_ycbcr_conversion 1
8910 typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;
8911 
8912 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14
8913 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
8915 
8917 
8919 
8921 
8923 
8925 
8927 
8929 
8931 
8932 typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
8933 typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
8934 
8935 #ifndef VK_NO_PROTOTYPES
8937  VkDevice device,
8938  const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
8939  const VkAllocationCallbacks* pAllocator,
8940  VkSamplerYcbcrConversion* pYcbcrConversion);
8941 
8943  VkDevice device,
8944  VkSamplerYcbcrConversion ycbcrConversion,
8945  const VkAllocationCallbacks* pAllocator);
8946 #endif
8947 
8948 
8949 #define VK_KHR_bind_memory2 1
8950 #define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1
8951 #define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2"
8953 
8955 
8956 typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
8957 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
8958 
8959 #ifndef VK_NO_PROTOTYPES
8961  VkDevice device,
8962  uint32_t bindInfoCount,
8963  const VkBindBufferMemoryInfo* pBindInfos);
8964 
8966  VkDevice device,
8967  uint32_t bindInfoCount,
8968  const VkBindImageMemoryInfo* pBindInfos);
8969 #endif
8970 
8971 
8972 #define VK_KHR_maintenance3 1
8973 #define VK_KHR_MAINTENANCE_3_SPEC_VERSION 1
8974 #define VK_KHR_MAINTENANCE_3_EXTENSION_NAME "VK_KHR_maintenance3"
8975 #define VK_KHR_MAINTENANCE3_SPEC_VERSION VK_KHR_MAINTENANCE_3_SPEC_VERSION
8976 #define VK_KHR_MAINTENANCE3_EXTENSION_NAME VK_KHR_MAINTENANCE_3_EXTENSION_NAME
8978 
8980 
8982 
8983 #ifndef VK_NO_PROTOTYPES
8985  VkDevice device,
8986  const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
8987  VkDescriptorSetLayoutSupport* pSupport);
8988 #endif
8989 
8990 
8991 #define VK_KHR_draw_indirect_count 1
8992 #define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
8993 #define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count"
8994 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
8995 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
8996 
8997 #ifndef VK_NO_PROTOTYPES
8999  VkCommandBuffer commandBuffer,
9000  VkBuffer buffer,
9001  VkDeviceSize offset,
9002  VkBuffer countBuffer,
9003  VkDeviceSize countBufferOffset,
9004  uint32_t maxDrawCount,
9005  uint32_t stride);
9006 
9008  VkCommandBuffer commandBuffer,
9009  VkBuffer buffer,
9010  VkDeviceSize offset,
9011  VkBuffer countBuffer,
9012  VkDeviceSize countBufferOffset,
9013  uint32_t maxDrawCount,
9014  uint32_t stride);
9015 #endif
9016 
9017 
9018 #define VK_KHR_shader_subgroup_extended_types 1
9019 #define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1
9020 #define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types"
9022 
9023 
9024 
9025 #define VK_KHR_8bit_storage 1
9026 #define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1
9027 #define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
9029 
9030 
9031 
9032 #define VK_KHR_shader_atomic_int64 1
9033 #define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1
9034 #define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"
9036 
9037 
9038 
9039 #define VK_KHR_shader_clock 1
9040 #define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1
9041 #define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"
9044  void* pNext;
9048 
9049 
9050 
9051 #define VK_KHR_global_priority 1
9052 #define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR 16U
9053 #define VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION 1
9054 #define VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME "VK_KHR_global_priority"
9055 
9069  const void* pNext;
9072 
9075  void* pNext;
9078 
9081  void* pNext;
9082  uint32_t priorityCount;
9085 
9086 
9087 
9088 #define VK_KHR_driver_properties 1
9089 #define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1
9090 #define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties"
9091 #define VK_MAX_DRIVER_NAME_SIZE_KHR VK_MAX_DRIVER_NAME_SIZE
9092 #define VK_MAX_DRIVER_INFO_SIZE_KHR VK_MAX_DRIVER_INFO_SIZE
9094 
9096 
9098 
9099 
9100 
9101 #define VK_KHR_shader_float_controls 1
9102 #define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4
9103 #define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls"
9105 
9107 
9108 
9109 
9110 #define VK_KHR_depth_stencil_resolve 1
9111 #define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1
9112 #define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve"
9114 
9115 typedef VkResolveModeFlags VkResolveModeFlagsKHR;
9116 
9118 
9120 
9121 
9122 
9123 #define VK_KHR_swapchain_mutable_format 1
9124 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1
9125 #define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format"
9126 
9127 
9128 #define VK_KHR_timeline_semaphore 1
9129 #define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2
9130 #define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore"
9132 
9134 
9135 typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR;
9136 
9138 
9140 
9142 
9144 
9146 
9148 
9149 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);
9150 typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);
9151 typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);
9152 
9153 #ifndef VK_NO_PROTOTYPES
9155  VkDevice device,
9156  VkSemaphore semaphore,
9157  uint64_t* pValue);
9158 
9160  VkDevice device,
9161  const VkSemaphoreWaitInfo* pWaitInfo,
9162  uint64_t timeout);
9163 
9165  VkDevice device,
9166  const VkSemaphoreSignalInfo* pSignalInfo);
9167 #endif
9168 
9169 
9170 #define VK_KHR_vulkan_memory_model 1
9171 #define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3
9172 #define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model"
9174 
9175 
9176 
9177 #define VK_KHR_shader_terminate_invocation 1
9178 #define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1
9179 #define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation"
9181 
9182 
9183 
9184 #define VK_KHR_fragment_shading_rate 1
9185 #define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 2
9186 #define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate"
9187 
9198  const void* pNext;
9202 
9205  const void* pNext;
9209 
9212  void* pNext;
9217 
9220  void* pNext;
9239 
9242  void* pNext;
9243  VkSampleCountFlags sampleCounts;
9246 
9247 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);
9248 typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
9249 
9250 #ifndef VK_NO_PROTOTYPES
9252  VkPhysicalDevice physicalDevice,
9253  uint32_t* pFragmentShadingRateCount,
9254  VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);
9255 
9257  VkCommandBuffer commandBuffer,
9258  const VkExtent2D* pFragmentSize,
9259  const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
9260 #endif
9261 
9262 
9263 #define VK_KHR_spirv_1_4 1
9264 #define VK_KHR_SPIRV_1_4_SPEC_VERSION 1
9265 #define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4"
9266 
9267 
9268 #define VK_KHR_surface_protected_capabilities 1
9269 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1
9270 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities"
9273  const void* pNext;
9276 
9277 
9278 
9279 #define VK_KHR_separate_depth_stencil_layouts 1
9280 #define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1
9281 #define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts"
9283 
9285 
9287 
9288 
9289 
9290 #define VK_KHR_present_wait 1
9291 #define VK_KHR_PRESENT_WAIT_SPEC_VERSION 1
9292 #define VK_KHR_PRESENT_WAIT_EXTENSION_NAME "VK_KHR_present_wait"
9295  void* pNext;
9296  VkBool32 presentWait;
9298 
9299 typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout);
9300 
9301 #ifndef VK_NO_PROTOTYPES
9303  VkDevice device,
9304  VkSwapchainKHR swapchain,
9305  uint64_t presentId,
9306  uint64_t timeout);
9307 #endif
9308 
9309 
9310 #define VK_KHR_uniform_buffer_standard_layout 1
9311 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
9312 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout"
9314 
9315 
9316 
9317 #define VK_KHR_buffer_device_address 1
9318 #define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1
9319 #define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address"
9321 
9323 
9325 
9327 
9329 
9331 typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);
9333 
9334 #ifndef VK_NO_PROTOTYPES
9336  VkDevice device,
9337  const VkBufferDeviceAddressInfo* pInfo);
9338 
9340  VkDevice device,
9341  const VkBufferDeviceAddressInfo* pInfo);
9342 
9344  VkDevice device,
9346 #endif
9347 
9348 
9349 #define VK_KHR_deferred_host_operations 1
9350 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR)
9351 #define VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION 4
9352 #define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations"
9353 typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation);
9354 typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator);
9355 typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation);
9356 typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation);
9357 typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation);
9358 
9359 #ifndef VK_NO_PROTOTYPES
9361  VkDevice device,
9362  const VkAllocationCallbacks* pAllocator,
9363  VkDeferredOperationKHR* pDeferredOperation);
9364 
9366  VkDevice device,
9367  VkDeferredOperationKHR operation,
9368  const VkAllocationCallbacks* pAllocator);
9369 
9371  VkDevice device,
9372  VkDeferredOperationKHR operation);
9373 
9375  VkDevice device,
9376  VkDeferredOperationKHR operation);
9377 
9379  VkDevice device,
9380  VkDeferredOperationKHR operation);
9381 #endif
9382 
9383 
9384 #define VK_KHR_pipeline_executable_properties 1
9385 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
9386 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
9387 
9397  void* pNext;
9400 
9401 typedef struct VkPipelineInfoKHR {
9403  const void* pNext;
9404  VkPipeline pipeline;
9406 
9409  void* pNext;
9410  VkShaderStageFlags stages;
9413  uint32_t subgroupSize;
9415 
9418  const void* pNext;
9419  VkPipeline pipeline;
9422 
9424  VkBool32 b32;
9425  int64_t i64;
9426  uint64_t u64;
9427  double f64;
9429 
9432  void* pNext;
9438 
9441  void* pNext;
9444  VkBool32 isText;
9445  size_t dataSize;
9446  void* pData;
9448 
9449 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
9450 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
9451 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
9452 
9453 #ifndef VK_NO_PROTOTYPES
9455  VkDevice device,
9456  const VkPipelineInfoKHR* pPipelineInfo,
9457  uint32_t* pExecutableCount,
9458  VkPipelineExecutablePropertiesKHR* pProperties);
9459 
9461  VkDevice device,
9462  const VkPipelineExecutableInfoKHR* pExecutableInfo,
9463  uint32_t* pStatisticCount,
9464  VkPipelineExecutableStatisticKHR* pStatistics);
9465 
9467  VkDevice device,
9468  const VkPipelineExecutableInfoKHR* pExecutableInfo,
9469  uint32_t* pInternalRepresentationCount,
9470  VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
9471 #endif
9472 
9473 
9474 #define VK_KHR_shader_integer_dot_product 1
9475 #define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION 1
9476 #define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME "VK_KHR_shader_integer_dot_product"
9478 
9480 
9481 
9482 
9483 #define VK_KHR_pipeline_library 1
9484 #define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1
9485 #define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library"
9488  const void* pNext;
9489  uint32_t libraryCount;
9490  const VkPipeline* pLibraries;
9492 
9493 
9494 
9495 #define VK_KHR_shader_non_semantic_info 1
9496 #define VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION 1
9497 #define VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME "VK_KHR_shader_non_semantic_info"
9498 
9499 
9500 #define VK_KHR_present_id 1
9501 #define VK_KHR_PRESENT_ID_SPEC_VERSION 1
9502 #define VK_KHR_PRESENT_ID_EXTENSION_NAME "VK_KHR_present_id"
9503 typedef struct VkPresentIdKHR {
9505  const void* pNext;
9506  uint32_t swapchainCount;
9507  const uint64_t* pPresentIds;
9508 } VkPresentIdKHR;
9509 
9512  void* pNext;
9513  VkBool32 presentId;
9515 
9516 
9517 
9518 #define VK_KHR_synchronization2 1
9519 #define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1
9520 #define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2"
9521 typedef VkPipelineStageFlags2 VkPipelineStageFlags2KHR;
9522 
9523 typedef VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR;
9524 
9525 typedef VkAccessFlags2 VkAccessFlags2KHR;
9526 
9527 typedef VkAccessFlagBits2 VkAccessFlagBits2KHR;
9528 
9530 
9531 typedef VkSubmitFlags VkSubmitFlagsKHR;
9532 
9534 
9536 
9538 
9540 
9542 
9544 
9546 
9548 
9551  void* pNext;
9552  VkPipelineStageFlags2 checkpointExecutionStageMask;
9554 
9555 typedef struct VkCheckpointData2NV {
9557  void* pNext;
9558  VkPipelineStageFlags2 stage;
9561 
9562 typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo);
9563 typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask);
9564 typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos);
9565 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo);
9566 typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query);
9567 typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
9568 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
9569 typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData);
9570 
9571 #ifndef VK_NO_PROTOTYPES
9573  VkCommandBuffer commandBuffer,
9574  VkEvent event,
9575  const VkDependencyInfo* pDependencyInfo);
9576 
9578  VkCommandBuffer commandBuffer,
9579  VkEvent event,
9580  VkPipelineStageFlags2 stageMask);
9581 
9583  VkCommandBuffer commandBuffer,
9584  uint32_t eventCount,
9585  const VkEvent* pEvents,
9586  const VkDependencyInfo* pDependencyInfos);
9587 
9589  VkCommandBuffer commandBuffer,
9590  const VkDependencyInfo* pDependencyInfo);
9591 
9593  VkCommandBuffer commandBuffer,
9594  VkPipelineStageFlags2 stage,
9595  VkQueryPool queryPool,
9596  uint32_t query);
9597 
9599  VkQueue queue,
9600  uint32_t submitCount,
9601  const VkSubmitInfo2* pSubmits,
9602  VkFence fence);
9603 
9605  VkCommandBuffer commandBuffer,
9606  VkPipelineStageFlags2 stage,
9607  VkBuffer dstBuffer,
9608  VkDeviceSize dstOffset,
9609  uint32_t marker);
9610 
9612  VkQueue queue,
9613  uint32_t* pCheckpointDataCount,
9614  VkCheckpointData2NV* pCheckpointData);
9615 #endif
9616 
9617 
9618 #define VK_KHR_fragment_shader_barycentric 1
9619 #define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1
9620 #define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_KHR_fragment_shader_barycentric"
9623  void* pNext;
9626 
9629  void* pNext;
9632 
9633 
9634 
9635 #define VK_KHR_shader_subgroup_uniform_control_flow 1
9636 #define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION 1
9637 #define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME "VK_KHR_shader_subgroup_uniform_control_flow"
9640  void* pNext;
9643 
9644 
9645 
9646 #define VK_KHR_zero_initialize_workgroup_memory 1
9647 #define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION 1
9648 #define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME "VK_KHR_zero_initialize_workgroup_memory"
9650 
9651 
9652 
9653 #define VK_KHR_workgroup_memory_explicit_layout 1
9654 #define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION 1
9655 #define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME "VK_KHR_workgroup_memory_explicit_layout"
9658  void* pNext;
9664 
9665 
9666 
9667 #define VK_KHR_copy_commands2 1
9668 #define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1
9669 #define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2"
9671 
9673 
9675 
9677 
9679 
9681 
9683 
9685 
9687 
9689 
9691 
9692 typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo);
9693 typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo);
9694 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
9695 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
9696 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo);
9697 typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo);
9698 
9699 #ifndef VK_NO_PROTOTYPES
9701  VkCommandBuffer commandBuffer,
9702  const VkCopyBufferInfo2* pCopyBufferInfo);
9703 
9705  VkCommandBuffer commandBuffer,
9706  const VkCopyImageInfo2* pCopyImageInfo);
9707 
9709  VkCommandBuffer commandBuffer,
9710  const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
9711 
9713  VkCommandBuffer commandBuffer,
9714  const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
9715 
9717  VkCommandBuffer commandBuffer,
9718  const VkBlitImageInfo2* pBlitImageInfo);
9719 
9721  VkCommandBuffer commandBuffer,
9722  const VkResolveImageInfo2* pResolveImageInfo);
9723 #endif
9724 
9725 
9726 #define VK_KHR_format_feature_flags2 1
9727 #define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 2
9728 #define VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME "VK_KHR_format_feature_flags2"
9729 typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR;
9730 
9731 typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR;
9732 
9734 
9735 
9736 
9737 #define VK_KHR_ray_tracing_maintenance1 1
9738 #define VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION 1
9739 #define VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_ray_tracing_maintenance1"
9742  void* pNext;
9746 
9748  VkDeviceAddress raygenShaderRecordAddress;
9759  uint32_t width;
9760  uint32_t height;
9761  uint32_t depth;
9763 
9764 typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress);
9765 
9766 #ifndef VK_NO_PROTOTYPES
9768  VkCommandBuffer commandBuffer,
9769  VkDeviceAddress indirectDeviceAddress);
9770 #endif
9771 
9772 
9773 #define VK_KHR_portability_enumeration 1
9774 #define VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION 1
9775 #define VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME "VK_KHR_portability_enumeration"
9776 
9777 
9778 #define VK_KHR_maintenance4 1
9779 #define VK_KHR_MAINTENANCE_4_SPEC_VERSION 2
9780 #define VK_KHR_MAINTENANCE_4_EXTENSION_NAME "VK_KHR_maintenance4"
9782 
9784 
9786 
9788 
9791 typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
9792 
9793 #ifndef VK_NO_PROTOTYPES
9795  VkDevice device,
9796  const VkDeviceBufferMemoryRequirements* pInfo,
9797  VkMemoryRequirements2* pMemoryRequirements);
9798 
9800  VkDevice device,
9801  const VkDeviceImageMemoryRequirements* pInfo,
9802  VkMemoryRequirements2* pMemoryRequirements);
9803 
9805  VkDevice device,
9806  const VkDeviceImageMemoryRequirements* pInfo,
9807  uint32_t* pSparseMemoryRequirementCount,
9808  VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
9809 #endif
9810 
9811 
9812 #define VK_EXT_debug_report 1
9813 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
9814 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION 10
9815 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
9816 
9863 
9872 typedef VkFlags VkDebugReportFlagsEXT;
9874  VkDebugReportFlagsEXT flags,
9875  VkDebugReportObjectTypeEXT objectType,
9876  uint64_t object,
9877  size_t location,
9878  int32_t messageCode,
9879  const char* pLayerPrefix,
9880  const char* pMessage,
9881  void* pUserData);
9882 
9885  const void* pNext;
9886  VkDebugReportFlagsEXT flags;
9888  void* pUserData;
9890 
9891 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
9892 typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
9893 typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
9894 
9895 #ifndef VK_NO_PROTOTYPES
9897  VkInstance instance,
9898  const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
9899  const VkAllocationCallbacks* pAllocator,
9900  VkDebugReportCallbackEXT* pCallback);
9901 
9903  VkInstance instance,
9904  VkDebugReportCallbackEXT callback,
9905  const VkAllocationCallbacks* pAllocator);
9906 
9908  VkInstance instance,
9909  VkDebugReportFlagsEXT flags,
9910  VkDebugReportObjectTypeEXT objectType,
9911  uint64_t object,
9912  size_t location,
9913  int32_t messageCode,
9914  const char* pLayerPrefix,
9915  const char* pMessage);
9916 #endif
9917 
9918 
9919 #define VK_NV_glsl_shader 1
9920 #define VK_NV_GLSL_SHADER_SPEC_VERSION 1
9921 #define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader"
9922 
9923 
9924 #define VK_EXT_depth_range_unrestricted 1
9925 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
9926 #define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"
9927 
9928 
9929 #define VK_IMG_filter_cubic 1
9930 #define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1
9931 #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
9932 
9933 
9934 #define VK_AMD_rasterization_order 1
9935 #define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
9936 #define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
9937 
9945  const void* pNext;
9948 
9949 
9950 
9951 #define VK_AMD_shader_trinary_minmax 1
9952 #define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
9953 #define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
9954 
9955 
9956 #define VK_AMD_shader_explicit_vertex_parameter 1
9957 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
9958 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
9959 
9960 
9961 #define VK_EXT_debug_marker 1
9962 #define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4
9963 #define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
9966  const void* pNext;
9968  uint64_t object;
9969  const char* pObjectName;
9971 
9974  const void* pNext;
9976  uint64_t object;
9977  uint64_t tagName;
9978  size_t tagSize;
9979  const void* pTag;
9981 
9984  const void* pNext;
9985  const char* pMarkerName;
9986  float color[4];
9988 
9991 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
9992 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
9993 typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
9994 
9995 #ifndef VK_NO_PROTOTYPES
9997  VkDevice device,
9998  const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
9999 
10001  VkDevice device,
10002  const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
10003 
10005  VkCommandBuffer commandBuffer,
10006  const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
10007 
10009  VkCommandBuffer commandBuffer);
10010 
10012  VkCommandBuffer commandBuffer,
10013  const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
10014 #endif
10015 
10016 
10017 #define VK_AMD_gcn_shader 1
10018 #define VK_AMD_GCN_SHADER_SPEC_VERSION 1
10019 #define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader"
10020 
10021 
10022 #define VK_NV_dedicated_allocation 1
10023 #define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
10024 #define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
10027  const void* pNext;
10030 
10033  const void* pNext;
10036 
10039  const void* pNext;
10040  VkImage image;
10041  VkBuffer buffer;
10043 
10044 
10045 
10046 #define VK_EXT_transform_feedback 1
10047 #define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1
10048 #define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback"
10052  void* pNext;
10056 
10059  void* pNext;
10071 
10074  const void* pNext;
10075  VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
10078 
10079 typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes);
10080 typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
10081 typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);
10082 typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index);
10083 typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);
10084 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride);
10085 
10086 #ifndef VK_NO_PROTOTYPES
10088  VkCommandBuffer commandBuffer,
10089  uint32_t firstBinding,
10090  uint32_t bindingCount,
10091  const VkBuffer* pBuffers,
10092  const VkDeviceSize* pOffsets,
10093  const VkDeviceSize* pSizes);
10094 
10096  VkCommandBuffer commandBuffer,
10097  uint32_t firstCounterBuffer,
10098  uint32_t counterBufferCount,
10099  const VkBuffer* pCounterBuffers,
10100  const VkDeviceSize* pCounterBufferOffsets);
10101 
10103  VkCommandBuffer commandBuffer,
10104  uint32_t firstCounterBuffer,
10105  uint32_t counterBufferCount,
10106  const VkBuffer* pCounterBuffers,
10107  const VkDeviceSize* pCounterBufferOffsets);
10108 
10110  VkCommandBuffer commandBuffer,
10111  VkQueryPool queryPool,
10112  uint32_t query,
10113  VkQueryControlFlags flags,
10114  uint32_t index);
10115 
10117  VkCommandBuffer commandBuffer,
10118  VkQueryPool queryPool,
10119  uint32_t query,
10120  uint32_t index);
10121 
10123  VkCommandBuffer commandBuffer,
10124  uint32_t instanceCount,
10125  uint32_t firstInstance,
10126  VkBuffer counterBuffer,
10127  VkDeviceSize counterBufferOffset,
10128  uint32_t counterOffset,
10129  uint32_t vertexStride);
10130 #endif
10131 
10132 
10133 #define VK_NVX_binary_import 1
10134 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX)
10135 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX)
10136 #define VK_NVX_BINARY_IMPORT_SPEC_VERSION 1
10137 #define VK_NVX_BINARY_IMPORT_EXTENSION_NAME "VK_NVX_binary_import"
10138 typedef struct VkCuModuleCreateInfoNVX {
10140  const void* pNext;
10141  size_t dataSize;
10142  const void* pData;
10144 
10147  const void* pNext;
10148  VkCuModuleNVX module;
10149  const char* pName;
10151 
10152 typedef struct VkCuLaunchInfoNVX {
10154  const void* pNext;
10155  VkCuFunctionNVX function;
10156  uint32_t gridDimX;
10157  uint32_t gridDimY;
10158  uint32_t gridDimZ;
10159  uint32_t blockDimX;
10160  uint32_t blockDimY;
10161  uint32_t blockDimZ;
10162  uint32_t sharedMemBytes;
10163  size_t paramCount;
10164  const void* const * pParams;
10165  size_t extraCount;
10166  const void* const * pExtras;
10168 
10169 typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule);
10170 typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction);
10171 typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator);
10172 typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator);
10173 typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo);
10174 
10175 #ifndef VK_NO_PROTOTYPES
10177  VkDevice device,
10178  const VkCuModuleCreateInfoNVX* pCreateInfo,
10179  const VkAllocationCallbacks* pAllocator,
10180  VkCuModuleNVX* pModule);
10181 
10183  VkDevice device,
10184  const VkCuFunctionCreateInfoNVX* pCreateInfo,
10185  const VkAllocationCallbacks* pAllocator,
10186  VkCuFunctionNVX* pFunction);
10187 
10189  VkDevice device,
10190  VkCuModuleNVX module,
10191  const VkAllocationCallbacks* pAllocator);
10192 
10194  VkDevice device,
10195  VkCuFunctionNVX function,
10196  const VkAllocationCallbacks* pAllocator);
10197 
10199  VkCommandBuffer commandBuffer,
10200  const VkCuLaunchInfoNVX* pLaunchInfo);
10201 #endif
10202 
10203 
10204 #define VK_NVX_image_view_handle 1
10205 #define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 2
10206 #define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle"
10209  const void* pNext;
10210  VkImageView imageView;
10212  VkSampler sampler;
10214 
10217  void* pNext;
10218  VkDeviceAddress deviceAddress;
10219  VkDeviceSize size;
10221 
10222 typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);
10223 typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties);
10224 
10225 #ifndef VK_NO_PROTOTYPES
10227  VkDevice device,
10228  const VkImageViewHandleInfoNVX* pInfo);
10229 
10231  VkDevice device,
10232  VkImageView imageView,
10233  VkImageViewAddressPropertiesNVX* pProperties);
10234 #endif
10235 
10236 
10237 #define VK_AMD_draw_indirect_count 1
10238 #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2
10239 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
10240 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
10241 typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
10242 
10243 #ifndef VK_NO_PROTOTYPES
10245  VkCommandBuffer commandBuffer,
10246  VkBuffer buffer,
10247  VkDeviceSize offset,
10248  VkBuffer countBuffer,
10249  VkDeviceSize countBufferOffset,
10250  uint32_t maxDrawCount,
10251  uint32_t stride);
10252 
10254  VkCommandBuffer commandBuffer,
10255  VkBuffer buffer,
10256  VkDeviceSize offset,
10257  VkBuffer countBuffer,
10258  VkDeviceSize countBufferOffset,
10259  uint32_t maxDrawCount,
10260  uint32_t stride);
10261 #endif
10262 
10263 
10264 #define VK_AMD_negative_viewport_height 1
10265 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
10266 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
10267 
10268 
10269 #define VK_AMD_gpu_shader_half_float 1
10270 #define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2
10271 #define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
10272 
10273 
10274 #define VK_AMD_shader_ballot 1
10275 #define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
10276 #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
10277 
10278 
10279 #define VK_AMD_texture_gather_bias_lod 1
10280 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
10281 #define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"
10284  void* pNext;
10287 
10288 
10289 
10290 #define VK_AMD_shader_info 1
10291 #define VK_AMD_SHADER_INFO_SPEC_VERSION 1
10292 #define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"
10293 
10294 typedef enum VkShaderInfoTypeAMD {
10301  uint32_t numUsedVgprs;
10302  uint32_t numUsedSgprs;
10307 
10309  VkShaderStageFlags shaderStageMask;
10317 
10318 typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);
10319 
10320 #ifndef VK_NO_PROTOTYPES
10322  VkDevice device,
10323  VkPipeline pipeline,
10324  VkShaderStageFlagBits shaderStage,
10325  VkShaderInfoTypeAMD infoType,
10326  size_t* pInfoSize,
10327  void* pInfo);
10328 #endif
10329 
10330 
10331 #define VK_AMD_shader_image_load_store_lod 1
10332 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1
10333 #define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"
10334 
10335 
10336 #define VK_NV_corner_sampled_image 1
10337 #define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2
10338 #define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image"
10341  void* pNext;
10344 
10345 
10346 
10347 #define VK_IMG_format_pvrtc 1
10348 #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1
10349 #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
10350 
10351 
10352 #define VK_NV_external_memory_capabilities 1
10353 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
10354 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
10355 
10364 
10374  VkExternalMemoryFeatureFlagsNV externalMemoryFeatures;
10375  VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
10376  VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
10378 
10379 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
10380 
10381 #ifndef VK_NO_PROTOTYPES
10383  VkPhysicalDevice physicalDevice,
10384  VkFormat format,
10385  VkImageType type,
10386  VkImageTiling tiling,
10387  VkImageUsageFlags usage,
10388  VkImageCreateFlags flags,
10389  VkExternalMemoryHandleTypeFlagsNV externalHandleType,
10390  VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
10391 #endif
10392 
10393 
10394 #define VK_NV_external_memory 1
10395 #define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
10396 #define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
10399  const void* pNext;
10400  VkExternalMemoryHandleTypeFlagsNV handleTypes;
10402 
10405  const void* pNext;
10406  VkExternalMemoryHandleTypeFlagsNV handleTypes;
10408 
10409 
10410 
10411 #define VK_EXT_validation_flags 1
10412 #define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2
10413 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
10414 
10415 typedef enum VkValidationCheckEXT {
10420 typedef struct VkValidationFlagsEXT {
10422  const void* pNext;
10426 
10427 
10428 
10429 #define VK_EXT_shader_subgroup_ballot 1
10430 #define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
10431 #define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
10432 
10433 
10434 #define VK_EXT_shader_subgroup_vote 1
10435 #define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
10436 #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
10437 
10438 
10439 #define VK_EXT_texture_compression_astc_hdr 1
10440 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1
10441 #define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
10443 
10444 
10445 
10446 #define VK_EXT_astc_decode_mode 1
10447 #define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1
10448 #define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"
10451  const void* pNext;
10454 
10457  void* pNext;
10460 
10461 
10462 
10463 #define VK_EXT_pipeline_robustness 1
10464 #define VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION 1
10465 #define VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_pipeline_robustness"
10466 
10474 
10484  void* pNext;
10487 
10490  void* pNext;
10496 
10499  const void* pNext;
10505 
10506 
10507 
10508 #define VK_EXT_conditional_rendering 1
10509 #define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2
10510 #define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
10511 
10519  const void* pNext;
10520  VkBuffer buffer;
10521  VkDeviceSize offset;
10522  VkConditionalRenderingFlagsEXT flags;
10524 
10527  void* pNext;
10531 
10534  const void* pNext;
10537 
10538 typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
10539 typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer);
10540 
10541 #ifndef VK_NO_PROTOTYPES
10543  VkCommandBuffer commandBuffer,
10544  const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
10545 
10547  VkCommandBuffer commandBuffer);
10548 #endif
10549 
10550 
10551 #define VK_NV_clip_space_w_scaling 1
10552 #define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
10553 #define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
10554 typedef struct VkViewportWScalingNV {
10555  float xcoeff;
10556  float ycoeff;
10558 
10561  const void* pNext;
10563  uint32_t viewportCount;
10566 
10567 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
10568 
10569 #ifndef VK_NO_PROTOTYPES
10571  VkCommandBuffer commandBuffer,
10572  uint32_t firstViewport,
10573  uint32_t viewportCount,
10574  const VkViewportWScalingNV* pViewportWScalings);
10575 #endif
10576 
10577 
10578 #define VK_EXT_direct_mode_display 1
10579 #define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
10580 #define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
10581 typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
10582 
10583 #ifndef VK_NO_PROTOTYPES
10585  VkPhysicalDevice physicalDevice,
10586  VkDisplayKHR display);
10587 #endif
10588 
10589 
10590 #define VK_EXT_display_surface_counter 1
10591 #define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
10592 #define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
10593 
10602  void* pNext;
10603  uint32_t minImageCount;
10604  uint32_t maxImageCount;
10609  VkSurfaceTransformFlagsKHR supportedTransforms;
10611  VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
10612  VkImageUsageFlags supportedUsageFlags;
10613  VkSurfaceCounterFlagsEXT supportedSurfaceCounters;
10615 
10616 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
10617 
10618 #ifndef VK_NO_PROTOTYPES
10620  VkPhysicalDevice physicalDevice,
10621  VkSurfaceKHR surface,
10622  VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
10623 #endif
10624 
10625 
10626 #define VK_EXT_display_control 1
10627 #define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
10628 #define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
10629 
10636 
10637 typedef enum VkDeviceEventTypeEXT {
10641 
10646 typedef struct VkDisplayPowerInfoEXT {
10648  const void* pNext;
10651 
10652 typedef struct VkDeviceEventInfoEXT {
10654  const void* pNext;
10657 
10658 typedef struct VkDisplayEventInfoEXT {
10660  const void* pNext;
10663 
10666  const void* pNext;
10667  VkSurfaceCounterFlagsEXT surfaceCounters;
10669 
10670 typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
10671 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
10672 typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
10673 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
10674 
10675 #ifndef VK_NO_PROTOTYPES
10677  VkDevice device,
10678  VkDisplayKHR display,
10679  const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
10680 
10682  VkDevice device,
10683  const VkDeviceEventInfoEXT* pDeviceEventInfo,
10684  const VkAllocationCallbacks* pAllocator,
10685  VkFence* pFence);
10686 
10688  VkDevice device,
10689  VkDisplayKHR display,
10690  const VkDisplayEventInfoEXT* pDisplayEventInfo,
10691  const VkAllocationCallbacks* pAllocator,
10692  VkFence* pFence);
10693 
10695  VkDevice device,
10696  VkSwapchainKHR swapchain,
10698  uint64_t* pCounterValue);
10699 #endif
10700 
10701 
10702 #define VK_GOOGLE_display_timing 1
10703 #define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
10704 #define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
10708 
10710  uint32_t presentID;
10714  uint64_t presentMargin;
10716 
10717 typedef struct VkPresentTimeGOOGLE {
10718  uint32_t presentID;
10721 
10724  const void* pNext;
10725  uint32_t swapchainCount;
10728 
10729 typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
10730 typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
10731 
10732 #ifndef VK_NO_PROTOTYPES
10734  VkDevice device,
10735  VkSwapchainKHR swapchain,
10736  VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
10737 
10739  VkDevice device,
10740  VkSwapchainKHR swapchain,
10741  uint32_t* pPresentationTimingCount,
10742  VkPastPresentationTimingGOOGLE* pPresentationTimings);
10743 #endif
10744 
10745 
10746 #define VK_NV_sample_mask_override_coverage 1
10747 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
10748 #define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
10749 
10750 
10751 #define VK_NV_geometry_shader_passthrough 1
10752 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
10753 #define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
10754 
10755 
10756 #define VK_NV_viewport_array2 1
10757 #define VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION 1
10758 #define VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME "VK_NV_viewport_array2"
10759 #define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION
10760 #define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME
10761 
10762 
10763 #define VK_NVX_multiview_per_view_attributes 1
10764 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
10765 #define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
10768  void* pNext;
10771 
10772 
10773 
10774 #define VK_NV_viewport_swizzle 1
10775 #define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
10776 #define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
10777 
10790 typedef struct VkViewportSwizzleNV {
10796 
10799  const void* pNext;
10800  VkPipelineViewportSwizzleStateCreateFlagsNV flags;
10801  uint32_t viewportCount;
10804 
10805 
10806 
10807 #define VK_EXT_discard_rectangles 1
10808 #define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
10809 #define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
10810 
10819  void* pNext;
10822 
10825  const void* pNext;
10826  VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
10831 
10832 typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
10833 
10834 #ifndef VK_NO_PROTOTYPES
10836  VkCommandBuffer commandBuffer,
10837  uint32_t firstDiscardRectangle,
10838  uint32_t discardRectangleCount,
10839  const VkRect2D* pDiscardRectangles);
10840 #endif
10841 
10842 
10843 #define VK_EXT_conservative_rasterization 1
10844 #define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1
10845 #define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"
10846 
10856  void* pNext;
10867 
10870  const void* pNext;
10871  VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
10875 
10876 
10877 
10878 #define VK_EXT_depth_clip_enable 1
10879 #define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1
10880 #define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable"
10884  void* pNext;
10887 
10890  const void* pNext;
10891  VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
10894 
10895 
10896 
10897 #define VK_EXT_swapchain_colorspace 1
10898 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4
10899 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
10900 
10901 
10902 #define VK_EXT_hdr_metadata 1
10903 #define VK_EXT_HDR_METADATA_SPEC_VERSION 2
10904 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
10905 typedef struct VkXYColorEXT {
10906  float x;
10907  float y;
10908 } VkXYColorEXT;
10909 
10910 typedef struct VkHdrMetadataEXT {
10912  const void* pNext;
10922 
10923 typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
10924 
10925 #ifndef VK_NO_PROTOTYPES
10927  VkDevice device,
10928  uint32_t swapchainCount,
10929  const VkSwapchainKHR* pSwapchains,
10930  const VkHdrMetadataEXT* pMetadata);
10931 #endif
10932 
10933 
10934 #define VK_EXT_external_memory_dma_buf 1
10935 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1
10936 #define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"
10937 
10938 
10939 #define VK_EXT_queue_family_foreign 1
10940 #define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1
10941 #define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"
10942 #define VK_QUEUE_FAMILY_FOREIGN_EXT (~2U)
10943 
10944 
10945 #define VK_EXT_debug_utils 1
10946 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)
10947 #define VK_EXT_DEBUG_UTILS_SPEC_VERSION 2
10948 #define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils"
10950 
10958 
10969 typedef struct VkDebugUtilsLabelEXT {
10971  const void* pNext;
10972  const char* pLabelName;
10973  float color[4];
10975 
10978  const void* pNext;
10980  uint64_t objectHandle;
10981  const char* pObjectName;
10983 
10986  const void* pNext;
10987  VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
10988  const char* pMessageIdName;
10990  const char* pMessage;
10995  uint32_t objectCount;
10998 
11001  VkDebugUtilsMessageTypeFlagsEXT messageTypes,
11002  const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
11003  void* pUserData);
11004 
11007  const void* pNext;
11008  VkDebugUtilsMessengerCreateFlagsEXT flags;
11009  VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
11010  VkDebugUtilsMessageTypeFlagsEXT messageType;
11012  void* pUserData;
11014 
11017  const void* pNext;
11019  uint64_t objectHandle;
11020  uint64_t tagName;
11021  size_t tagSize;
11022  const void* pTag;
11024 
11030 typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
11031 typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer);
11032 typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
11033 typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);
11034 typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);
11035 typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
11036 
11037 #ifndef VK_NO_PROTOTYPES
11039  VkDevice device,
11040  const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
11041 
11043  VkDevice device,
11044  const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
11045 
11047  VkQueue queue,
11048  const VkDebugUtilsLabelEXT* pLabelInfo);
11049 
11051  VkQueue queue);
11052 
11054  VkQueue queue,
11055  const VkDebugUtilsLabelEXT* pLabelInfo);
11056 
11058  VkCommandBuffer commandBuffer,
11059  const VkDebugUtilsLabelEXT* pLabelInfo);
11060 
11062  VkCommandBuffer commandBuffer);
11063 
11065  VkCommandBuffer commandBuffer,
11066  const VkDebugUtilsLabelEXT* pLabelInfo);
11067 
11069  VkInstance instance,
11070  const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
11071  const VkAllocationCallbacks* pAllocator,
11072  VkDebugUtilsMessengerEXT* pMessenger);
11073 
11075  VkInstance instance,
11076  VkDebugUtilsMessengerEXT messenger,
11077  const VkAllocationCallbacks* pAllocator);
11078 
11080  VkInstance instance,
11082  VkDebugUtilsMessageTypeFlagsEXT messageTypes,
11083  const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
11084 #endif
11085 
11086 
11087 #define VK_EXT_sampler_filter_minmax 1
11088 #define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2
11089 #define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
11091 
11093 
11095 
11096 
11097 
11098 #define VK_AMD_gpu_shader_int16 1
11099 #define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2
11100 #define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
11101 
11102 
11103 #define VK_AMD_mixed_attachment_samples 1
11104 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
11105 #define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"
11106 
11107 
11108 #define VK_AMD_shader_fragment_mask 1
11109 #define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1
11110 #define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"
11111 
11112 
11113 #define VK_EXT_inline_uniform_block 1
11114 #define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1
11115 #define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block"
11117 
11119 
11121 
11123 
11124 
11125 
11126 #define VK_EXT_shader_stencil_export 1
11127 #define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
11128 #define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"
11129 
11130 
11131 #define VK_EXT_sample_locations 1
11132 #define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1
11133 #define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"
11134 typedef struct VkSampleLocationEXT {
11135  float x;
11136  float y;
11138 
11141  const void* pNext;
11147 
11152 
11154  uint32_t subpassIndex;
11157 
11160  const void* pNext;
11166 
11169  const void* pNext;
11173 
11176  void* pNext;
11177  VkSampleCountFlags sampleLocationSampleCounts;
11183 
11186  void* pNext;
11189 
11190 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
11192 
11193 #ifndef VK_NO_PROTOTYPES
11195  VkCommandBuffer commandBuffer,
11196  const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
11197 
11199  VkPhysicalDevice physicalDevice,
11200  VkSampleCountFlagBits samples,
11201  VkMultisamplePropertiesEXT* pMultisampleProperties);
11202 #endif
11203 
11204 
11205 #define VK_EXT_blend_operation_advanced 1
11206 #define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
11207 #define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
11208 
11209 typedef enum VkBlendOverlapEXT {
11217  void* pNext;
11220 
11223  void* pNext;
11231 
11234  const void* pNext;
11239 
11240 
11241 
11242 #define VK_NV_fragment_coverage_to_color 1
11243 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
11244 #define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"
11248  const void* pNext;
11249  VkPipelineCoverageToColorStateCreateFlagsNV flags;
11253 
11254 
11255 
11256 #define VK_NV_framebuffer_mixed_samples 1
11257 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
11258 #define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"
11259 
11270  const void* pNext;
11271  VkPipelineCoverageModulationStateCreateFlagsNV flags;
11277 
11278 
11279 
11280 #define VK_NV_fill_rectangle 1
11281 #define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
11282 #define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
11283 
11284 
11285 #define VK_NV_shader_sm_builtins 1
11286 #define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1
11287 #define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins"
11290  void* pNext;
11291  uint32_t shaderSMCount;
11294 
11297  void* pNext;
11300 
11301 
11302 
11303 #define VK_EXT_post_depth_coverage 1
11304 #define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
11305 #define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
11306 
11307 
11308 #define VK_EXT_image_drm_format_modifier 1
11309 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 2
11310 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier"
11314  VkFormatFeatureFlags drmFormatModifierTilingFeatures;
11316 
11319  void* pNext;
11323 
11326  const void* pNext;
11330  const uint32_t* pQueueFamilyIndices;
11332 
11335  const void* pNext;
11337  const uint64_t* pDrmFormatModifiers;
11339 
11342  const void* pNext;
11347 
11350  void* pNext;
11353 
11357  VkFormatFeatureFlags2 drmFormatModifierTilingFeatures;
11359 
11362  void* pNext;
11366 
11368 
11369 #ifndef VK_NO_PROTOTYPES
11371  VkDevice device,
11372  VkImage image,
11374 #endif
11375 
11376 
11377 #define VK_EXT_validation_cache 1
11378 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)
11379 #define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
11380 #define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"
11381 
11389  const void* pNext;
11390  VkValidationCacheCreateFlagsEXT flags;
11392  const void* pInitialData;
11394 
11397  const void* pNext;
11398  VkValidationCacheEXT validationCache;
11400 
11401 typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);
11402 typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator);
11403 typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);
11404 typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData);
11405 
11406 #ifndef VK_NO_PROTOTYPES
11408  VkDevice device,
11409  const VkValidationCacheCreateInfoEXT* pCreateInfo,
11410  const VkAllocationCallbacks* pAllocator,
11411  VkValidationCacheEXT* pValidationCache);
11412 
11414  VkDevice device,
11415  VkValidationCacheEXT validationCache,
11416  const VkAllocationCallbacks* pAllocator);
11417 
11419  VkDevice device,
11420  VkValidationCacheEXT dstCache,
11421  uint32_t srcCacheCount,
11422  const VkValidationCacheEXT* pSrcCaches);
11423 
11425  VkDevice device,
11426  VkValidationCacheEXT validationCache,
11427  size_t* pDataSize,
11428  void* pData);
11429 #endif
11430 
11431 
11432 #define VK_EXT_descriptor_indexing 1
11433 #define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2
11434 #define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing"
11436 
11437 typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT;
11438 
11440 
11442 
11444 
11446 
11448 
11449 
11450 
11451 #define VK_EXT_shader_viewport_index_layer 1
11452 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
11453 #define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
11454 
11455 
11456 #define VK_NV_shading_rate_image 1
11457 #define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3
11458 #define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"
11459 
11475 
11483 typedef struct VkShadingRatePaletteNV {
11487 
11490  const void* pNext;
11492  uint32_t viewportCount;
11495 
11498  void* pNext;
11502 
11505  void* pNext;
11510 
11512  uint32_t pixelX;
11513  uint32_t pixelY;
11514  uint32_t sample;
11516 
11519  uint32_t sampleCount;
11523 
11526  const void* pNext;
11531 
11532 typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
11533 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes);
11534 typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
11535 
11536 #ifndef VK_NO_PROTOTYPES
11538  VkCommandBuffer commandBuffer,
11539  VkImageView imageView,
11540  VkImageLayout imageLayout);
11541 
11543  VkCommandBuffer commandBuffer,
11544  uint32_t firstViewport,
11545  uint32_t viewportCount,
11546  const VkShadingRatePaletteNV* pShadingRatePalettes);
11547 
11549  VkCommandBuffer commandBuffer,
11550  VkCoarseSampleOrderTypeNV sampleOrderType,
11551  uint32_t customSampleOrderCount,
11552  const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
11553 #endif
11554 
11555 
11556 #define VK_NV_ray_tracing 1
11557 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV)
11558 #define VK_NV_RAY_TRACING_SPEC_VERSION 3
11559 #define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing"
11560 #define VK_SHADER_UNUSED_KHR (~0U)
11561 #define VK_SHADER_UNUSED_NV VK_SHADER_UNUSED_KHR
11562 
11573 
11574 
11575 typedef enum VkGeometryTypeKHR {
11584 
11585 
11595 
11596 
11607 
11608 
11615 
11623 typedef VkFlags VkGeometryFlagsKHR;
11624 typedef VkGeometryFlagsKHR VkGeometryFlagsNV;
11625 
11627 
11628 
11644 typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV;
11645 
11647 
11648 
11667 typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV;
11668 
11670 
11673  const void* pNext;
11675  uint32_t generalShader;
11677  uint32_t anyHitShader;
11680 
11683  const void* pNext;
11684  VkPipelineCreateFlags flags;
11685  uint32_t stageCount;
11687  uint32_t groupCount;
11690  VkPipelineLayout layout;
11694 
11695 typedef struct VkGeometryTrianglesNV {
11697  const void* pNext;
11698  VkBuffer vertexData;
11699  VkDeviceSize vertexOffset;
11700  uint32_t vertexCount;
11701  VkDeviceSize vertexStride;
11703  VkBuffer indexData;
11704  VkDeviceSize indexOffset;
11705  uint32_t indexCount;
11707  VkBuffer transformData;
11708  VkDeviceSize transformOffset;
11710 
11711 typedef struct VkGeometryAABBNV {
11713  const void* pNext;
11714  VkBuffer aabbData;
11715  uint32_t numAABBs;
11716  uint32_t stride;
11717  VkDeviceSize offset;
11719 
11720 typedef struct VkGeometryDataNV {
11724 
11725 typedef struct VkGeometryNV {
11727  const void* pNext;
11730  VkGeometryFlagsKHR flags;
11731 } VkGeometryNV;
11732 
11735  const void* pNext;
11736  VkAccelerationStructureTypeNV type;
11737  VkBuildAccelerationStructureFlagsNV flags;
11738  uint32_t instanceCount;
11739  uint32_t geometryCount;
11742 
11745  const void* pNext;
11746  VkDeviceSize compactedSize;
11749 
11752  const void* pNext;
11753  VkAccelerationStructureNV accelerationStructure;
11754  VkDeviceMemory memory;
11755  VkDeviceSize memoryOffset;
11757  const uint32_t* pDeviceIndices;
11759 
11762  const void* pNext;
11764  const VkAccelerationStructureNV* pAccelerationStructures;
11766 
11769  const void* pNext;
11771  VkAccelerationStructureNV accelerationStructure;
11773 
11776  void* pNext;
11786 
11787 typedef struct VkTransformMatrixKHR {
11788  float matrix[3][4];
11790 
11792 
11793 typedef struct VkAabbPositionsKHR {
11794  float minX;
11795  float minY;
11796  float minZ;
11797  float maxX;
11798  float maxY;
11799  float maxZ;
11801 
11803 
11806  uint32_t instanceCustomIndex:24;
11807  uint32_t mask:8;
11809  VkGeometryInstanceFlagsKHR flags:8;
11812 
11814 
11815 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure);
11816 typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator);
11817 typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
11818 typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
11819 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset);
11820 typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode);
11821 typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth);
11822 typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
11823 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
11824 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
11825 typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData);
11826 typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
11827 typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader);
11828 
11829 #ifndef VK_NO_PROTOTYPES
11831  VkDevice device,
11832  const VkAccelerationStructureCreateInfoNV* pCreateInfo,
11833  const VkAllocationCallbacks* pAllocator,
11834  VkAccelerationStructureNV* pAccelerationStructure);
11835 
11837  VkDevice device,
11838  VkAccelerationStructureNV accelerationStructure,
11839  const VkAllocationCallbacks* pAllocator);
11840 
11842  VkDevice device,
11844  VkMemoryRequirements2KHR* pMemoryRequirements);
11845 
11847  VkDevice device,
11848  uint32_t bindInfoCount,
11849  const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
11850 
11852  VkCommandBuffer commandBuffer,
11853  const VkAccelerationStructureInfoNV* pInfo,
11854  VkBuffer instanceData,
11855  VkDeviceSize instanceOffset,
11856  VkBool32 update,
11857  VkAccelerationStructureNV dst,
11858  VkAccelerationStructureNV src,
11859  VkBuffer scratch,
11860  VkDeviceSize scratchOffset);
11861 
11863  VkCommandBuffer commandBuffer,
11864  VkAccelerationStructureNV dst,
11865  VkAccelerationStructureNV src,
11867 
11869  VkCommandBuffer commandBuffer,
11870  VkBuffer raygenShaderBindingTableBuffer,
11871  VkDeviceSize raygenShaderBindingOffset,
11872  VkBuffer missShaderBindingTableBuffer,
11873  VkDeviceSize missShaderBindingOffset,
11874  VkDeviceSize missShaderBindingStride,
11875  VkBuffer hitShaderBindingTableBuffer,
11876  VkDeviceSize hitShaderBindingOffset,
11877  VkDeviceSize hitShaderBindingStride,
11878  VkBuffer callableShaderBindingTableBuffer,
11879  VkDeviceSize callableShaderBindingOffset,
11880  VkDeviceSize callableShaderBindingStride,
11881  uint32_t width,
11882  uint32_t height,
11883  uint32_t depth);
11884 
11886  VkDevice device,
11887  VkPipelineCache pipelineCache,
11888  uint32_t createInfoCount,
11889  const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
11890  const VkAllocationCallbacks* pAllocator,
11891  VkPipeline* pPipelines);
11892 
11894  VkDevice device,
11895  VkPipeline pipeline,
11896  uint32_t firstGroup,
11897  uint32_t groupCount,
11898  size_t dataSize,
11899  void* pData);
11900 
11902  VkDevice device,
11903  VkPipeline pipeline,
11904  uint32_t firstGroup,
11905  uint32_t groupCount,
11906  size_t dataSize,
11907  void* pData);
11908 
11910  VkDevice device,
11911  VkAccelerationStructureNV accelerationStructure,
11912  size_t dataSize,
11913  void* pData);
11914 
11916  VkCommandBuffer commandBuffer,
11917  uint32_t accelerationStructureCount,
11918  const VkAccelerationStructureNV* pAccelerationStructures,
11919  VkQueryType queryType,
11920  VkQueryPool queryPool,
11921  uint32_t firstQuery);
11922 
11924  VkDevice device,
11925  VkPipeline pipeline,
11926  uint32_t shader);
11927 #endif
11928 
11929 
11930 #define VK_NV_representative_fragment_test 1
11931 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2
11932 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
11935  void* pNext;
11938 
11941  const void* pNext;
11944 
11945 
11946 
11947 #define VK_EXT_filter_cubic 1
11948 #define VK_EXT_FILTER_CUBIC_SPEC_VERSION 3
11949 #define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic"
11952  void* pNext;
11955 
11958  void* pNext;
11959  VkBool32 filterCubic;
11962 
11963 
11964 
11965 #define VK_QCOM_render_pass_shader_resolve 1
11966 #define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION 4
11967 #define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve"
11968 
11969 
11970 #define VK_EXT_global_priority 1
11971 #define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
11972 #define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
11974 
11976 
11977 
11978 
11979 #define VK_EXT_external_memory_host 1
11980 #define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
11981 #define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"
11984  const void* pNext;
11988 
11991  void* pNext;
11992  uint32_t memoryTypeBits;
11994 
11997  void* pNext;
12000 
12001 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
12002 
12003 #ifndef VK_NO_PROTOTYPES
12005  VkDevice device,
12007  const void* pHostPointer,
12008  VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
12009 #endif
12010 
12011 
12012 #define VK_AMD_buffer_marker 1
12013 #define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1
12014 #define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker"
12015 typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
12016 
12017 #ifndef VK_NO_PROTOTYPES
12019  VkCommandBuffer commandBuffer,
12020  VkPipelineStageFlagBits pipelineStage,
12021  VkBuffer dstBuffer,
12022  VkDeviceSize dstOffset,
12023  uint32_t marker);
12024 #endif
12025 
12026 
12027 #define VK_AMD_pipeline_compiler_control 1
12028 #define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1
12029 #define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control"
12030 
12037  const void* pNext;
12038  VkPipelineCompilerControlFlagsAMD compilerControlFlags;
12040 
12041 
12042 
12043 #define VK_EXT_calibrated_timestamps 1
12044 #define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2
12045 #define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"
12046 
12047 typedef enum VkTimeDomainEXT {
12053 } VkTimeDomainEXT;
12056  const void* pNext;
12059 
12060 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains);
12061 typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);
12062 
12063 #ifndef VK_NO_PROTOTYPES
12065  VkPhysicalDevice physicalDevice,
12066  uint32_t* pTimeDomainCount,
12067  VkTimeDomainEXT* pTimeDomains);
12068 
12070  VkDevice device,
12071  uint32_t timestampCount,
12072  const VkCalibratedTimestampInfoEXT* pTimestampInfos,
12073  uint64_t* pTimestamps,
12074  uint64_t* pMaxDeviation);
12075 #endif
12076 
12077 
12078 #define VK_AMD_shader_core_properties 1
12079 #define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2
12080 #define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"
12083  void* pNext;
12089  uint32_t wavefrontSize;
12090  uint32_t sgprsPerSimd;
12094  uint32_t vgprsPerSimd;
12099 
12100 
12101 
12102 #define VK_AMD_memory_overallocation_behavior 1
12103 #define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1
12104 #define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior"
12105 
12114  const void* pNext;
12117 
12118 
12119 
12120 #define VK_EXT_vertex_attribute_divisor 1
12121 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3
12122 #define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"
12125  void* pNext;
12128 
12130  uint32_t binding;
12131  uint32_t divisor;
12133 
12136  const void* pNext;
12140 
12143  void* pNext;
12147 
12148 
12149 
12150 #define VK_EXT_pipeline_creation_feedback 1
12151 #define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1
12152 #define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback"
12154 
12155 typedef VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT;
12156 
12158 
12160 
12161 
12162 
12163 #define VK_NV_shader_subgroup_partitioned 1
12164 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1
12165 #define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"
12166 
12167 
12168 #define VK_NV_compute_shader_derivatives 1
12169 #define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1
12170 #define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"
12173  void* pNext;
12177 
12178 
12179 
12180 #define VK_NV_mesh_shader 1
12181 #define VK_NV_MESH_SHADER_SPEC_VERSION 1
12182 #define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader"
12185  void* pNext;
12186  VkBool32 taskShader;
12187  VkBool32 meshShader;
12189 
12192  void* pNext;
12207 
12209  uint32_t taskCount;
12210  uint32_t firstTask;
12212 
12213 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
12214 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
12215 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
12216 
12217 #ifndef VK_NO_PROTOTYPES
12219  VkCommandBuffer commandBuffer,
12220  uint32_t taskCount,
12221  uint32_t firstTask);
12222 
12224  VkCommandBuffer commandBuffer,
12225  VkBuffer buffer,
12226  VkDeviceSize offset,
12227  uint32_t drawCount,
12228  uint32_t stride);
12229 
12231  VkCommandBuffer commandBuffer,
12232  VkBuffer buffer,
12233  VkDeviceSize offset,
12234  VkBuffer countBuffer,
12235  VkDeviceSize countBufferOffset,
12236  uint32_t maxDrawCount,
12237  uint32_t stride);
12238 #endif
12239 
12240 
12241 #define VK_NV_fragment_shader_barycentric 1
12242 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1
12243 #define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric"
12245 
12246 
12247 
12248 #define VK_NV_shader_image_footprint 1
12249 #define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2
12250 #define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"
12253  void* pNext;
12254  VkBool32 imageFootprint;
12256 
12257 
12258 
12259 #define VK_NV_scissor_exclusive 1
12260 #define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1
12261 #define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"
12264  const void* pNext;
12268 
12271  void* pNext;
12274 
12275 typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
12276 
12277 #ifndef VK_NO_PROTOTYPES
12279  VkCommandBuffer commandBuffer,
12280  uint32_t firstExclusiveScissor,
12281  uint32_t exclusiveScissorCount,
12282  const VkRect2D* pExclusiveScissors);
12283 #endif
12284 
12285 
12286 #define VK_NV_device_diagnostic_checkpoints 1
12287 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2
12288 #define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints"
12291  void* pNext;
12292  VkPipelineStageFlags checkpointExecutionStageMask;
12294 
12295 typedef struct VkCheckpointDataNV {
12297  void* pNext;
12301 
12302 typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker);
12303 typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData);
12304 
12305 #ifndef VK_NO_PROTOTYPES
12307  VkCommandBuffer commandBuffer,
12308  const void* pCheckpointMarker);
12309 
12311  VkQueue queue,
12312  uint32_t* pCheckpointDataCount,
12313  VkCheckpointDataNV* pCheckpointData);
12314 #endif
12315 
12316 
12317 #define VK_INTEL_shader_integer_functions2 1
12318 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1
12319 #define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"
12322  void* pNext;
12325 
12326 
12327 
12328 #define VK_INTEL_performance_query 1
12329 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL)
12330 #define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 2
12331 #define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query"
12332 
12337 
12342 
12348 
12354 
12364  uint32_t value32;
12365  uint64_t value64;
12366  float valueFloat;
12367  VkBool32 valueBool;
12368  const char* valueString;
12370 
12371 typedef struct VkPerformanceValueINTEL {
12375 
12378  const void* pNext;
12379  void* pUserData;
12381 
12384  const void* pNext;
12387 
12389 
12392  const void* pNext;
12393  uint64_t marker;
12395 
12398  const void* pNext;
12399  uint32_t marker;
12401 
12404  const void* pNext;
12406  VkBool32 enable;
12407  uint64_t parameter;
12409 
12412  const void* pNext;
12415 
12418 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
12419 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
12420 typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
12421 typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration);
12422 typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration);
12423 typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration);
12425 
12426 #ifndef VK_NO_PROTOTYPES
12428  VkDevice device,
12429  const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
12430 
12432  VkDevice device);
12433 
12435  VkCommandBuffer commandBuffer,
12436  const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
12437 
12439  VkCommandBuffer commandBuffer,
12440  const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
12441 
12443  VkCommandBuffer commandBuffer,
12444  const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
12445 
12447  VkDevice device,
12448  const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
12449  VkPerformanceConfigurationINTEL* pConfiguration);
12450 
12452  VkDevice device,
12453  VkPerformanceConfigurationINTEL configuration);
12454 
12456  VkQueue queue,
12457  VkPerformanceConfigurationINTEL configuration);
12458 
12460  VkDevice device,
12462  VkPerformanceValueINTEL* pValue);
12463 #endif
12464 
12465 
12466 #define VK_EXT_pci_bus_info 1
12467 #define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2
12468 #define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info"
12471  void* pNext;
12472  uint32_t pciDomain;
12473  uint32_t pciBus;
12474  uint32_t pciDevice;
12475  uint32_t pciFunction;
12477 
12478 
12479 
12480 #define VK_AMD_display_native_hdr 1
12481 #define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1
12482 #define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr"
12485  void* pNext;
12488 
12491  const void* pNext;
12494 
12495 typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable);
12496 
12497 #ifndef VK_NO_PROTOTYPES
12499  VkDevice device,
12500  VkSwapchainKHR swapChain,
12501  VkBool32 localDimmingEnable);
12502 #endif
12503 
12504 
12505 #define VK_EXT_fragment_density_map 1
12506 #define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 2
12507 #define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map"
12510  void* pNext;
12515 
12518  void* pNext;
12523 
12526  const void* pNext;
12529 
12530 
12531 
12532 #define VK_EXT_scalar_block_layout 1
12533 #define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1
12534 #define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout"
12536 
12537 
12538 
12539 #define VK_GOOGLE_hlsl_functionality1 1
12540 #define VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION 1
12541 #define VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1"
12542 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION
12543 #define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME
12544 
12545 
12546 #define VK_GOOGLE_decorate_string 1
12547 #define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1
12548 #define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"
12549 
12550 
12551 #define VK_EXT_subgroup_size_control 1
12552 #define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2
12553 #define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control"
12555 
12557 
12559 
12560 
12561 
12562 #define VK_AMD_shader_core_properties2 1
12563 #define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1
12564 #define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2"
12565 
12572  void* pNext;
12573  VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
12576 
12577 
12578 
12579 #define VK_AMD_device_coherent_memory 1
12580 #define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1
12581 #define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory"
12584  void* pNext;
12587 
12588 
12589 
12590 #define VK_EXT_shader_image_atomic_int64 1
12591 #define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1
12592 #define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64"
12595  void* pNext;
12599 
12600 
12601 
12602 #define VK_EXT_memory_budget 1
12603 #define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1
12604 #define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget"
12607  void* pNext;
12611 
12612 
12613 
12614 #define VK_EXT_memory_priority 1
12615 #define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1
12616 #define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority"
12619  void* pNext;
12620  VkBool32 memoryPriority;
12622 
12625  const void* pNext;
12626  float priority;
12628 
12629 
12630 
12631 #define VK_NV_dedicated_allocation_image_aliasing 1
12632 #define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1
12633 #define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing"
12636  void* pNext;
12639 
12640 
12641 
12642 #define VK_EXT_buffer_device_address 1
12643 #define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2
12644 #define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
12647  void* pNext;
12652 
12654 
12656 
12659  const void* pNext;
12660  VkDeviceAddress deviceAddress;
12662 
12664 
12665 #ifndef VK_NO_PROTOTYPES
12667  VkDevice device,
12668  const VkBufferDeviceAddressInfo* pInfo);
12669 #endif
12670 
12671 
12672 #define VK_EXT_tooling_info 1
12673 #define VK_EXT_TOOLING_INFO_SPEC_VERSION 1
12674 #define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info"
12676 
12677 typedef VkToolPurposeFlags VkToolPurposeFlagsEXT;
12678 
12680 
12681 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties);
12682 
12683 #ifndef VK_NO_PROTOTYPES
12685  VkPhysicalDevice physicalDevice,
12686  uint32_t* pToolCount,
12687  VkPhysicalDeviceToolProperties* pToolProperties);
12688 #endif
12689 
12690 
12691 #define VK_EXT_separate_stencil_usage 1
12692 #define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1
12693 #define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage"
12695 
12696 
12697 
12698 #define VK_EXT_validation_features 1
12699 #define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5
12700 #define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features"
12701 
12710 
12722 typedef struct VkValidationFeaturesEXT {
12724  const void* pNext;
12730 
12731 
12732 
12733 #define VK_NV_cooperative_matrix 1
12734 #define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1
12735 #define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix"
12736 
12737 typedef enum VkComponentTypeNV {
12751 
12752 typedef enum VkScopeNV {
12758 } VkScopeNV;
12761  void* pNext;
12762  uint32_t MSize;
12763  uint32_t NSize;
12764  uint32_t KSize;
12771 
12774  void* pNext;
12778 
12781  void* pNext;
12784 
12785 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties);
12786 
12787 #ifndef VK_NO_PROTOTYPES
12789  VkPhysicalDevice physicalDevice,
12790  uint32_t* pPropertyCount,
12791  VkCooperativeMatrixPropertiesNV* pProperties);
12792 #endif
12793 
12794 
12795 #define VK_NV_coverage_reduction_mode 1
12796 #define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1
12797 #define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode"
12798 
12807  void* pNext;
12810 
12813  const void* pNext;
12814  VkPipelineCoverageReductionStateCreateFlagsNV flags;
12817 
12820  void* pNext;
12823  VkSampleCountFlags depthStencilSamples;
12824  VkSampleCountFlags colorSamples;
12826 
12827 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations);
12828 
12829 #ifndef VK_NO_PROTOTYPES
12831  VkPhysicalDevice physicalDevice,
12832  uint32_t* pCombinationCount,
12834 #endif
12835 
12836 
12837 #define VK_EXT_fragment_shader_interlock 1
12838 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1
12839 #define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock"
12842  void* pNext;
12847 
12848 
12849 
12850 #define VK_EXT_ycbcr_image_arrays 1
12851 #define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1
12852 #define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
12855  void* pNext;
12858 
12859 
12860 
12861 #define VK_EXT_provoking_vertex 1
12862 #define VK_EXT_PROVOKING_VERTEX_SPEC_VERSION 1
12863 #define VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME "VK_EXT_provoking_vertex"
12864 
12872  void* pNext;
12876 
12879  void* pNext;
12883 
12886  const void* pNext;
12889 
12890 
12891 
12892 #define VK_EXT_headless_surface 1
12893 #define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1
12894 #define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface"
12898  const void* pNext;
12899  VkHeadlessSurfaceCreateFlagsEXT flags;
12901 
12902 typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
12903 
12904 #ifndef VK_NO_PROTOTYPES
12906  VkInstance instance,
12907  const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
12908  const VkAllocationCallbacks* pAllocator,
12909  VkSurfaceKHR* pSurface);
12910 #endif
12911 
12912 
12913 #define VK_EXT_line_rasterization 1
12914 #define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1
12915 #define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"
12916 
12926  void* pNext;
12928  VkBool32 bresenhamLines;
12929  VkBool32 smoothLines;
12934 
12937  void* pNext;
12940 
12943  const void* pNext;
12949 
12950 typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
12951 
12952 #ifndef VK_NO_PROTOTYPES
12954  VkCommandBuffer commandBuffer,
12955  uint32_t lineStippleFactor,
12956  uint16_t lineStipplePattern);
12957 #endif
12958 
12959 
12960 #define VK_EXT_shader_atomic_float 1
12961 #define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1
12962 #define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float"
12965  void* pNext;
12979 
12980 
12981 
12982 #define VK_EXT_host_query_reset 1
12983 #define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1
12984 #define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset"
12986 
12987 typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
12988 
12989 #ifndef VK_NO_PROTOTYPES
12991  VkDevice device,
12992  VkQueryPool queryPool,
12993  uint32_t firstQuery,
12994  uint32_t queryCount);
12995 #endif
12996 
12997 
12998 #define VK_EXT_index_type_uint8 1
12999 #define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1
13000 #define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"
13003  void* pNext;
13004  VkBool32 indexTypeUint8;
13006 
13007 
13008 
13009 #define VK_EXT_extended_dynamic_state 1
13010 #define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1
13011 #define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state"
13014  void* pNext;
13017 
13018 typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);
13019 typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace);
13020 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);
13021 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
13022 typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
13023 typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides);
13024 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);
13025 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable);
13026 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
13027 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);
13028 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);
13029 typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);
13030 
13031 #ifndef VK_NO_PROTOTYPES
13033  VkCommandBuffer commandBuffer,
13034  VkCullModeFlags cullMode);
13035 
13037  VkCommandBuffer commandBuffer,
13038  VkFrontFace frontFace);
13039 
13041  VkCommandBuffer commandBuffer,
13042  VkPrimitiveTopology primitiveTopology);
13043 
13045  VkCommandBuffer commandBuffer,
13046  uint32_t viewportCount,
13047  const VkViewport* pViewports);
13048 
13050  VkCommandBuffer commandBuffer,
13051  uint32_t scissorCount,
13052  const VkRect2D* pScissors);
13053 
13055  VkCommandBuffer commandBuffer,
13056  uint32_t firstBinding,
13057  uint32_t bindingCount,
13058  const VkBuffer* pBuffers,
13059  const VkDeviceSize* pOffsets,
13060  const VkDeviceSize* pSizes,
13061  const VkDeviceSize* pStrides);
13062 
13064  VkCommandBuffer commandBuffer,
13065  VkBool32 depthTestEnable);
13066 
13068  VkCommandBuffer commandBuffer,
13069  VkBool32 depthWriteEnable);
13070 
13072  VkCommandBuffer commandBuffer,
13073  VkCompareOp depthCompareOp);
13074 
13076  VkCommandBuffer commandBuffer,
13077  VkBool32 depthBoundsTestEnable);
13078 
13080  VkCommandBuffer commandBuffer,
13081  VkBool32 stencilTestEnable);
13082 
13084  VkCommandBuffer commandBuffer,
13085  VkStencilFaceFlags faceMask,
13086  VkStencilOp failOp,
13087  VkStencilOp passOp,
13088  VkStencilOp depthFailOp,
13089  VkCompareOp compareOp);
13090 #endif
13091 
13092 
13093 #define VK_EXT_shader_atomic_float2 1
13094 #define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1
13095 #define VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME "VK_EXT_shader_atomic_float2"
13098  void* pNext;
13112 
13113 
13114 
13115 #define VK_EXT_shader_demote_to_helper_invocation 1
13116 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1
13117 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation"
13119 
13120 
13121 
13122 #define VK_NV_device_generated_commands 1
13123 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV)
13124 #define VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
13125 #define VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NV_device_generated_commands"
13126 
13139 
13144 typedef VkFlags VkIndirectStateFlagsNV;
13145 
13155  void* pNext;
13166 
13169  void* pNext;
13172 
13175  const void* pNext;
13176  uint32_t stageCount;
13181 
13184  const void* pNext;
13185  uint32_t groupCount;
13187  uint32_t pipelineCount;
13188  const VkPipeline* pPipelines;
13190 
13192  uint32_t groupIndex;
13194 
13196  VkDeviceAddress bufferAddress;
13197  uint32_t size;
13200 
13202  VkDeviceAddress bufferAddress;
13203  uint32_t size;
13204  uint32_t stride;
13206 
13208  uint32_t data;
13210 
13212  VkBuffer buffer;
13213  VkDeviceSize offset;
13215 
13218  const void* pNext;
13220  uint32_t stream;
13221  uint32_t offset;
13224  VkPipelineLayout pushconstantPipelineLayout;
13225  VkShaderStageFlags pushconstantShaderStageFlags;
13228  VkIndirectStateFlagsNV indirectStateFlags;
13229  uint32_t indexTypeCount;
13231  const uint32_t* pIndexTypeValues;
13233 
13236  const void* pNext;
13237  VkIndirectCommandsLayoutUsageFlagsNV flags;
13239  uint32_t tokenCount;
13241  uint32_t streamCount;
13242  const uint32_t* pStreamStrides;
13244 
13247  const void* pNext;
13249  VkPipeline pipeline;
13250  VkIndirectCommandsLayoutNV indirectCommandsLayout;
13251  uint32_t streamCount;
13253  uint32_t sequencesCount;
13255  VkDeviceSize preprocessOffset;
13256  VkDeviceSize preprocessSize;
13258  VkDeviceSize sequencesCountOffset;
13260  VkDeviceSize sequencesIndexOffset;
13262 
13265  const void* pNext;
13267  VkPipeline pipeline;
13268  VkIndirectCommandsLayoutNV indirectCommandsLayout;
13271 
13273 typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
13274 typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
13275 typedef void (VKAPI_PTR *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex);
13276 typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout);
13277 typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
13278 
13279 #ifndef VK_NO_PROTOTYPES
13281  VkDevice device,
13283  VkMemoryRequirements2* pMemoryRequirements);
13284 
13286  VkCommandBuffer commandBuffer,
13287  const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
13288 
13290  VkCommandBuffer commandBuffer,
13291  VkBool32 isPreprocessed,
13292  const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
13293 
13295  VkCommandBuffer commandBuffer,
13296  VkPipelineBindPoint pipelineBindPoint,
13297  VkPipeline pipeline,
13298  uint32_t groupIndex);
13299 
13301  VkDevice device,
13302  const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
13303  const VkAllocationCallbacks* pAllocator,
13304  VkIndirectCommandsLayoutNV* pIndirectCommandsLayout);
13305 
13307  VkDevice device,
13308  VkIndirectCommandsLayoutNV indirectCommandsLayout,
13309  const VkAllocationCallbacks* pAllocator);
13310 #endif
13311 
13312 
13313 #define VK_NV_inherited_viewport_scissor 1
13314 #define VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION 1
13315 #define VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME "VK_NV_inherited_viewport_scissor"
13318  void* pNext;
13321 
13324  const void* pNext;
13329 
13330 
13331 
13332 #define VK_EXT_texel_buffer_alignment 1
13333 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1
13334 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment"
13337  void* pNext;
13340 
13342 
13343 
13344 
13345 #define VK_QCOM_render_pass_transform 1
13346 #define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 3
13347 #define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform"
13350  void* pNext;
13353 
13356  void* pNext;
13360 
13361 
13362 
13363 #define VK_EXT_device_memory_report 1
13364 #define VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION 2
13365 #define VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME "VK_EXT_device_memory_report"
13366 
13378  void* pNext;
13381 
13384  void* pNext;
13385  VkDeviceMemoryReportFlagsEXT flags;
13387  uint64_t memoryObjectId;
13388  VkDeviceSize size;
13390  uint64_t objectHandle;
13391  uint32_t heapIndex;
13393 
13395  const VkDeviceMemoryReportCallbackDataEXT* pCallbackData,
13396  void* pUserData);
13397 
13400  const void* pNext;
13401  VkDeviceMemoryReportFlagsEXT flags;
13403  void* pUserData;
13405 
13406 
13407 
13408 #define VK_EXT_acquire_drm_display 1
13409 #define VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION 1
13410 #define VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_drm_display"
13411 typedef VkResult (VKAPI_PTR *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display);
13412 typedef VkResult (VKAPI_PTR *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display);
13413 
13414 #ifndef VK_NO_PROTOTYPES
13416  VkPhysicalDevice physicalDevice,
13417  int32_t drmFd,
13418  VkDisplayKHR display);
13419 
13421  VkPhysicalDevice physicalDevice,
13422  int32_t drmFd,
13423  uint32_t connectorId,
13424  VkDisplayKHR* display);
13425 #endif
13426 
13427 
13428 #define VK_EXT_robustness2 1
13429 #define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1
13430 #define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2"
13433  void* pNext;
13436  VkBool32 nullDescriptor;
13438 
13441  void* pNext;
13445 
13446 
13447 
13448 #define VK_EXT_custom_border_color 1
13449 #define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12
13450 #define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color"
13453  const void* pNext;
13457 
13460  void* pNext;
13463 
13466  void* pNext;
13470 
13471 
13472 
13473 #define VK_GOOGLE_user_type 1
13474 #define VK_GOOGLE_USER_TYPE_SPEC_VERSION 1
13475 #define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type"
13476 
13477 
13478 #define VK_NV_present_barrier 1
13479 #define VK_NV_PRESENT_BARRIER_SPEC_VERSION 1
13480 #define VK_NV_PRESENT_BARRIER_EXTENSION_NAME "VK_NV_present_barrier"
13483  void* pNext;
13484  VkBool32 presentBarrier;
13486 
13489  void* pNext;
13492 
13495  void* pNext;
13498 
13499 
13500 
13501 #define VK_EXT_private_data 1
13502 typedef VkPrivateDataSlot VkPrivateDataSlotEXT;
13503 
13504 #define VK_EXT_PRIVATE_DATA_SPEC_VERSION 1
13505 #define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data"
13506 typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT;
13507 
13509 
13511 
13513 
13514 typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot);
13515 typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator);
13516 typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data);
13517 typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData);
13518 
13519 #ifndef VK_NO_PROTOTYPES
13521  VkDevice device,
13522  const VkPrivateDataSlotCreateInfo* pCreateInfo,
13523  const VkAllocationCallbacks* pAllocator,
13524  VkPrivateDataSlot* pPrivateDataSlot);
13525 
13527  VkDevice device,
13528  VkPrivateDataSlot privateDataSlot,
13529  const VkAllocationCallbacks* pAllocator);
13530 
13532  VkDevice device,
13533  VkObjectType objectType,
13534  uint64_t objectHandle,
13535  VkPrivateDataSlot privateDataSlot,
13536  uint64_t data);
13537 
13539  VkDevice device,
13540  VkObjectType objectType,
13541  uint64_t objectHandle,
13542  VkPrivateDataSlot privateDataSlot,
13543  uint64_t* pData);
13544 #endif
13545 
13546 
13547 #define VK_EXT_pipeline_creation_cache_control 1
13548 #define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION 3
13549 #define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME "VK_EXT_pipeline_creation_cache_control"
13551 
13552 
13553 
13554 #define VK_NV_device_diagnostics_config 1
13555 #define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 2
13556 #define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config"
13557 
13568  void* pNext;
13571 
13574  const void* pNext;
13575  VkDeviceDiagnosticsConfigFlagsNV flags;
13577 
13578 
13579 
13580 #define VK_QCOM_render_pass_store_ops 1
13581 #define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2
13582 #define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops"
13583 
13584 
13585 #define VK_EXT_descriptor_buffer 1
13586 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR)
13587 #define VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION 1
13588 #define VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME "VK_EXT_descriptor_buffer"
13591  void* pNext;
13626 
13629  void* pNext;
13632 
13635  void* pNext;
13641 
13644  void* pNext;
13645  VkDeviceAddress address;
13646  VkDeviceSize range;
13649 
13652  void* pNext;
13653  VkDeviceAddress address;
13654  VkBufferUsageFlags usage;
13656 
13659  void* pNext;
13660  VkBuffer buffer;
13662 
13663 typedef union VkDescriptorDataEXT {
13664  const VkSampler* pSampler;
13673  VkDeviceAddress accelerationStructure;
13675 
13676 typedef struct VkDescriptorGetInfoEXT {
13678  const void* pNext;
13682 
13685  const void* pNext;
13686  VkBuffer buffer;
13688 
13691  const void* pNext;
13692  VkImage image;
13694 
13697  const void* pNext;
13698  VkImageView imageView;
13700 
13703  const void* pNext;
13704  VkSampler sampler;
13706 
13709  const void* pNext;
13712 
13715  const void* pNext;
13716  VkAccelerationStructureKHR accelerationStructure;
13717  VkAccelerationStructureNV accelerationStructureNV;
13719 
13720 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes);
13721 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset);
13722 typedef void (VKAPI_PTR *PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor);
13723 typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos);
13724 typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets);
13725 typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set);
13731 
13732 #ifndef VK_NO_PROTOTYPES
13734  VkDevice device,
13735  VkDescriptorSetLayout layout,
13736  VkDeviceSize* pLayoutSizeInBytes);
13737 
13739  VkDevice device,
13740  VkDescriptorSetLayout layout,
13741  uint32_t binding,
13742  VkDeviceSize* pOffset);
13743 
13745  VkDevice device,
13746  const VkDescriptorGetInfoEXT* pDescriptorInfo,
13747  size_t dataSize,
13748  void* pDescriptor);
13749 
13751  VkCommandBuffer commandBuffer,
13752  uint32_t bufferCount,
13753  const VkDescriptorBufferBindingInfoEXT* pBindingInfos);
13754 
13756  VkCommandBuffer commandBuffer,
13757  VkPipelineBindPoint pipelineBindPoint,
13758  VkPipelineLayout layout,
13759  uint32_t firstSet,
13760  uint32_t setCount,
13761  const uint32_t* pBufferIndices,
13762  const VkDeviceSize* pOffsets);
13763 
13765  VkCommandBuffer commandBuffer,
13766  VkPipelineBindPoint pipelineBindPoint,
13767  VkPipelineLayout layout,
13768  uint32_t set);
13769 
13771  VkDevice device,
13773  void* pData);
13774 
13776  VkDevice device,
13778  void* pData);
13779 
13781  VkDevice device,
13783  void* pData);
13784 
13786  VkDevice device,
13788  void* pData);
13789 
13791  VkDevice device,
13793  void* pData);
13794 #endif
13795 
13796 
13797 #define VK_EXT_graphics_pipeline_library 1
13798 #define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION 1
13799 #define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME "VK_EXT_graphics_pipeline_library"
13800 
13811  void* pNext;
13814 
13817  void* pNext;
13821 
13824  void* pNext;
13825  VkGraphicsPipelineLibraryFlagsEXT flags;
13827 
13828 
13829 
13830 #define VK_AMD_shader_early_and_late_fragment_tests 1
13831 #define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION 1
13832 #define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME "VK_AMD_shader_early_and_late_fragment_tests"
13835  void* pNext;
13838 
13839 
13840 
13841 #define VK_NV_fragment_shading_rate_enums 1
13842 #define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION 1
13843 #define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME "VK_NV_fragment_shading_rate_enums"
13844 
13850 
13868  void* pNext;
13873 
13876  void* pNext;
13879 
13882  const void* pNext;
13887 
13888 typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
13889 
13890 #ifndef VK_NO_PROTOTYPES
13892  VkCommandBuffer commandBuffer,
13893  VkFragmentShadingRateNV shadingRate,
13894  const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
13895 #endif
13896 
13897 
13898 #define VK_NV_ray_tracing_motion_blur 1
13899 #define VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION 1
13900 #define VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME "VK_NV_ray_tracing_motion_blur"
13901 
13911  VkDeviceAddress deviceAddress;
13912  const void* hostAddress;
13914 
13917  const void* pNext;
13920 
13923  const void* pNext;
13924  uint32_t maxInstances;
13925  VkAccelerationStructureMotionInfoFlagsNV flags;
13927 
13931  uint32_t instanceCustomIndex:24;
13932  uint32_t mask:8;
13934  VkGeometryInstanceFlagsKHR flags:8;
13937 
13938 typedef struct VkSRTDataNV {
13939  float sx;
13940  float a;
13941  float b;
13942  float pvx;
13943  float sy;
13944  float c;
13945  float pvy;
13946  float sz;
13947  float pvz;
13948  float qx;
13949  float qy;
13950  float qz;
13951  float qw;
13952  float tx;
13953  float ty;
13954  float tz;
13955 } VkSRTDataNV;
13956 
13960  uint32_t instanceCustomIndex:24;
13961  uint32_t mask:8;
13963  VkGeometryInstanceFlagsKHR flags:8;
13966 
13972 
13975  VkAccelerationStructureMotionInstanceFlagsNV flags;
13978 
13981  void* pNext;
13985 
13986 
13987 
13988 #define VK_EXT_ycbcr_2plane_444_formats 1
13989 #define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1
13990 #define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats"
13993  void* pNext;
13996 
13997 
13998 
13999 #define VK_EXT_fragment_density_map2 1
14000 #define VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION 1
14001 #define VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME "VK_EXT_fragment_density_map2"
14004  void* pNext;
14007 
14010  void* pNext;
14016 
14017 
14018 
14019 #define VK_QCOM_rotated_copy_commands 1
14020 #define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1
14021 #define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands"
14024  const void* pNext;
14027 
14028 
14029 
14030 #define VK_EXT_image_robustness 1
14031 #define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1
14032 #define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness"
14034 
14035 
14036 
14037 #define VK_EXT_image_compression_control 1
14038 #define VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION 1
14039 #define VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME "VK_EXT_image_compression_control"
14040 
14049 
14081  void* pNext;
14084 
14087  const void* pNext;
14088  VkImageCompressionFlagsEXT flags;
14090  VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags;
14092 
14093 typedef struct VkSubresourceLayout2EXT {
14095  void* pNext;
14098 
14099 typedef struct VkImageSubresource2EXT {
14101  void* pNext;
14104 
14107  void* pNext;
14108  VkImageCompressionFlagsEXT imageCompressionFlags;
14109  VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
14111 
14112 typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout);
14113 
14114 #ifndef VK_NO_PROTOTYPES
14116  VkDevice device,
14117  VkImage image,
14118  const VkImageSubresource2EXT* pSubresource,
14119  VkSubresourceLayout2EXT* pLayout);
14120 #endif
14121 
14122 
14123 #define VK_EXT_attachment_feedback_loop_layout 1
14124 #define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION 2
14125 #define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME "VK_EXT_attachment_feedback_loop_layout"
14128  void* pNext;
14131 
14132 
14133 
14134 #define VK_EXT_4444_formats 1
14135 #define VK_EXT_4444_FORMATS_SPEC_VERSION 1
14136 #define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats"
14139  void* pNext;
14140  VkBool32 formatA4R4G4B4;
14141  VkBool32 formatA4B4G4R4;
14143 
14144 
14145 
14146 #define VK_EXT_device_fault 1
14147 #define VK_EXT_DEVICE_FAULT_SPEC_VERSION 1
14148 #define VK_EXT_DEVICE_FAULT_EXTENSION_NAME "VK_EXT_device_fault"
14149 
14160 
14167  void* pNext;
14168  VkBool32 deviceFault;
14171 
14172 typedef struct VkDeviceFaultCountsEXT {
14174  void* pNext;
14177  VkDeviceSize vendorBinarySize;
14179 
14182  VkDeviceAddress reportedAddress;
14183  VkDeviceSize addressPrecision;
14185 
14191 
14192 typedef struct VkDeviceFaultInfoEXT {
14194  void* pNext;
14200 
14202  uint32_t headerSize;
14204  uint32_t vendorID;
14205  uint32_t deviceID;
14206  uint32_t driverVersion;
14212 
14213 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo);
14214 
14215 #ifndef VK_NO_PROTOTYPES
14217  VkDevice device,
14218  VkDeviceFaultCountsEXT* pFaultCounts,
14219  VkDeviceFaultInfoEXT* pFaultInfo);
14220 #endif
14221 
14222 
14223 #define VK_ARM_rasterization_order_attachment_access 1
14224 #define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1
14225 #define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_ARM_rasterization_order_attachment_access"
14228  void* pNext;
14233 
14235 
14236 
14237 
14238 #define VK_EXT_rgba10x6_formats 1
14239 #define VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION 1
14240 #define VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME "VK_EXT_rgba10x6_formats"
14243  void* pNext;
14246 
14247 
14248 
14249 #define VK_VALVE_mutable_descriptor_type 1
14250 #define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1
14251 #define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type"
14254  void* pNext;
14257 
14259 
14264 
14266 
14269  const void* pNext;
14273 
14275 
14276 
14277 
14278 #define VK_EXT_vertex_input_dynamic_state 1
14279 #define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2
14280 #define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state"
14283  void* pNext;
14286 
14289  void* pNext;
14290  uint32_t binding;
14291  uint32_t stride;
14293  uint32_t divisor;
14295 
14298  void* pNext;
14299  uint32_t location;
14300  uint32_t binding;
14302  uint32_t offset;
14304 
14305 typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
14306 
14307 #ifndef VK_NO_PROTOTYPES
14309  VkCommandBuffer commandBuffer,
14310  uint32_t vertexBindingDescriptionCount,
14311  const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions,
14312  uint32_t vertexAttributeDescriptionCount,
14313  const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
14314 #endif
14315 
14316 
14317 #define VK_EXT_physical_device_drm 1
14318 #define VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION 1
14319 #define VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME "VK_EXT_physical_device_drm"
14322  void* pNext;
14323  VkBool32 hasPrimary;
14324  VkBool32 hasRender;
14325  int64_t primaryMajor;
14326  int64_t primaryMinor;
14327  int64_t renderMajor;
14328  int64_t renderMinor;
14330 
14331 
14332 
14333 #define VK_EXT_device_address_binding_report 1
14334 #define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION 1
14335 #define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME "VK_EXT_device_address_binding_report"
14336 
14342 
14350  void* pNext;
14353 
14356  void* pNext;
14357  VkDeviceAddressBindingFlagsEXT flags;
14358  VkDeviceAddress baseAddress;
14359  VkDeviceSize size;
14362 
14363 
14364 
14365 #define VK_EXT_depth_clip_control 1
14366 #define VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION 1
14367 #define VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clip_control"
14370  void* pNext;
14373 
14376  const void* pNext;
14379 
14380 
14381 
14382 #define VK_EXT_primitive_topology_list_restart 1
14383 #define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION 1
14384 #define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME "VK_EXT_primitive_topology_list_restart"
14387  void* pNext;
14391 
14392 
14393 
14394 #define VK_HUAWEI_subpass_shading 1
14395 #define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 2
14396 #define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading"
14399  void* pNext;
14400  VkRenderPass renderPass;
14401  uint32_t subpass;
14403 
14406  void* pNext;
14407  VkBool32 subpassShading;
14409 
14412  void* pNext;
14415 
14416 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize);
14417 typedef void (VKAPI_PTR *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer);
14418 
14419 #ifndef VK_NO_PROTOTYPES
14421  VkDevice device,
14422  VkRenderPass renderpass,
14423  VkExtent2D* pMaxWorkgroupSize);
14424 
14426  VkCommandBuffer commandBuffer);
14427 #endif
14428 
14429 
14430 #define VK_HUAWEI_invocation_mask 1
14431 #define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1
14432 #define VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME "VK_HUAWEI_invocation_mask"
14435  void* pNext;
14436  VkBool32 invocationMask;
14438 
14439 typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
14440 
14441 #ifndef VK_NO_PROTOTYPES
14443  VkCommandBuffer commandBuffer,
14444  VkImageView imageView,
14445  VkImageLayout imageLayout);
14446 #endif
14447 
14448 
14449 #define VK_NV_external_memory_rdma 1
14450 typedef void* VkRemoteAddressNV;
14451 #define VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION 1
14452 #define VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME "VK_NV_external_memory_rdma"
14455  const void* pNext;
14456  VkDeviceMemory memory;
14459 
14462  void* pNext;
14465 
14466 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress);
14467 
14468 #ifndef VK_NO_PROTOTYPES
14470  VkDevice device,
14471  const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
14472  VkRemoteAddressNV* pAddress);
14473 #endif
14474 
14475 
14476 #define VK_EXT_pipeline_properties 1
14477 #define VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION 1
14478 #define VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME "VK_EXT_pipeline_properties"
14480 
14483  void* pNext;
14486 
14489  void* pNext;
14492 
14493 typedef VkResult (VKAPI_PTR *PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties);
14494 
14495 #ifndef VK_NO_PROTOTYPES
14497  VkDevice device,
14498  const VkPipelineInfoEXT* pPipelineInfo,
14499  VkBaseOutStructure* pPipelineProperties);
14500 #endif
14501 
14502 
14503 #define VK_EXT_multisampled_render_to_single_sampled 1
14504 #define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION 1
14505 #define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME "VK_EXT_multisampled_render_to_single_sampled"
14508  void* pNext;
14511 
14514  void* pNext;
14515  VkBool32 optimal;
14517 
14520  const void* pNext;
14524 
14525 
14526 
14527 #define VK_EXT_extended_dynamic_state2 1
14528 #define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1
14529 #define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2"
14532  void* pNext;
14537 
14538 typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints);
14539 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);
14540 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);
14541 typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp);
14542 typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);
14543 
14544 #ifndef VK_NO_PROTOTYPES
14546  VkCommandBuffer commandBuffer,
14547  uint32_t patchControlPoints);
14548 
14550  VkCommandBuffer commandBuffer,
14551  VkBool32 rasterizerDiscardEnable);
14552 
14554  VkCommandBuffer commandBuffer,
14555  VkBool32 depthBiasEnable);
14556 
14558  VkCommandBuffer commandBuffer,
14559  VkLogicOp logicOp);
14560 
14562  VkCommandBuffer commandBuffer,
14563  VkBool32 primitiveRestartEnable);
14564 #endif
14565 
14566 
14567 #define VK_EXT_color_write_enable 1
14568 #define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1
14569 #define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable"
14572  void* pNext;
14575 
14578  const void* pNext;
14580  const VkBool32* pColorWriteEnables;
14582 
14583 typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables);
14584 
14585 #ifndef VK_NO_PROTOTYPES
14587  VkCommandBuffer commandBuffer,
14588  uint32_t attachmentCount,
14589  const VkBool32* pColorWriteEnables);
14590 #endif
14591 
14592 
14593 #define VK_EXT_primitives_generated_query 1
14594 #define VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION 1
14595 #define VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME "VK_EXT_primitives_generated_query"
14598  void* pNext;
14603 
14604 
14605 
14606 #define VK_EXT_global_priority_query 1
14607 #define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1
14608 #define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query"
14609 #define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT VK_MAX_GLOBAL_PRIORITY_SIZE_KHR
14611 
14613 
14614 
14615 
14616 #define VK_EXT_image_view_min_lod 1
14617 #define VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION 1
14618 #define VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME "VK_EXT_image_view_min_lod"
14621  void* pNext;
14622  VkBool32 minLod;
14624 
14627  const void* pNext;
14628  float minLod;
14630 
14631 
14632 
14633 #define VK_EXT_multi_draw 1
14634 #define VK_EXT_MULTI_DRAW_SPEC_VERSION 1
14635 #define VK_EXT_MULTI_DRAW_EXTENSION_NAME "VK_EXT_multi_draw"
14638  void* pNext;
14639  VkBool32 multiDraw;
14641 
14644  void* pNext;
14647 
14648 typedef struct VkMultiDrawInfoEXT {
14649  uint32_t firstVertex;
14650  uint32_t vertexCount;
14652 
14654  uint32_t firstIndex;
14655  uint32_t indexCount;
14656  int32_t vertexOffset;
14658 
14659 typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride);
14660 typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset);
14661 
14662 #ifndef VK_NO_PROTOTYPES
14664  VkCommandBuffer commandBuffer,
14665  uint32_t drawCount,
14666  const VkMultiDrawInfoEXT* pVertexInfo,
14667  uint32_t instanceCount,
14668  uint32_t firstInstance,
14669  uint32_t stride);
14670 
14672  VkCommandBuffer commandBuffer,
14673  uint32_t drawCount,
14674  const VkMultiDrawIndexedInfoEXT* pIndexInfo,
14675  uint32_t instanceCount,
14676  uint32_t firstInstance,
14677  uint32_t stride,
14678  const int32_t* pVertexOffset);
14679 #endif
14680 
14681 
14682 #define VK_EXT_image_2d_view_of_3d 1
14683 #define VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION 1
14684 #define VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_2d_view_of_3d"
14687  void* pNext;
14691 
14692 
14693 
14694 #define VK_EXT_opacity_micromap 1
14695 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT)
14696 #define VK_EXT_OPACITY_MICROMAP_SPEC_VERSION 2
14697 #define VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME "VK_EXT_opacity_micromap"
14698 
14699 typedef enum VkMicromapTypeEXT {
14703 
14708 
14716 
14722 
14730 
14736 
14743 
14750 typedef VkFlags VkBuildMicromapFlagsEXT;
14751 
14757 typedef struct VkMicromapUsageEXT {
14758  uint32_t count;
14760  uint32_t format;
14762 
14764  VkDeviceAddress deviceAddress;
14767 
14768 typedef struct VkMicromapBuildInfoEXT {
14770  const void* pNext;
14772  VkBuildMicromapFlagsEXT flags;
14774  VkMicromapEXT dstMicromap;
14781  VkDeviceSize triangleArrayStride;
14783 
14784 typedef struct VkMicromapCreateInfoEXT {
14786  const void* pNext;
14787  VkMicromapCreateFlagsEXT createFlags;
14788  VkBuffer buffer;
14789  VkDeviceSize offset;
14790  VkDeviceSize size;
14792  VkDeviceAddress deviceAddress;
14794 
14797  void* pNext;
14798  VkBool32 micromap;
14802 
14805  void* pNext;
14809 
14812  const void* pNext;
14813  const uint8_t* pVersionData;
14815 
14818  const void* pNext;
14819  VkMicromapEXT src;
14823 
14826  const void* pNext;
14828  VkMicromapEXT dst;
14831 
14832 typedef struct VkCopyMicromapInfoEXT {
14834  const void* pNext;
14835  VkMicromapEXT src;
14836  VkMicromapEXT dst;
14839 
14842  const void* pNext;
14843  VkDeviceSize micromapSize;
14844  VkDeviceSize buildScratchSize;
14845  VkBool32 discardable;
14847 
14850  void* pNext;
14853  VkDeviceSize indexStride;
14854  uint32_t baseTriangle;
14858  VkMicromapEXT micromap;
14860 
14861 typedef struct VkMicromapTriangleEXT {
14862  uint32_t dataOffset;
14864  uint16_t format;
14866 
14867 typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap);
14868 typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator);
14869 typedef void (VKAPI_PTR *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos);
14870 typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos);
14871 typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo);
14872 typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo);
14873 typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo);
14874 typedef VkResult (VKAPI_PTR *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride);
14875 typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo);
14876 typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo);
14877 typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo);
14878 typedef void (VKAPI_PTR *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
14881 
14882 #ifndef VK_NO_PROTOTYPES
14884  VkDevice device,
14885  const VkMicromapCreateInfoEXT* pCreateInfo,
14886  const VkAllocationCallbacks* pAllocator,
14887  VkMicromapEXT* pMicromap);
14888 
14890  VkDevice device,
14891  VkMicromapEXT micromap,
14892  const VkAllocationCallbacks* pAllocator);
14893 
14895  VkCommandBuffer commandBuffer,
14896  uint32_t infoCount,
14897  const VkMicromapBuildInfoEXT* pInfos);
14898 
14900  VkDevice device,
14901  VkDeferredOperationKHR deferredOperation,
14902  uint32_t infoCount,
14903  const VkMicromapBuildInfoEXT* pInfos);
14904 
14906  VkDevice device,
14907  VkDeferredOperationKHR deferredOperation,
14908  const VkCopyMicromapInfoEXT* pInfo);
14909 
14911  VkDevice device,
14912  VkDeferredOperationKHR deferredOperation,
14913  const VkCopyMicromapToMemoryInfoEXT* pInfo);
14914 
14916  VkDevice device,
14917  VkDeferredOperationKHR deferredOperation,
14918  const VkCopyMemoryToMicromapInfoEXT* pInfo);
14919 
14921  VkDevice device,
14922  uint32_t micromapCount,
14923  const VkMicromapEXT* pMicromaps,
14924  VkQueryType queryType,
14925  size_t dataSize,
14926  void* pData,
14927  size_t stride);
14928 
14930  VkCommandBuffer commandBuffer,
14931  const VkCopyMicromapInfoEXT* pInfo);
14932 
14934  VkCommandBuffer commandBuffer,
14935  const VkCopyMicromapToMemoryInfoEXT* pInfo);
14936 
14938  VkCommandBuffer commandBuffer,
14939  const VkCopyMemoryToMicromapInfoEXT* pInfo);
14940 
14942  VkCommandBuffer commandBuffer,
14943  uint32_t micromapCount,
14944  const VkMicromapEXT* pMicromaps,
14945  VkQueryType queryType,
14946  VkQueryPool queryPool,
14947  uint32_t firstQuery);
14948 
14950  VkDevice device,
14951  const VkMicromapVersionInfoEXT* pVersionInfo,
14952  VkAccelerationStructureCompatibilityKHR* pCompatibility);
14953 
14955  VkDevice device,
14957  const VkMicromapBuildInfoEXT* pBuildInfo,
14958  VkMicromapBuildSizesInfoEXT* pSizeInfo);
14959 #endif
14960 
14961 
14962 #define VK_EXT_load_store_op_none 1
14963 #define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1
14964 #define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none"
14965 
14966 
14967 #define VK_EXT_border_color_swizzle 1
14968 #define VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION 1
14969 #define VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME "VK_EXT_border_color_swizzle"
14972  void* pNext;
14976 
14979  const void* pNext;
14981  VkBool32 srgb;
14983 
14984 
14985 
14986 #define VK_EXT_pageable_device_local_memory 1
14987 #define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION 1
14988 #define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME "VK_EXT_pageable_device_local_memory"
14991  void* pNext;
14994 
14995 typedef void (VKAPI_PTR *PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority);
14996 
14997 #ifndef VK_NO_PROTOTYPES
14999  VkDevice device,
15000  VkDeviceMemory memory,
15001  float priority);
15002 #endif
15003 
15004 
15005 #define VK_VALVE_descriptor_set_host_mapping 1
15006 #define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION 1
15007 #define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME "VK_VALVE_descriptor_set_host_mapping"
15010  void* pNext;
15013 
15016  const void* pNext;
15017  VkDescriptorSetLayout descriptorSetLayout;
15018  uint32_t binding;
15020 
15023  void* pNext;
15025  uint32_t descriptorSize;
15027 
15029 typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void** ppData);
15030 
15031 #ifndef VK_NO_PROTOTYPES
15033  VkDevice device,
15034  const VkDescriptorSetBindingReferenceVALVE* pBindingReference,
15036 
15038  VkDevice device,
15039  VkDescriptorSet descriptorSet,
15040  void** ppData);
15041 #endif
15042 
15043 
15044 #define VK_EXT_depth_clamp_zero_one 1
15045 #define VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1
15046 #define VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_EXT_depth_clamp_zero_one"
15049  void* pNext;
15052 
15053 
15054 
15055 #define VK_EXT_non_seamless_cube_map 1
15056 #define VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION 1
15057 #define VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME "VK_EXT_non_seamless_cube_map"
15060  void* pNext;
15063 
15064 
15065 
15066 #define VK_QCOM_fragment_density_map_offset 1
15067 #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1
15068 #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset"
15071  void* pNext;
15074 
15077  void* pNext;
15080 
15083  const void* pNext;
15087 
15088 
15089 
15090 #define VK_NV_copy_memory_indirect 1
15091 #define VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION 1
15092 #define VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_NV_copy_memory_indirect"
15094  VkDeviceAddress srcAddress;
15095  VkDeviceAddress dstAddress;
15096  VkDeviceSize size;
15098 
15100  VkDeviceAddress srcAddress;
15107 
15110  void* pNext;
15111  VkBool32 indirectCopy;
15113 
15116  void* pNext;
15117  VkQueueFlags supportedQueues;
15119 
15120 typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride);
15121 typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources);
15122 
15123 #ifndef VK_NO_PROTOTYPES
15125  VkCommandBuffer commandBuffer,
15126  VkDeviceAddress copyBufferAddress,
15127  uint32_t copyCount,
15128  uint32_t stride);
15129 
15131  VkCommandBuffer commandBuffer,
15132  VkDeviceAddress copyBufferAddress,
15133  uint32_t copyCount,
15134  uint32_t stride,
15135  VkImage dstImage,
15136  VkImageLayout dstImageLayout,
15137  const VkImageSubresourceLayers* pImageSubresources);
15138 #endif
15139 
15140 
15141 #define VK_NV_memory_decompression 1
15142 #define VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION 1
15143 #define VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME "VK_NV_memory_decompression"
15144 
15145 // Flag bits for VkMemoryDecompressionMethodFlagBitsNV
15147 static const VkMemoryDecompressionMethodFlagBitsNV VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = 0x00000001ULL;
15148 
15151  VkDeviceAddress srcAddress;
15152  VkDeviceAddress dstAddress;
15153  VkDeviceSize compressedSize;
15154  VkDeviceSize decompressedSize;
15155  VkMemoryDecompressionMethodFlagsNV decompressionMethod;
15157 
15160  void* pNext;
15163 
15166  void* pNext;
15167  VkMemoryDecompressionMethodFlagsNV decompressionMethods;
15170 
15171 typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions);
15172 typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride);
15173 
15174 #ifndef VK_NO_PROTOTYPES
15176  VkCommandBuffer commandBuffer,
15177  uint32_t decompressRegionCount,
15178  const VkDecompressMemoryRegionNV* pDecompressMemoryRegions);
15179 
15181  VkCommandBuffer commandBuffer,
15182  VkDeviceAddress indirectCommandsAddress,
15183  VkDeviceAddress indirectCommandsCountAddress,
15184  uint32_t stride);
15185 #endif
15186 
15187 
15188 #define VK_NV_linear_color_attachment 1
15189 #define VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION 1
15190 #define VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME "VK_NV_linear_color_attachment"
15193  void* pNext;
15196 
15197 
15198 
15199 #define VK_GOOGLE_surfaceless_query 1
15200 #define VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION 2
15201 #define VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME "VK_GOOGLE_surfaceless_query"
15202 
15203 
15204 #define VK_EXT_image_compression_control_swapchain 1
15205 #define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION 1
15206 #define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME "VK_EXT_image_compression_control_swapchain"
15209  void* pNext;
15212 
15213 
15214 
15215 #define VK_QCOM_image_processing 1
15216 #define VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION 1
15217 #define VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME "VK_QCOM_image_processing"
15220  const void* pNext;
15223  uint32_t numPhases;
15225 
15228  void* pNext;
15233 
15236  void* pNext;
15242 
15243 
15244 
15245 #define VK_EXT_extended_dynamic_state3 1
15246 #define VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION 2
15247 #define VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME "VK_EXT_extended_dynamic_state3"
15250  void* pNext;
15283 
15286  void* pNext;
15289 
15290 typedef struct VkColorBlendEquationEXT {
15298 
15299 typedef struct VkColorBlendAdvancedEXT {
15304  VkBool32 clampResults;
15306 
15307 typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin);
15308 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable);
15309 typedef void (VKAPI_PTR *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode);
15310 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples);
15311 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask);
15312 typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable);
15313 typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable);
15314 typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable);
15315 typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables);
15316 typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations);
15317 typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks);
15318 typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream);
15319 typedef void (VKAPI_PTR *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode);
15320 typedef void (VKAPI_PTR *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize);
15321 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable);
15322 typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable);
15323 typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced);
15324 typedef void (VKAPI_PTR *PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode);
15325 typedef void (VKAPI_PTR *PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode);
15326 typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable);
15327 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne);
15328 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable);
15329 typedef void (VKAPI_PTR *PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles);
15330 typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable);
15331 typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation);
15332 typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode);
15333 typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable);
15334 typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable);
15335 typedef void (VKAPI_PTR *PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable);
15336 typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable);
15337 typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode);
15338 
15339 #ifndef VK_NO_PROTOTYPES
15341  VkCommandBuffer commandBuffer,
15342  VkTessellationDomainOrigin domainOrigin);
15343 
15345  VkCommandBuffer commandBuffer,
15346  VkBool32 depthClampEnable);
15347 
15349  VkCommandBuffer commandBuffer,
15350  VkPolygonMode polygonMode);
15351 
15353  VkCommandBuffer commandBuffer,
15354  VkSampleCountFlagBits rasterizationSamples);
15355 
15357  VkCommandBuffer commandBuffer,
15358  VkSampleCountFlagBits samples,
15359  const VkSampleMask* pSampleMask);
15360 
15362  VkCommandBuffer commandBuffer,
15363  VkBool32 alphaToCoverageEnable);
15364 
15366  VkCommandBuffer commandBuffer,
15367  VkBool32 alphaToOneEnable);
15368 
15370  VkCommandBuffer commandBuffer,
15371  VkBool32 logicOpEnable);
15372 
15374  VkCommandBuffer commandBuffer,
15375  uint32_t firstAttachment,
15376  uint32_t attachmentCount,
15377  const VkBool32* pColorBlendEnables);
15378 
15380  VkCommandBuffer commandBuffer,
15381  uint32_t firstAttachment,
15382  uint32_t attachmentCount,
15383  const VkColorBlendEquationEXT* pColorBlendEquations);
15384 
15386  VkCommandBuffer commandBuffer,
15387  uint32_t firstAttachment,
15388  uint32_t attachmentCount,
15389  const VkColorComponentFlags* pColorWriteMasks);
15390 
15392  VkCommandBuffer commandBuffer,
15393  uint32_t rasterizationStream);
15394 
15396  VkCommandBuffer commandBuffer,
15397  VkConservativeRasterizationModeEXT conservativeRasterizationMode);
15398 
15400  VkCommandBuffer commandBuffer,
15401  float extraPrimitiveOverestimationSize);
15402 
15404  VkCommandBuffer commandBuffer,
15405  VkBool32 depthClipEnable);
15406 
15408  VkCommandBuffer commandBuffer,
15409  VkBool32 sampleLocationsEnable);
15410 
15412  VkCommandBuffer commandBuffer,
15413  uint32_t firstAttachment,
15414  uint32_t attachmentCount,
15415  const VkColorBlendAdvancedEXT* pColorBlendAdvanced);
15416 
15418  VkCommandBuffer commandBuffer,
15419  VkProvokingVertexModeEXT provokingVertexMode);
15420 
15422  VkCommandBuffer commandBuffer,
15423  VkLineRasterizationModeEXT lineRasterizationMode);
15424 
15426  VkCommandBuffer commandBuffer,
15427  VkBool32 stippledLineEnable);
15428 
15430  VkCommandBuffer commandBuffer,
15431  VkBool32 negativeOneToOne);
15432 
15434  VkCommandBuffer commandBuffer,
15435  VkBool32 viewportWScalingEnable);
15436 
15438  VkCommandBuffer commandBuffer,
15439  uint32_t firstViewport,
15440  uint32_t viewportCount,
15441  const VkViewportSwizzleNV* pViewportSwizzles);
15442 
15444  VkCommandBuffer commandBuffer,
15445  VkBool32 coverageToColorEnable);
15446 
15448  VkCommandBuffer commandBuffer,
15449  uint32_t coverageToColorLocation);
15450 
15452  VkCommandBuffer commandBuffer,
15453  VkCoverageModulationModeNV coverageModulationMode);
15454 
15456  VkCommandBuffer commandBuffer,
15457  VkBool32 coverageModulationTableEnable);
15458 
15460  VkCommandBuffer commandBuffer,
15461  uint32_t coverageModulationTableCount,
15462  const float* pCoverageModulationTable);
15463 
15465  VkCommandBuffer commandBuffer,
15466  VkBool32 shadingRateImageEnable);
15467 
15469  VkCommandBuffer commandBuffer,
15470  VkBool32 representativeFragmentTestEnable);
15471 
15473  VkCommandBuffer commandBuffer,
15474  VkCoverageReductionModeNV coverageReductionMode);
15475 #endif
15476 
15477 
15478 #define VK_EXT_subpass_merge_feedback 1
15479 #define VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION 2
15480 #define VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME "VK_EXT_subpass_merge_feedback"
15481 
15501  void* pNext;
15504 
15507  const void* pNext;
15510 
15514 
15517  const void* pNext;
15520 
15524  uint32_t postMergeIndex;
15526 
15529  const void* pNext;
15532 
15533 
15534 
15535 #define VK_LUNARG_direct_driver_loading 1
15536 #define VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION 1
15537 #define VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME "VK_LUNARG_direct_driver_loading"
15538 
15546  VkInstance instance, const char* pName);
15547 
15550  void* pNext;
15551  VkDirectDriverLoadingFlagsLUNARG flags;
15554 
15557  void* pNext;
15559  uint32_t driverCount;
15562 
15563 
15564 
15565 #define VK_EXT_shader_module_identifier 1
15566 #define VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT 32U
15567 #define VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION 1
15568 #define VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME "VK_EXT_shader_module_identifier"
15571  void* pNext;
15574 
15577  void* pNext;
15580 
15583  const void* pNext;
15584  uint32_t identifierSize;
15585  const uint8_t* pIdentifier;
15587 
15590  void* pNext;
15591  uint32_t identifierSize;
15594 
15595 typedef void (VKAPI_PTR *PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier);
15597 
15598 #ifndef VK_NO_PROTOTYPES
15600  VkDevice device,
15601  VkShaderModule shaderModule,
15602  VkShaderModuleIdentifierEXT* pIdentifier);
15603 
15605  VkDevice device,
15606  const VkShaderModuleCreateInfo* pCreateInfo,
15607  VkShaderModuleIdentifierEXT* pIdentifier);
15608 #endif
15609 
15610 
15611 #define VK_EXT_rasterization_order_attachment_access 1
15612 #define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1
15613 #define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_EXT_rasterization_order_attachment_access"
15614 
15615 
15616 #define VK_NV_optical_flow 1
15617 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV)
15618 #define VK_NV_OPTICAL_FLOW_SPEC_VERSION 1
15619 #define VK_NV_OPTICAL_FLOW_EXTENSION_NAME "VK_NV_optical_flow"
15620 
15628 
15641 
15651 
15662 
15672 
15680  void* pNext;
15681  VkBool32 opticalFlow;
15683 
15686  void* pNext;
15687  VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
15688  VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
15689  VkBool32 hintSupported;
15690  VkBool32 costSupported;
15693  uint32_t minWidth;
15694  uint32_t minHeight;
15695  uint32_t maxWidth;
15696  uint32_t maxHeight;
15699 
15702  const void* pNext;
15703  VkOpticalFlowUsageFlagsNV usage;
15705 
15708  const void* pNext;
15711 
15714  void* pNext;
15715  uint32_t width;
15716  uint32_t height;
15720  VkOpticalFlowGridSizeFlagsNV outputGridSize;
15721  VkOpticalFlowGridSizeFlagsNV hintGridSize;
15723  VkOpticalFlowSessionCreateFlagsNV flags;
15725 
15728  void* pNext;
15729  uint32_t id;
15730  uint32_t size;
15731  const void* pPrivateData;
15733 
15736  void* pNext;
15737  VkOpticalFlowExecuteFlagsNV flags;
15738  uint32_t regionCount;
15741 
15742 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties);
15743 typedef VkResult (VKAPI_PTR *PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession);
15744 typedef void (VKAPI_PTR *PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator);
15745 typedef VkResult (VKAPI_PTR *PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout);
15746 typedef void (VKAPI_PTR *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo);
15747 
15748 #ifndef VK_NO_PROTOTYPES
15750  VkPhysicalDevice physicalDevice,
15751  const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo,
15752  uint32_t* pFormatCount,
15753  VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties);
15754 
15756  VkDevice device,
15757  const VkOpticalFlowSessionCreateInfoNV* pCreateInfo,
15758  const VkAllocationCallbacks* pAllocator,
15759  VkOpticalFlowSessionNV* pSession);
15760 
15762  VkDevice device,
15763  VkOpticalFlowSessionNV session,
15764  const VkAllocationCallbacks* pAllocator);
15765 
15767  VkDevice device,
15768  VkOpticalFlowSessionNV session,
15770  VkImageView view,
15771  VkImageLayout layout);
15772 
15774  VkCommandBuffer commandBuffer,
15775  VkOpticalFlowSessionNV session,
15776  const VkOpticalFlowExecuteInfoNV* pExecuteInfo);
15777 #endif
15778 
15779 
15780 #define VK_EXT_legacy_dithering 1
15781 #define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 1
15782 #define VK_EXT_LEGACY_DITHERING_EXTENSION_NAME "VK_EXT_legacy_dithering"
15785  void* pNext;
15788 
15789 
15790 
15791 #define VK_EXT_pipeline_protected_access 1
15792 #define VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION 1
15793 #define VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME "VK_EXT_pipeline_protected_access"
15796  void* pNext;
15799 
15800 
15801 
15802 #define VK_QCOM_tile_properties 1
15803 #define VK_QCOM_TILE_PROPERTIES_SPEC_VERSION 1
15804 #define VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME "VK_QCOM_tile_properties"
15807  void* pNext;
15808  VkBool32 tileProperties;
15810 
15811 typedef struct VkTilePropertiesQCOM {
15813  void* pNext;
15818 
15819 typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties);
15820 typedef VkResult (VKAPI_PTR *PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties);
15821 
15822 #ifndef VK_NO_PROTOTYPES
15824  VkDevice device,
15825  VkFramebuffer framebuffer,
15826  uint32_t* pPropertiesCount,
15827  VkTilePropertiesQCOM* pProperties);
15828 
15830  VkDevice device,
15831  const VkRenderingInfo* pRenderingInfo,
15832  VkTilePropertiesQCOM* pProperties);
15833 #endif
15834 
15835 
15836 #define VK_SEC_amigo_profiling 1
15837 #define VK_SEC_AMIGO_PROFILING_SPEC_VERSION 1
15838 #define VK_SEC_AMIGO_PROFILING_EXTENSION_NAME "VK_SEC_amigo_profiling"
15841  void* pNext;
15842  VkBool32 amigoProfiling;
15844 
15847  const void* pNext;
15851 
15852 
15853 
15854 #define VK_QCOM_multiview_per_view_viewports 1
15855 #define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION 1
15856 #define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME "VK_QCOM_multiview_per_view_viewports"
15859  void* pNext;
15862 
15863 
15864 
15865 #define VK_NV_ray_tracing_invocation_reorder 1
15866 #define VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 1
15867 #define VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME "VK_NV_ray_tracing_invocation_reorder"
15868 
15876  void* pNext;
15879 
15882  void* pNext;
15885 
15886 
15887 
15888 #define VK_EXT_mutable_descriptor_type 1
15889 #define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1
15890 #define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_EXT_mutable_descriptor_type"
15891 
15892 
15893 #define VK_ARM_shader_core_builtins 1
15894 #define VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION 2
15895 #define VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME "VK_ARM_shader_core_builtins"
15898  void* pNext;
15901 
15904  void* pNext;
15905  uint64_t shaderCoreMask;
15909 
15910 
15911 
15912 #define VK_KHR_acceleration_structure 1
15913 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13
15914 #define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure"
15915 
15921 
15930  uint32_t primitiveCount;
15932  uint32_t firstVertex;
15935 
15938  const void* pNext;
15941  VkDeviceSize vertexStride;
15942  uint32_t maxVertex;
15947 
15950  const void* pNext;
15952  VkDeviceSize stride;
15954 
15957  const void* pNext;
15961 
15967 
15970  const void* pNext;
15973  VkGeometryFlagsKHR flags;
15975 
15978  const void* pNext;
15980  VkBuildAccelerationStructureFlagsKHR flags;
15982  VkAccelerationStructureKHR srcAccelerationStructure;
15983  VkAccelerationStructureKHR dstAccelerationStructure;
15984  uint32_t geometryCount;
15989 
15992  const void* pNext;
15993  VkAccelerationStructureCreateFlagsKHR createFlags;
15994  VkBuffer buffer;
15995  VkDeviceSize offset;
15996  VkDeviceSize size;
15998  VkDeviceAddress deviceAddress;
16000 
16003  const void* pNext;
16005  const VkAccelerationStructureKHR* pAccelerationStructures;
16007 
16010  void* pNext;
16017 
16020  void* pNext;
16030 
16033  const void* pNext;
16034  VkAccelerationStructureKHR accelerationStructure;
16036 
16039  const void* pNext;
16040  const uint8_t* pVersionData;
16042 
16045  const void* pNext;
16046  VkAccelerationStructureKHR src;
16050 
16053  const void* pNext;
16055  VkAccelerationStructureKHR dst;
16058 
16061  const void* pNext;
16062  VkAccelerationStructureKHR src;
16063  VkAccelerationStructureKHR dst;
16066 
16069  const void* pNext;
16071  VkDeviceSize updateScratchSize;
16072  VkDeviceSize buildScratchSize;
16074 
16075 typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure);
16076 typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator);
16077 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
16078 typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts);
16079 typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
16080 typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo);
16081 typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
16082 typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
16083 typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride);
16084 typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo);
16088 typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);
16091 
16092 #ifndef VK_NO_PROTOTYPES
16094  VkDevice device,
16095  const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
16096  const VkAllocationCallbacks* pAllocator,
16097  VkAccelerationStructureKHR* pAccelerationStructure);
16098 
16100  VkDevice device,
16101  VkAccelerationStructureKHR accelerationStructure,
16102  const VkAllocationCallbacks* pAllocator);
16103 
16105  VkCommandBuffer commandBuffer,
16106  uint32_t infoCount,
16108  const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
16109 
16111  VkCommandBuffer commandBuffer,
16112  uint32_t infoCount,
16114  const VkDeviceAddress* pIndirectDeviceAddresses,
16115  const uint32_t* pIndirectStrides,
16116  const uint32_t* const* ppMaxPrimitiveCounts);
16117 
16119  VkDevice device,
16120  VkDeferredOperationKHR deferredOperation,
16121  uint32_t infoCount,
16123  const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
16124 
16126  VkDevice device,
16127  VkDeferredOperationKHR deferredOperation,
16128  const VkCopyAccelerationStructureInfoKHR* pInfo);
16129 
16131  VkDevice device,
16132  VkDeferredOperationKHR deferredOperation,
16134 
16136  VkDevice device,
16137  VkDeferredOperationKHR deferredOperation,
16139 
16141  VkDevice device,
16142  uint32_t accelerationStructureCount,
16143  const VkAccelerationStructureKHR* pAccelerationStructures,
16144  VkQueryType queryType,
16145  size_t dataSize,
16146  void* pData,
16147  size_t stride);
16148 
16150  VkCommandBuffer commandBuffer,
16151  const VkCopyAccelerationStructureInfoKHR* pInfo);
16152 
16154  VkCommandBuffer commandBuffer,
16156 
16158  VkCommandBuffer commandBuffer,
16160 
16162  VkDevice device,
16164 
16166  VkCommandBuffer commandBuffer,
16167  uint32_t accelerationStructureCount,
16168  const VkAccelerationStructureKHR* pAccelerationStructures,
16169  VkQueryType queryType,
16170  VkQueryPool queryPool,
16171  uint32_t firstQuery);
16172 
16174  VkDevice device,
16175  const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
16176  VkAccelerationStructureCompatibilityKHR* pCompatibility);
16177 
16179  VkDevice device,
16182  const uint32_t* pMaxPrimitiveCounts,
16184 #endif
16185 
16186 
16187 #define VK_KHR_ray_tracing_pipeline 1
16188 #define VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION 1
16189 #define VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME "VK_KHR_ray_tracing_pipeline"
16190 
16200  const void* pNext;
16202  uint32_t generalShader;
16204  uint32_t anyHitShader;
16208 
16211  const void* pNext;
16215 
16218  const void* pNext;
16219  VkPipelineCreateFlags flags;
16220  uint32_t stageCount;
16222  uint32_t groupCount;
16228  VkPipelineLayout layout;
16232 
16235  void* pNext;
16242 
16245  void* pNext;
16255 
16257  VkDeviceAddress deviceAddress;
16258  VkDeviceSize stride;
16259  VkDeviceSize size;
16261 
16263  uint32_t width;
16264  uint32_t height;
16265  uint32_t depth;
16267 
16268 typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth);
16269 typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
16270 typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);
16271 typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress);
16272 typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader);
16273 typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize);
16274 
16275 #ifndef VK_NO_PROTOTYPES
16277  VkCommandBuffer commandBuffer,
16278  const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
16279  const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
16280  const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
16281  const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
16282  uint32_t width,
16283  uint32_t height,
16284  uint32_t depth);
16285 
16287  VkDevice device,
16288  VkDeferredOperationKHR deferredOperation,
16289  VkPipelineCache pipelineCache,
16290  uint32_t createInfoCount,
16291  const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
16292  const VkAllocationCallbacks* pAllocator,
16293  VkPipeline* pPipelines);
16294 
16296  VkDevice device,
16297  VkPipeline pipeline,
16298  uint32_t firstGroup,
16299  uint32_t groupCount,
16300  size_t dataSize,
16301  void* pData);
16302 
16304  VkCommandBuffer commandBuffer,
16305  const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
16306  const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
16307  const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
16308  const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
16309  VkDeviceAddress indirectDeviceAddress);
16310 
16312  VkDevice device,
16313  VkPipeline pipeline,
16314  uint32_t group,
16315  VkShaderGroupShaderKHR groupShader);
16316 
16318  VkCommandBuffer commandBuffer,
16319  uint32_t pipelineStackSize);
16320 #endif
16321 
16322 
16323 #define VK_KHR_ray_query 1
16324 #define VK_KHR_RAY_QUERY_SPEC_VERSION 1
16325 #define VK_KHR_RAY_QUERY_EXTENSION_NAME "VK_KHR_ray_query"
16328  void* pNext;
16329  VkBool32 rayQuery;
16331 
16332 
16333 
16334 #define VK_EXT_mesh_shader 1
16335 #define VK_EXT_MESH_SHADER_SPEC_VERSION 1
16336 #define VK_EXT_MESH_SHADER_EXTENSION_NAME "VK_EXT_mesh_shader"
16339  void* pNext;
16340  VkBool32 taskShader;
16341  VkBool32 meshShader;
16346 
16349  void* pNext;
16379 
16381  uint32_t groupCountX;
16382  uint32_t groupCountY;
16383  uint32_t groupCountZ;
16385 
16386 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
16387 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
16388 typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
16389 
16390 #ifndef VK_NO_PROTOTYPES
16392  VkCommandBuffer commandBuffer,
16393  uint32_t groupCountX,
16394  uint32_t groupCountY,
16395  uint32_t groupCountZ);
16396 
16398  VkCommandBuffer commandBuffer,
16399  VkBuffer buffer,
16400  VkDeviceSize offset,
16401  uint32_t drawCount,
16402  uint32_t stride);
16403 
16405  VkCommandBuffer commandBuffer,
16406  VkBuffer buffer,
16407  VkDeviceSize offset,
16408  VkBuffer countBuffer,
16409  VkDeviceSize countBufferOffset,
16410  uint32_t maxDrawCount,
16411  uint32_t stride);
16412 #endif
16413 
16414 #ifdef __cplusplus
16415 }
16416 #endif
16417 
16418 #endif
const VkPushConstantRange * pPushConstantRanges
Definition: vulkan_core.h:3627
void(VKAPI_PTR * PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:6380
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
void(VKAPI_PTR * PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
GLsizei GLenum GLsizei GLsizei GLuint memory
Definition: RE_OGL.h:202
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
uint32_t correlatedViewMaskCount
Definition: vulkan_core.h:6039
VkDeviceOrHostAddressConstKHR transformData
VkPipelineRobustnessImageBehaviorEXT images
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:6385
VkPointClippingBehavior pointClippingBehavior
Definition: vulkan_core.h:5847
char category[VK_MAX_DESCRIPTION_SIZE]
Definition: vulkan_core.h:8655
VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR
Definition: vulkan_core.h:9135
VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated
Definition: vulkan_core.h:6811
VkImageViewType viewType
Definition: vulkan_core.h:3397
struct VkGeneratedCommandsMemoryRequirementsInfoNV VkGeneratedCommandsMemoryRequirementsInfoNV
VkAccelerationStructureTypeNV type
VkAccelerationStructureMotionInstanceFlagsNV flags
VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR
Definition: vulkan_core.h:8733
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
VkImageLayout initialLayout
Definition: vulkan_core.h:5988
struct VkSparseImageMemoryRequirements VkSparseImageMemoryRequirements
VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions)
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
const VkPipelineShaderStageCreateInfo * pStages
VkPipelineStageFlags2 dstStageMask
Definition: vulkan_core.h:6903
struct VkShaderModuleIdentifierEXT VkShaderModuleIdentifierEXT
VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
uint32_t engineVersion
Definition: vulkan_core.h:2934
uint32_t maxDescriptorSetStorageBuffers
Definition: vulkan_core.h:3056
VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV VkPhysicalDeviceExternalMemoryRDMAFeaturesNV
const VkSampler * pImmutableSamplers
Definition: vulkan_core.h:3702
VkSharingMode sharingMode
Definition: vulkan_core.h:3371
struct VkDisplayPresentInfoKHR VkDisplayPresentInfoKHR
void(VKAPI_PTR * PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
const VkSwapchainKHR * pSwapchains
Definition: vulkan_core.h:7674
VkResult(VKAPI_PTR * PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:3972
void(VKAPI_PTR * PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
VkAttachmentStoreOp stencilStoreOp
Definition: vulkan_core.h:5987
VkImageUsageFlagBits
Definition: vulkan_core.h:2275
const uint64_t * pSignalSemaphoreValues
Definition: vulkan_core.h:6324
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
Definition: vulkan_core.h:7305
const void * pNext
Definition: vulkan_core.h:6045
VkResult(VKAPI_PTR * PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
Definition: vulkan_core.h:3927
struct VkWriteDescriptorSetAccelerationStructureNV VkWriteDescriptorSetAccelerationStructureNV
VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(VkDevice device)
VkSurfaceTransformFlagBitsKHR transform
struct VkRenderPassSampleLocationsBeginInfoEXT VkRenderPassSampleLocationsBeginInfoEXT
VkStructureType sType
VkResult(VKAPI_PTR * PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings)
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
VkStructureType sType
Definition: vulkan_core.h:7035
VkAttachmentDescription2 VkAttachmentDescription2KHR
Definition: vulkan_core.h:8448
VkMutableDescriptorTypeCreateInfoEXT VkMutableDescriptorTypeCreateInfoVALVE
GLenum query
Definition: glad.h:2772
VkOffset2D offset
Definition: vulkan_core.h:8374
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
struct VkDrawMeshTasksIndirectCommandNV VkDrawMeshTasksIndirectCommandNV
VkStructureType sType
Definition: vulkan_core.h:9556
void(VKAPI_PTR * PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
Definition: vulkan_core.h:9696
VkImageUsageFlags usage
Definition: vulkan_core.h:5276
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
const void * pNext
Definition: vulkan_core.h:2863
VkBool32 shaderStorageImageArrayDynamicIndexing
Definition: vulkan_core.h:3010
const VkSemaphore * pWaitSemaphores
Definition: vulkan_core.h:7672
VkSampleCountFlags framebufferStencilSampleCounts
Definition: vulkan_core.h:3114
struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV VkPhysicalDeviceRayTracingMotionBlurFeaturesNV
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
Definition: vulkan_core.h:8956
VkPipelineLayoutCreateFlagBits
Definition: vulkan_core.h:2655
VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
struct VkDeviceBufferMemoryRequirements VkDeviceBufferMemoryRequirements
struct VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeatures
VkStructureType sType
Definition: vulkan_core.h:2875
struct VkImportFenceFdInfoKHR VkImportFenceFdInfoKHR
void(VKAPI_PTR * PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4])
Definition: vulkan_core.h:4004
VkCopyMicromapModeEXT mode
VkSampleCountFlags sampledImageDepthSampleCounts
Definition: vulkan_core.h:3119
VkBlendFactor
Definition: vulkan_core.h:1768
VkResult(VKAPI_PTR * PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
Definition: vulkan_core.h:9150
uint32_t offset
Definition: vulkan_core.h:3421
VkDeviceSize memoryOffset
Definition: vulkan_core.h:3272
VkFlags VkPipelineCoverageToColorStateCreateFlagsNV
uint32_t maxTexelBufferElements
Definition: vulkan_core.h:3037
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
struct VkDrawIndirectCommand VkDrawIndirectCommand
VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR
Definition: vulkan_core.h:9729
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
VkImageAspectFlagBits
Definition: vulkan_core.h:2157
VkCompareOp compareOp
Definition: vulkan_core.h:3541
void(VKAPI_PTR * PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
VkStructureType sType
Definition: vulkan_core.h:8806
struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR
Definition: vulkan_core.h:8190
struct VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRobustnessFeatures
const uint64_t * pPresentIds
Definition: vulkan_core.h:9507
VkFlags VkSemaphoreWaitFlags
Definition: vulkan_core.h:5817
void(VKAPI_PTR * PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:4041
VkAccessFlags2 srcAccessMask
Definition: vulkan_core.h:6916
VkResult(VKAPI_PTR * PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
Definition: vulkan_core.h:3917
int32_t x
Definition: vulkan_core.h:2795
VkDescriptorType type
VkExtent2D physicalResolution
Definition: vulkan_core.h:7839
struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV
struct VkPhysicalDevicePresentBarrierFeaturesNV VkPhysicalDevicePresentBarrierFeaturesNV
void(VKAPI_PTR * PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:9789
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
struct VkValidationCacheCreateInfoEXT VkValidationCacheCreateInfoEXT
struct VkQueueFamilyGlobalPriorityPropertiesKHR VkQueueFamilyGlobalPriorityPropertiesKHR
VkRayTracingShaderGroupTypeKHR
VkStructureType sType
Definition: vulkan_core.h:8385
VkAccelerationStructureCreateFlagBitsKHR
VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes
uint32_t waitSemaphoreInfoCount
Definition: vulkan_core.h:6959
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT
struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV
VkSamplerAddressMode
Definition: vulkan_core.h:2032
VkSparseImageFormatProperties formatProperties
Definition: vulkan_core.h:3304
VkMemoryOverallocationBehaviorAMD overallocationBehavior
void(VKAPI_PTR * PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3987
VkSharingMode sharingMode
Definition: vulkan_core.h:3344
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
Definition: vulkan_core.h:9449
VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
VkOpticalFlowGridSizeFlagBitsNV
const void * pNext
Definition: vulkan_core.h:8386
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
struct VkIndirectCommandsStreamNV VkIndirectCommandsStreamNV
VkStructureType
Definition: vulkan_core.h:208
const char * displayName
Definition: vulkan_core.h:7837
VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VkResult(VKAPI_PTR * PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
GLbitfield flags
Definition: glcorearb.h:1596
VkExternalSemaphoreHandleTypeFlagBits handleType
Definition: vulkan_core.h:8306
VkSurfaceTransformFlagsKHR supportedTransforms
Definition: vulkan_core.h:7578
uint32_t bufferBindCount
Definition: vulkan_core.h:3287
uint32_t dstQueueFamilyIndex
Definition: vulkan_core.h:2826
VkPrimitiveTopology
Definition: vulkan_core.h:1957
const VkRayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface
VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
void(VKAPI_PTR * PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
Definition: vulkan_core.h:4003
VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT
VkFlags VkPipelineCoverageReductionStateCreateFlagsNV
void(VKAPI_PTR * PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes)
VkBool32(VKAPI_PTR * PFN_vkDebugReportCallbackEXT)(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage, void *pUserData)
Definition: vulkan_core.h:9873
VkSamplerAddressMode addressModeW
Definition: vulkan_core.h:3639
VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR
Definition: vulkan_core.h:8087
VkPhysicalDeviceProperties properties
Definition: vulkan_core.h:5201
const VkCommandBuffer * pCommandBuffers
Definition: vulkan_core.h:3215
struct VkPhysicalDeviceDiscardRectanglePropertiesEXT VkPhysicalDeviceDiscardRectanglePropertiesEXT
VkFlags VkPerformanceCounterDescriptionFlagsKHR
Definition: vulkan_core.h:8622
VkRenderPassCreateFlagBits
Definition: vulkan_core.h:2719
const VkDebugUtilsObjectNameInfoEXT * pObjects
VkCommandBuffer commandBuffer
Definition: vulkan_core.h:6951
VkSampleCountFlagBits depthStencilAttachmentSamples
Definition: vulkan_core.h:7975
VkResult(VKAPI_PTR * PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
Definition: vulkan_core.h:7294
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
Definition: vulkan_core.h:8759
uint32_t maxTessellationControlPerVertexOutputComponents
Definition: vulkan_core.h:3069
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceLayerProperties)(uint32_t *pPropertyCount, VkLayerProperties *pProperties)
Definition: vulkan_core.h:3921
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
void(VKAPI_PTR * PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
Definition: vulkan_core.h:4006
struct VkPipelineCoverageReductionStateCreateInfoNV VkPipelineCoverageReductionStateCreateInfoNV
VkViewportCoordinateSwizzleNV w
uint32_t maxDescriptorSetUniformBuffers
Definition: vulkan_core.h:3054
VkAccelerationStructureMotionInstanceTypeNV type
VkStructureType sType
Definition: vulkan_core.h:7086
VkExtent2D extent
Definition: vulkan_core.h:8375
struct VkPipelineViewportDepthClipControlCreateInfoEXT VkPipelineViewportDepthClipControlCreateInfoEXT
VkResult(VKAPI_PTR * PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
Definition: vulkan_core.h:3943
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts)
const uint32_t * pSignalSemaphoreDeviceIndices
Definition: vulkan_core.h:5121
VkDeviceMemory memory
Definition: vulkan_core.h:5057
VkFramebufferCreateFlags flags
Definition: vulkan_core.h:3746
VkResult(VKAPI_PTR * PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
Definition: vulkan_core.h:9353
VkResult(VKAPI_PTR * PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
Definition: vulkan_core.h:9299
struct VkInputAttachmentAspectReference VkInputAttachmentAspectReference
void(VKAPI_PTR * PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3989
VkImageLayout initialLayout
Definition: vulkan_core.h:3374
struct VkImageSubresource VkImageSubresource
VkDeviceSize minStorageBufferOffsetAlignment
Definition: vulkan_core.h:3101
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
VkOpticalFlowUsageFlagsNV usage
VkProvokingVertexModeEXT
VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
VkFlags VkInstanceCreateFlags
Definition: vulkan_core.h:2317
struct VkExportMemoryAllocateInfo VkExportMemoryAllocateInfo
VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
uint32_t regionCount
Definition: vulkan_core.h:7070
struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT VkPipelineShaderStageModuleIdentifierCreateInfoEXT
void(VKAPI_PTR * PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
VkStructureType sType
Definition: vulkan_core.h:3283
VkExtent3D extent
Definition: vulkan_core.h:7009
VkDeviceFaultVendorBinaryHeaderVersionEXT
VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR
Definition: vulkan_core.h:9649
struct VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeatures
VkExtent3D extent
Definition: vulkan_core.h:7082
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
Definition: vulkan_core.h:3937
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
VkViewportCoordinateSwizzleNV y
struct VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalDevicePipelineCreationCacheControlFeatures
struct VkViewport VkViewport
char extensionName[VK_MAX_EXTENSION_NAME_SIZE]
Definition: vulkan_core.h:3197
VkFlags VkCompositeAlphaFlagsKHR
Definition: vulkan_core.h:7569
VkDescriptorSetLayoutCreateFlagBits
Definition: vulkan_core.h:2683
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
VkResult(VKAPI_PTR * PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
VkPerformanceCounterScopeKHR
Definition: vulkan_core.h:8595
VkAttachmentStoreOp
Definition: vulkan_core.h:2079
PFN_vkDebugReportCallbackEXT pfnCallback
Definition: vulkan_core.h:9887
struct VkGraphicsPipelineLibraryCreateInfoEXT VkGraphicsPipelineLibraryCreateInfoEXT
char description[VK_MAX_DESCRIPTION_SIZE]
VkStructureType sType
Definition: vulkan_core.h:8642
VkResult(VKAPI_PTR * PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
const uint32_t * pImageIndices
Definition: vulkan_core.h:7675
void(VKAPI_PTR * PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
uint32_t height
Definition: vulkan_core.h:2790
void(VKAPI_PTR * PFN_vkUninitializePerformanceApiINTEL)(VkDevice device)
VkImageTiling tiling
Definition: vulkan_core.h:3369
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities)
void(VKAPI_PTR * PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
void(VKAPI_PTR * PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT VkPhysicalDeviceFragmentDensityMapPropertiesEXT
struct VkDisplayPlanePropertiesKHR VkDisplayPlanePropertiesKHR
VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR
Definition: vulkan_core.h:8172
VkDynamicState
Definition: vulkan_core.h:1858
VkFormatFeatureFlags2 drmFormatModifierTilingFeatures
uint32_t VkBool32
Definition: vulkan_core.h:93
uint32_t swapchainCount
Definition: vulkan_core.h:7673
VkResult(VKAPI_PTR * PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
void(VKAPI_PTR * PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7589
const VkViewportSwizzleNV * pViewportSwizzles
int int32
Definition: SYS_Types.h:39
VkBool32 drawIndirectFirstInstance
Definition: vulkan_core.h:2984
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
void(VKAPI_PTR * PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2EXT *pSubresource, VkSubresourceLayout2EXT *pLayout)
VkClearDepthStencilValue depthStencil
Definition: vulkan_core.h:3858
struct VkPipelineExecutableStatisticKHR VkPipelineExecutableStatisticKHR
VkDeviceMemory memory
Definition: vulkan_core.h:3244
struct VkVertexInputBindingDivisorDescriptionEXT VkVertexInputBindingDivisorDescriptionEXT
VkColorComponentFlags colorWriteMask
Definition: vulkan_core.h:3570
VkResolveModeFlagBits depthResolveMode
Definition: vulkan_core.h:6183
struct VkBufferImageCopy VkBufferImageCopy
VkAccessFlags2 VkAccessFlags2KHR
Definition: vulkan_core.h:9525
VkFlags VkConditionalRenderingFlagsEXT
const VkPipelineRasterizationStateCreateInfo * pRasterizationState
Definition: vulkan_core.h:3602
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
struct VkComputePipelineCreateInfo VkComputePipelineCreateInfo
void(VKAPI_PTR * PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
Definition: vulkan_core.h:4027
VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR
Definition: vulkan_core.h:8267
void(VKAPI_PTR * PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
VkFlags VkBufferUsageFlags
Definition: vulkan_core.h:2515
struct VkExternalImageFormatProperties VkExternalImageFormatProperties
struct VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewProperties
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
void(VKAPI_PTR * PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
struct VkCopyAccelerationStructureToMemoryInfoKHR VkCopyAccelerationStructureToMemoryInfoKHR
struct VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntry
VkDrmFormatModifierProperties2EXT * pDrmFormatModifierProperties
struct VkPhysicalDeviceMaintenance4Features VkPhysicalDeviceMaintenance4Features
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
VkResult(VKAPI_PTR * PFN_vkResetEvent)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3952
struct VkPipelineDepthStencilStateCreateInfo VkPipelineDepthStencilStateCreateInfo
VkSamplerYcbcrModelConversion ycbcrModel
Definition: vulkan_core.h:5350
VkCommandBufferResetFlagBits
Definition: vulkan_core.h:2769
const VkDescriptorSetLayout * pSetLayouts
Definition: vulkan_core.h:3694
VkFlags VkFormatFeatureFlags
Definition: vulkan_core.h:2231
struct VkPhysicalDeviceProtectedMemoryFeatures VkPhysicalDeviceProtectedMemoryFeatures
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
VkPipelineCreationFeedbackFlagBits
Definition: vulkan_core.h:6469
VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT
struct VkImageFormatProperties2 VkImageFormatProperties2
VkGeometryDataNV geometry
VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR
Definition: vulkan_core.h:9117
struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT
VkOffset3D srcOffset
Definition: vulkan_core.h:3882
const VkSemaphoreSubmitInfo * pWaitSemaphoreInfos
Definition: vulkan_core.h:6960
const VkBufferCopy2 * pRegions
Definition: vulkan_core.h:6999
VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
VkOpticalFlowPerformanceLevelNV performanceLevel
const void * pNext
Definition: vulkan_core.h:6995
VkResult(VKAPI_PTR * PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
Definition: vulkan_core.h:3955
struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV VkPhysicalDeviceInheritedViewportScissorFeaturesNV
void(VKAPI_PTR * PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
Definition: vulkan_core.h:7323
void(VKAPI_PTR * PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3959
void(VKAPI_PTR * PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
void(VKAPI_PTR * PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
VkPhysicalDeviceInlineUniformBlockProperties VkPhysicalDeviceInlineUniformBlockPropertiesEXT
struct VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2
struct VkAttachmentSampleCountInfoAMD VkAttachmentSampleCountInfoAMD
VkImageMemoryBarrier2 VkImageMemoryBarrier2KHR
Definition: vulkan_core.h:9537
VkDeviceSize indexOffset
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:8310
void(VKAPI_PTR * PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
Definition: vulkan_core.h:7322
VkShaderStageFlags stageFlags
Definition: vulkan_core.h:3701
VkResult
Definition: vulkan_core.h:139
VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
VkDescriptorSetLayout descriptorSetLayout
Definition: vulkan_core.h:5405
uint32_t imageBindCount
Definition: vulkan_core.h:3291
VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
VkScopeNV
VkFlags VkPipelineVertexInputStateCreateFlags
Definition: vulkan_core.h:2631
void(VKAPI_PTR * PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
Definition: vulkan_core.h:7308
struct VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfo
VkFlags VkSampleCountFlags
Definition: vulkan_core.h:2273
struct VkAccelerationStructureBuildGeometryInfoKHR VkAccelerationStructureBuildGeometryInfoKHR
VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
uint32_t preserveAttachmentCount
Definition: vulkan_core.h:6012
struct VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeatures
VkPipelineRobustnessImageBehaviorEXT
VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
VkFenceCreateFlagBits
Definition: vulkan_core.h:2418
void(VKAPI_PTR * PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
Definition: vulkan_core.h:7310
VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
struct VkBindAccelerationStructureMemoryInfoNV VkBindAccelerationStructureMemoryInfoNV
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
VkStructureType sType
#define VKAPI_CALL
Definition: vk_platform.h:57
struct VkBufferCopy2 VkBufferCopy2
struct VkImageViewMinLodCreateInfoEXT VkImageViewMinLodCreateInfoEXT
VkDeviceOrHostAddressConstKHR src
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
struct VkAccelerationStructureBuildRangeInfoKHR VkAccelerationStructureBuildRangeInfoKHR
VkPipeline pipeline
Definition: vulkan_core.h:9404
VkDeviceSize offset
Definition: vulkan_core.h:3378
VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR
Definition: vulkan_core.h:8257
struct VkExtensionProperties VkExtensionProperties
VkDeviceSize size
Definition: vulkan_core.h:2964
VkStructureType sType
Definition: vulkan_core.h:3209
VkDeviceSize vendorBinarySize
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
VkImageAspectFlagBits planeAspect
Definition: vulkan_core.h:7288
void(VKAPI_PTR * PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
void(VKAPI_PTR * PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT
void(VKAPI_PTR * PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
const VkDescriptorAddressInfoEXT * pStorageTexelBuffer
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
VkCommandPoolResetFlagBits
Definition: vulkan_core.h:2749
struct VkDescriptorGetInfoEXT VkDescriptorGetInfoEXT
struct VkPhysicalDeviceShaderTerminateInvocationFeatures VkPhysicalDeviceShaderTerminateInvocationFeatures
VkPipelineCreationFeedback * pPipelineCreationFeedback
Definition: vulkan_core.h:6838
struct VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64Features
VkSamplerCreateFlags flags
Definition: vulkan_core.h:3633
VkBufferCopy2 VkBufferCopy2KHR
Definition: vulkan_core.h:9682
VkExternalFenceHandleTypeFlags handleTypes
Definition: vulkan_core.h:5488
VkAccelerationStructureKHR dst
const VkApplicationInfo * pApplicationInfo
Definition: vulkan_core.h:2956
VkFlags VkPipelineDynamicStateCreateFlags
Definition: vulkan_core.h:2653
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkCopyImageToBufferInfo2 VkCopyImageToBufferInfo2KHR
Definition: vulkan_core.h:9676
void(VKAPI_PTR * PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:5552
VkSampleCountFlags framebufferColorSampleCounts
Definition: vulkan_core.h:3112
VkBorderColor
Definition: vulkan_core.h:2012
struct VkGraphicsPipelineShaderGroupsCreateInfoNV VkGraphicsPipelineShaderGroupsCreateInfoNV
const VkSparseBufferMemoryBindInfo * pBufferBinds
Definition: vulkan_core.h:3288
VkExternalSemaphoreHandleTypeFlagBits handleType
Definition: vulkan_core.h:8298
VkMemoryOverallocationBehaviorAMD
VkQueueFamilyGlobalPriorityPropertiesKHR VkQueueFamilyGlobalPriorityPropertiesEXT
VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers
struct VkRenderPassCreateInfo2 VkRenderPassCreateInfo2
struct VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParametersFeatures
VkQueryPipelineStatisticFlagBits
Definition: vulkan_core.h:2432
void(VKAPI_PTR * PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts)
struct VkAccelerationStructureDeviceAddressInfoKHR VkAccelerationStructureDeviceAddressInfoKHR
VkPointClippingBehavior VkPointClippingBehaviorKHR
Definition: vulkan_core.h:8721
struct VkPhysicalDeviceOpticalFlowPropertiesNV VkPhysicalDeviceOpticalFlowPropertiesNV
VkBuildAccelerationStructureFlagsKHR flags
PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback
VkBool32 shaderSampledImageArrayNonUniformIndexingNative
Definition: vulkan_core.h:5940
uint32_t dstBinding
Definition: vulkan_core.h:5390
struct VkSampleLocationEXT VkSampleLocationEXT
const VkImageView * pAttachments
Definition: vulkan_core.h:3749
struct VkPhysicalDeviceDescriptorBufferFeaturesEXT VkPhysicalDeviceDescriptorBufferFeaturesEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples
Definition: vulkan_core.h:9230
struct VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlineUniformBlock
VkStencilOp depthFailOp
Definition: vulkan_core.h:3540
VkRayTracingInvocationReorderModeNV
struct VkPhysicalDeviceRobustness2PropertiesEXT VkPhysicalDeviceRobustness2PropertiesEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties)
VkPhysicalDeviceMaintenance4Features VkPhysicalDeviceMaintenance4FeaturesKHR
Definition: vulkan_core.h:9781
struct VkIndirectCommandsLayoutTokenNV VkIndirectCommandsLayoutTokenNV
VkIndirectStateFlagsNV indirectStateFlags
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
union VkAccelerationStructureGeometryDataKHR VkAccelerationStructureGeometryDataKHR
struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV VkPhysicalDeviceCopyMemoryIndirectPropertiesNV
VkFlags VkDescriptorPoolResetFlags
Definition: vulkan_core.h:2681
VkExtent3D minImageTransferGranularity
Definition: vulkan_core.h:3171
struct VkRayTracingShaderGroupCreateInfoKHR VkRayTracingShaderGroupCreateInfoKHR
struct VkDisplayPlaneProperties2KHR VkDisplayPlaneProperties2KHR
VkImageLayout srcImageLayout
Definition: vulkan_core.h:7048
struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV VkPipelineFragmentShadingRateEnumStateCreateInfoNV
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6376
void(VKAPI_PTR * PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
VkPipelineExecutableStatisticValueKHR value
Definition: vulkan_core.h:9436
VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
VkGeometryFlagsKHR flags
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
void(VKAPI_PTR * PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
VkImageLayout dstImageLayout
Definition: vulkan_core.h:7091
const VkDescriptorAddressInfoEXT * pStorageBuffer
union VkPerformanceCounterResultKHR VkPerformanceCounterResultKHR
VkStructureType sType
Definition: vulkan_core.h:7648
VkDeviceAddress deviceAddress
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:4015
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR
Definition: vulkan_core.h:8928
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
Definition: vulkan_core.h:8036
uint32_t layerCount
Definition: vulkan_core.h:3870
VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
struct VkCoarseSampleOrderCustomNV VkCoarseSampleOrderCustomNV
struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures
VkPipelineDynamicStateCreateFlags flags
Definition: vulkan_core.h:3587
VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
VkFlags VkBufferViewCreateFlags
Definition: vulkan_core.h:2516
VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
struct VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayout
VkRenderPassCreateFlags flags
Definition: vulkan_core.h:6032
struct VkPresentTimeGOOGLE VkPresentTimeGOOGLE
VkOpacityMicromapFormatEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
VkExternalMemoryHandleTypeFlags handleTypes
Definition: vulkan_core.h:5456
VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint
VkFlags VkExternalMemoryHandleTypeFlags
Definition: vulkan_core.h:4970
VkTessellationDomainOrigin
Definition: vulkan_core.h:4862
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
VkSemaphoreWaitFlagBits
Definition: vulkan_core.h:5812
const uint32_t * pCorrelationMasks
Definition: vulkan_core.h:5293
uint32_t maxPerStageDescriptorInputAttachments
Definition: vulkan_core.h:3051
const VkSemaphore * pWaitSemaphores
Definition: vulkan_core.h:3212
struct VkSubresourceLayout VkSubresourceLayout
VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
VkPhysicalDeviceTextureCompressionASTCHDRFeatures VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
VkStructureType sType
Definition: vulkan_core.h:5054
void
Definition: png.h:1083
VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
void(VKAPI_PTR * PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence)
void(VKAPI_PTR * PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
struct VkPhysicalDeviceMemoryDecompressionFeaturesNV VkPhysicalDeviceMemoryDecompressionFeaturesNV
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer)
struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR
VkResult(VKAPI_PTR * PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
Definition: vulkan_core.h:3945
struct VkDebugUtilsObjectNameInfoEXT VkDebugUtilsObjectNameInfoEXT
VkPerformanceCounterScopeKHR scope
Definition: vulkan_core.h:8645
VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
uint32_t enabledExtensionCount
Definition: vulkan_core.h:2959
VkDisplayPlaneAlphaFlagBitsKHR alphaMode
Definition: vulkan_core.h:7854
VkPipelineCacheHeaderVersion
Definition: vulkan_core.h:1245
void(VKAPI_PTR * PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
VkImageSubresourceRange subresourceRange
Definition: vulkan_core.h:3400
VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR
Definition: vulkan_core.h:8511
void(VKAPI_PTR * PFN_vkDeviceMemoryReportCallbackEXT)(const VkDeviceMemoryReportCallbackDataEXT *pCallbackData, void *pUserData)
VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
const uint32_t * pDeviceMasks
Definition: vulkan_core.h:7713
uint32_t enabledValidationFeatureCount
struct VkDescriptorSetLayoutCreateInfo VkDescriptorSetLayoutCreateInfo
VkShaderStageFlags pushconstantShaderStageFlags
struct VkAmigoProfilingSubmitInfoSEC VkAmigoProfilingSubmitInfoSEC
const void * pNext
struct VkBufferDeviceAddressInfo VkBufferDeviceAddressInfo
VkBool32 integerDotProduct32BitMixedSignednessAccelerated
Definition: vulkan_core.h:6804
GLboolean * data
Definition: glcorearb.h:131
const void * pNext
Definition: vulkan_core.h:3284
VkShaderCorePropertiesFlagBitsAMD
VkResult(VKAPI_PTR * PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
VkFlags VkExternalFenceFeatureFlags
Definition: vulkan_core.h:5003
VkStructureType sType
Definition: vulkan_core.h:6956
VkResult(VKAPI_PTR * PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
Definition: vulkan_core.h:7861
VkResult(VKAPI_PTR * PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
Definition: vulkan_core.h:3941
void(VKAPI_PTR * PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR
Definition: vulkan_core.h:8174
VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
void(VKAPI_PTR * PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:8103
VkStructureType sType
Definition: vulkan_core.h:3312
VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
void(VKAPI_PTR * PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer)
struct VkRayTracingPipelineCreateInfoKHR VkRayTracingPipelineCreateInfoKHR
VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR
Definition: vulkan_core.h:8079
VkComponentSwizzle g
Definition: vulkan_core.h:3387
VkExportFenceCreateInfo VkExportFenceCreateInfoKHR
Definition: vulkan_core.h:8538
VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
const VkSampleCountFlagBits * pColorAttachmentSamples
Definition: vulkan_core.h:7974
struct VkOffset3D VkOffset3D
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
void(VKAPI_PTR * PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
struct VkBufferCaptureDescriptorDataInfoEXT VkBufferCaptureDescriptorDataInfoEXT
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV
struct VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfo
uint32_t maxViewportDimensions[2]
Definition: vulkan_core.h:3095
uint32_t subPixelPrecisionBits
Definition: vulkan_core.h:3087
struct VkPhysicalDeviceAccelerationStructurePropertiesKHR VkPhysicalDeviceAccelerationStructurePropertiesKHR
VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV
struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV
struct VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfo
VkResult(VKAPI_PTR * PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:9330
uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers
Definition: vulkan_core.h:5954
VkAccelerationStructureKHR src
VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]
const char * pLabelName
VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event)
void(VKAPI_PTR * PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth)
Definition: vulkan_core.h:4002
VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR
Definition: vulkan_core.h:8871
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
struct VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfo
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
struct VkPhysicalDeviceInlineUniformBlockFeatures VkPhysicalDeviceInlineUniformBlockFeatures
VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
VkStructureType sType
Definition: vulkan_core.h:6337
void(VKAPI_PTR * PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
Definition: vulkan_core.h:3962
const VkAttachmentReference * pColorAttachments
Definition: vulkan_core.h:3761
VkMemoryAllocateFlagBits
Definition: vulkan_core.h:4934
VkBool32 integerDotProduct64BitMixedSignednessAccelerated
Definition: vulkan_core.h:6807
VkResult(VKAPI_PTR * PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
struct VkFormatProperties2 VkFormatProperties2
const VkDescriptorImageInfo * pSampledImage
VkResult(VKAPI_PTR * PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
Definition: vulkan_core.h:3967
VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
VkDescriptorSet dstSet
Definition: vulkan_core.h:3657
void(VKAPI_PTR * PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
Definition: vulkan_core.h:7319
VkDisplayEventTypeEXT
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping)
VkBool32 shaderInputAttachmentArrayDynamicIndexing
Definition: vulkan_core.h:5868
VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated
Definition: vulkan_core.h:6812
VkResult(VKAPI_PTR * PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode)
Definition: vulkan_core.h:7862
struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV
const VkBufferImageCopy2 * pRegions
Definition: vulkan_core.h:7041
const void * pNext
Definition: vulkan_core.h:6957
VkExtent2D maxSampleLocationGridSize
VkResult(VKAPI_PTR * PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties)
VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR
Definition: vulkan_core.h:8926
VkStencilOp passOp
Definition: vulkan_core.h:3539
VKAPI_ATTR void VKAPI_CALL vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
uint32_t signalSemaphoreCount
Definition: vulkan_core.h:3293
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
const void * pNext
Definition: vulkan_core.h:3340
VkExternalMemoryProperties externalMemoryProperties
Definition: vulkan_core.h:5440
VkFramebufferCreateFlagBits
Definition: vulkan_core.h:2712
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
void(VKAPI_PTR * PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
Definition: vulkan_core.h:8408
struct VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfo
uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments
Definition: vulkan_core.h:5951
uint32_t colorAttachment
Definition: vulkan_core.h:3863
void(VKAPI_PTR * PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
Definition: vulkan_core.h:9991
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT VkPhysicalDeviceExtendedDynamicStateFeaturesEXT
VkStructureType sType
Definition: vulkan_core.h:5211
struct VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfo
VkSamplerYcbcrRange
Definition: vulkan_core.h:4884
VkPipelineCompilerControlFlagsAMD compilerControlFlags
void(VKAPI_PTR * PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
Definition: vulkan_core.h:9563
VkImageCompressionFixedRateFlagBitsEXT
float maxDepth
Definition: vulkan_core.h:3496
VkExternalFenceFeatureFlagBits
Definition: vulkan_core.h:4996
struct VkPhysicalDeviceCooperativeMatrixPropertiesNV VkPhysicalDeviceCooperativeMatrixPropertiesNV
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
VkDebugUtilsMessageSeverityFlagsEXT messageSeverity
struct VkBufferCopy VkBufferCopy
VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR
Definition: vulkan_core.h:8016
VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures
Definition: vulkan_core.h:5530
VkDeviceSize hitShaderBindingTableStride
Definition: vulkan_core.h:9755
VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT
VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR
Definition: vulkan_core.h:8905
uint32_t colorAttachmentCount
Definition: vulkan_core.h:6008
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
struct VkPhysicalDeviceAddressBindingReportFeaturesEXT VkPhysicalDeviceAddressBindingReportFeaturesEXT
VkSubpassDependency2 VkSubpassDependency2KHR
Definition: vulkan_core.h:8454
void(VKAPI_PTR * PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
Definition: vulkan_core.h:7307
VkOpticalFlowSessionBindingPointNV
struct VkMemoryGetRemoteAddressInfoNV VkMemoryGetRemoteAddressInfoNV
VkResult(VKAPI_PTR * PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
Definition: vulkan_core.h:3970
struct VkSubpassDependency2 VkSubpassDependency2
void(VKAPI_PTR * PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
Definition: vulkan_core.h:4000
VkPipelineShaderStageCreateInfo stage
Definition: vulkan_core.h:3446
struct VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfo
VkImageAspectFlagBits planeAspect
Definition: vulkan_core.h:5374
struct VkMicromapUsageEXT VkMicromapUsageEXT
VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR
Definition: vulkan_core.h:8182
VkPerformanceCounterStorageKHR storage
Definition: vulkan_core.h:8646
VkSurfaceTransformFlagBitsKHR transform
Definition: vulkan_core.h:7852
VkExternalFenceHandleTypeFlagBits handleType
Definition: vulkan_core.h:8550
VkResult(VKAPI_PTR * PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue)
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
Definition: vulkan_core.h:3938
VkQueryPoolSamplingModeINTEL
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
Definition: vulkan_core.h:3909
VkDebugReportObjectTypeEXT
Definition: vulkan_core.h:9817
void(VKAPI_PTR * PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3957
void(VKAPI_PTR * PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
struct VkRenderingAttachmentInfo VkRenderingAttachmentInfo
VkBool32 shaderImageGatherExtended
Definition: vulkan_core.h:3002
struct VkPastPresentationTimingGOOGLE VkPastPresentationTimingGOOGLE
VkDeviceOrHostAddressConstKHR data
VkDeviceAddressBindingTypeEXT bindingType
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
VkDeviceAddressBindingTypeEXT
struct VkPhysicalDeviceASTCDecodeFeaturesEXT VkPhysicalDeviceASTCDecodeFeaturesEXT
VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR
Definition: vulkan_core.h:9286
struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM
VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
VkBool32 descriptorBindingStorageImageUpdateAfterBind
Definition: vulkan_core.h:5880
VkDeviceAddress raygenShaderRecordAddress
Definition: vulkan_core.h:9748
uint32_t maxSamplerAllocationCount
Definition: vulkan_core.h:3042
VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
GLuint64 GLenum handleType
Definition: RE_OGL.h:262
#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
Definition: vulkan_core.h:133
VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
struct VkDisplayPlaneCapabilitiesKHR VkDisplayPlaneCapabilitiesKHR
struct VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfo
void(VKAPI_PTR * PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
VkImageLayout resolveImageLayout
Definition: vulkan_core.h:7161
VkPerformanceConfigurationTypeINTEL
VkImageLayout newLayout
Definition: vulkan_core.h:2867
VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV
VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR
Definition: vulkan_core.h:9320
VkStructureType sType
Definition: vulkan_core.h:2816
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
struct VkPerformanceStreamMarkerInfoINTEL VkPerformanceStreamMarkerInfoINTEL
void(VKAPI_PTR * PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
Definition: vulkan_core.h:9693
VkStructureType sType
Definition: vulkan_core.h:6044
VkSampleCountFlagBits rasterizationSamples
struct VkAttachmentSampleLocationsEXT VkAttachmentSampleLocationsEXT
VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags
VkAccessFlags2 srcAccessMask
Definition: vulkan_core.h:6893
void(VKAPI_PTR * PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
char description[VK_MAX_DESCRIPTION_SIZE]
struct VkAccelerationStructureCreateInfoKHR VkAccelerationStructureCreateInfoKHR
VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR
Definition: vulkan_core.h:8920
struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT VkPhysicalDeviceImage2DViewOf3DFeaturesEXT
VkOpticalFlowGridSizeFlagsNV outputGridSize
struct VkPhysicalDeviceTransformFeedbackPropertiesEXT VkPhysicalDeviceTransformFeedbackPropertiesEXT
VkFlags64 VkPipelineStageFlagBits2
Definition: vulkan_core.h:6500
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
void(VKAPI_PTR * PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3979
const VkBufferCreateInfo * pCreateInfo
Definition: vulkan_core.h:7281
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
VkPrivateDataSlot VkPrivateDataSlotEXT
VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated
Definition: vulkan_core.h:6809
struct VkTraceRaysIndirectCommandKHR VkTraceRaysIndirectCommandKHR
void(VKAPI_PTR * PFN_vkFreeFunction)(void *pUserData, void *pMemory)
Definition: vulkan_core.h:2895
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
VkSampleLocationsInfoEXT sampleLocationsInfo
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
uint32_t swapchainCount
Definition: vulkan_core.h:9506
VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets)
struct VkComponentMapping VkComponentMapping
VkPipelineDepthStencilStateCreateFlagBits
Definition: vulkan_core.h:2638
const VkIndexType * pIndexTypes
VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
struct VkRayTracingShaderGroupCreateInfoNV VkRayTracingShaderGroupCreateInfoNV
VkPhysicalDeviceShaderIntegerDotProductProperties VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR
Definition: vulkan_core.h:9479
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:8994
VkFlags VkDebugUtilsMessageTypeFlagsEXT
VkSemaphoreWaitFlags flags
Definition: vulkan_core.h:6330
VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR VkPhysicalDeviceFragmentShadingRateFeaturesKHR
const void * pNext
Definition: vulkan_core.h:3222
struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV VkPipelineRepresentativeFragmentTestStateCreateInfoNV
VkGeometryFlagBitsKHR VkGeometryFlagBitsNV
struct VkMemoryPriorityAllocateInfoEXT VkMemoryPriorityAllocateInfoEXT
struct VkRenderPassSubpassFeedbackInfoEXT VkRenderPassSubpassFeedbackInfoEXT
VkBool32 textureCompressionASTC_LDR
Definition: vulkan_core.h:2995
const VkImageMemoryBarrier2 * pImageMemoryBarriers
Definition: vulkan_core.h:6936
VkFlags VkSparseImageFormatFlags
Definition: vulkan_core.h:2416
VkDescriptorSetLayout descriptorSetLayout
struct VkPhysicalDevicePresentWaitFeaturesKHR VkPhysicalDevicePresentWaitFeaturesKHR
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
Definition: vulkan_core.h:5543
VkImageSubresource imageSubresource
VkDeviceOrHostAddressConstKHR src
VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]
Definition: vulkan_core.h:3142
VkStructureType sType
Definition: vulkan_core.h:8788
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
VkConditionalRenderingFlagsEXT flags
VkStructureType sType
Definition: vulkan_core.h:5205
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
VkColorComponentFlagBits
Definition: vulkan_core.h:2534
VkPhysicalDeviceShaderTerminateInvocationFeatures VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR
Definition: vulkan_core.h:9180
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
void(VKAPI_PTR * PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
Definition: vulkan_core.h:7302
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
Definition: vulkan_core.h:3914
uint32_t inputAttachmentCount
Definition: vulkan_core.h:6006
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
struct VkSubpassDescription VkSubpassDescription
VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT
VkFlags VkPipelineMultisampleStateCreateFlags
Definition: vulkan_core.h:2636
struct VkShadingRatePaletteNV VkShadingRatePaletteNV
struct VkQueueFamilyProperties VkQueueFamilyProperties
void(VKAPI_PTR * PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
Definition: vulkan_core.h:7297
VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
VkMicromapCreateFlagsEXT createFlags
struct VkGeometryDataNV VkGeometryDataNV
void(VKAPI_PTR * PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetDeviceProcAddr)(VkDevice device, const char *pName)
Definition: vulkan_core.h:3916
struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR
VkPipelineCoverageReductionStateCreateFlagsNV flags
VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
VkFlags VkShaderModuleCreateFlags
Definition: vulkan_core.h:2525
const char *const * ppEnabledExtensionNames
Definition: vulkan_core.h:3192
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
Definition: vulkan_core.h:5557
VkDisplayModeKHR displayMode
Definition: vulkan_core.h:7814
struct VkPhysicalDeviceFaultFeaturesEXT VkPhysicalDeviceFaultFeaturesEXT
VkAccessFlags srcAccessMask
Definition: vulkan_core.h:2864
struct VkPhysicalDeviceProtectedMemoryProperties VkPhysicalDeviceProtectedMemoryProperties
VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR
Definition: vulkan_core.h:8446
struct VkMemoryGetFdInfoKHR VkMemoryGetFdInfoKHR
void(VKAPI_PTR * PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
Definition: vulkan_core.h:7987
struct VkPhysicalDeviceRobustness2FeaturesEXT VkPhysicalDeviceRobustness2FeaturesEXT
VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
VkFlags VkCullModeFlags
Definition: vulkan_core.h:2630
VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
VkStructureType sType
Definition: vulkan_core.h:3897
VkFlags VkColorComponentFlags
Definition: vulkan_core.h:2541
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
VkPipelineStageFlags checkpointExecutionStageMask
struct VkSwapchainCreateInfoKHR VkSwapchainCreateInfoKHR
struct VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfo
VkStructureType sType
Definition: vulkan_core.h:7168
VkFlags VkRenderPassCreateFlags
Definition: vulkan_core.h:2723
struct VkMemoryRequirements VkMemoryRequirements
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
Definition: vulkan_core.h:8035
const VkSemaphore * pSemaphores
Definition: vulkan_core.h:6332
struct VkOpticalFlowSessionCreateInfoNV VkOpticalFlowSessionCreateInfoNV
VkBool32 shaderUniformBufferArrayDynamicIndexing
Definition: vulkan_core.h:3007
struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR VkPhysicalDeviceFragmentShadingRatePropertiesKHR
VkDeviceSize alignment
Definition: vulkan_core.h:3237
VkSurfaceTransformFlagBitsKHR preTransform
Definition: vulkan_core.h:7661
VkDisplayPowerStateEXT
VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
VkStructureType sType
Definition: vulkan_core.h:3360
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
Definition: vulkan_core.h:7729
struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferDeviceAddressFeaturesEXT
float maxContentLightLevel
VkImageCopy2 VkImageCopy2KHR
Definition: vulkan_core.h:9684
VkDescriptorDataEXT data
VkResult(VKAPI_PTR * PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
void(VKAPI_PTR * PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
VkPipelineCreateFlagBits
Definition: vulkan_core.h:2543
VkImageSubresourceLayers srcSubresource
Definition: vulkan_core.h:7005
VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
VkAccelerationStructureGeometryTrianglesDataKHR triangles
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Definition: vulkan_core.h:8269
struct VkSubmitInfo VkSubmitInfo
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
Definition: vulkan_core.h:7591
VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR
Definition: vulkan_core.h:8873
VkResult(VKAPI_PTR * PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
Definition: vulkan_core.h:3969
void(VKAPI_PTR * PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
void(VKAPI_PTR * PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
VkStructureType sType
Definition: vulkan_core.h:3175
VkStructureType sType
Definition: vulkan_core.h:9504
VkResult(VKAPI_PTR * PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
void(VKAPI_PTR * PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
void(VKAPI_PTR * PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions)
VkStructureType sType
Definition: vulkan_core.h:9402
#define VK_MAX_DRIVER_INFO_SIZE
Definition: vulkan_core.h:5714
VkDeviceQueueCreateFlagBits
Definition: vulkan_core.h:2359
void(VKAPI_PTR * PFN_vkReleaseProfilingLockKHR)(VkDevice device)
Definition: vulkan_core.h:8692
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
void(VKAPI_PTR * PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
VkResolveModeFlags supportedDepthResolveModes
Definition: vulkan_core.h:5961
struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR VkPhysicalDeviceRayTracingPipelineFeaturesKHR
struct VkDeviceDeviceMemoryReportCreateInfoEXT VkDeviceDeviceMemoryReportCreateInfoEXT
VkDisplayModeCreateFlagsKHR flags
Definition: vulkan_core.h:7809
VkDeviceSize bufferImageGranularity
Definition: vulkan_core.h:3043
struct VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolve
VkResult(VKAPI_PTR * PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
VkStructureType sType
Definition: vulkan_core.h:7064
VkResult(VKAPI_PTR * PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
Definition: vulkan_core.h:8691
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkFlags VkPipelineLayoutCreateFlags
Definition: vulkan_core.h:2659
#define VK_MAX_DRIVER_NAME_SIZE
Definition: vulkan_core.h:5713
VkFlags VkCommandPoolTrimFlags
Definition: vulkan_core.h:4944
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
Definition: vulkan_core.h:5556
VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
struct VkBindVertexBufferIndirectCommandNV VkBindVertexBufferIndirectCommandNV
VkFilter
Definition: vulkan_core.h:2024
const void * pNext
Definition: vulkan_core.h:3325
struct VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfo
void(VKAPI_PTR * PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
uint32_t rectangleCount
Definition: vulkan_core.h:8380
void(VKAPI_PTR * PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:9892
VkFormatFeatureFlags bufferFeatures
Definition: vulkan_core.h:2941
VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
void(VKAPI_PTR * PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
Definition: vulkan_core.h:6381
struct VkPipelineRasterizationStateRasterizationOrderAMD VkPipelineRasterizationStateRasterizationOrderAMD
struct VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfo
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
Definition: vulkan_core.h:7592
VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR
Definition: vulkan_core.h:8138
uint8_t deviceUUID[VK_UUID_SIZE]
Definition: vulkan_core.h:5838
VkImageLayout dstImageLayout
Definition: vulkan_core.h:7069
VkStructureType sType
Definition: vulkan_core.h:7055
VkFlags64 VkAccessFlags2
Definition: vulkan_core.h:6579
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
VkResult(VKAPI_PTR * PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
Definition: vulkan_core.h:7731
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT VkPhysicalDeviceImageDrmFormatModifierInfoEXT
const void * pNext
Definition: vulkan_core.h:3361
VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkDeviceEventTypeEXT deviceEvent
struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
VkBool32 shaderInputAttachmentArrayNonUniformIndexing
Definition: vulkan_core.h:5875
VkImageSubresourceLayers dstSubresource
Definition: vulkan_core.h:3876
VkFlags VkDisplayPlaneAlphaFlagsKHR
Definition: vulkan_core.h:7799
VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
Definition: vulkan_core.h:8819
void(VKAPI_PTR * PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
struct VkPerformanceConfigurationAcquireInfoINTEL VkPerformanceConfigurationAcquireInfoINTEL
VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
VkSamplerYcbcrConversion conversion
Definition: vulkan_core.h:5362
VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
Definition: vulkan_core.h:5542
VkAttachmentLoadOp loadOp
Definition: vulkan_core.h:3730
struct VkDeviceCreateInfo VkDeviceCreateInfo
struct VkBufferImageCopy2 VkBufferImageCopy2
VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR
Definition: vulkan_core.h:8778
VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]
VkSparseMemoryBindFlags flags
Definition: vulkan_core.h:3246
struct VkCooperativeMatrixPropertiesNV VkCooperativeMatrixPropertiesNV
const VkRect2D * pDeviceRenderAreas
Definition: vulkan_core.h:5104
struct VkPipelineDynamicStateCreateInfo VkPipelineDynamicStateCreateInfo
VkPipelineStageFlags srcStageMask
Definition: vulkan_core.h:6021
const VkAccelerationStructureGeometryKHR * pGeometries
VkResult(VKAPI_PTR * PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
VkPhysicalDeviceType deviceType
Definition: vulkan_core.h:3160
void(VKAPI_PTR * PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority)
VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR
Definition: vulkan_core.h:9282
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
VkSampleCountFlagBits samples
Definition: vulkan_core.h:3729
const VkSemaphore * pSignalSemaphores
Definition: vulkan_core.h:3294
VkPipelineCacheCreateFlags flags
Definition: vulkan_core.h:3414
struct VkDescriptorPoolCreateInfo VkDescriptorPoolCreateInfo
uint32_t specVersion
Definition: vulkan_core.h:3203
void(VKAPI_PTR * PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
uint32_t maxComputeSharedMemorySize
Definition: vulkan_core.h:3083
uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic
Definition: vulkan_core.h:5955
struct VkPipelineVertexInputDivisorStateCreateInfoEXT VkPipelineVertexInputDivisorStateCreateInfoEXT
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
Definition: vulkan_core.h:4039
VkPipelineStageFlags2 dstStageMask
Definition: vulkan_core.h:6917
struct VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupport
struct VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverProperties
VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated
Definition: vulkan_core.h:6813
const VkViewportWScalingNV * pViewportWScalings
void(VKAPI_PTR * PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
Definition: vulkan_core.h:7291
char driverInfo[VK_MAX_DRIVER_INFO_SIZE]
Definition: vulkan_core.h:6067
const VkSparseImageMemoryBind * pBinds
Definition: vulkan_core.h:3279
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR
Definition: vulkan_core.h:8003
VkSurfaceCounterFlagBitsEXT
struct VkStencilOpState VkStencilOpState
VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event)
uint32_t maxDescriptorSetUpdateAfterBindInputAttachments
Definition: vulkan_core.h:5960
VkPipelineCacheCreateFlagBits
Definition: vulkan_core.h:2527
VkDependencyFlags dependencyFlags
Definition: vulkan_core.h:3775
VkDeviceFaultAddressTypeEXT addressType
void(VKAPI_PTR * PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
uint32_t sharedMemBytes
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
Definition: vulkan_core.h:7859
void(VKAPI_PTR * PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
VkAccessFlags dstAccessMask
Definition: vulkan_core.h:6024
struct VkOpticalFlowImageFormatPropertiesNV VkOpticalFlowImageFormatPropertiesNV
VkFlags VkDisplaySurfaceCreateFlagsKHR
Definition: vulkan_core.h:7800
GLenum GLenum GLsizei void * image
Definition: glad.h:5132
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
const VkImageBlit2 * pRegions
Definition: vulkan_core.h:7071
struct VkCommandBufferInheritanceRenderingInfo VkCommandBufferInheritanceRenderingInfo
VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM
VkMicromapTypeEXT type
struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD
VkGeometryInstanceFlagBitsKHR
void(VKAPI_PTR * PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
const VkPipelineInputAssemblyStateCreateInfo * pInputAssemblyState
Definition: vulkan_core.h:3599
uint32_t descriptorCount
Definition: vulkan_core.h:3660
VkFlags VkPipelineCacheCreateFlags
Definition: vulkan_core.h:2532
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR
Definition: vulkan_core.h:8284
VkSwapchainCreateFlagBitsKHR
Definition: vulkan_core.h:7631
void(VKAPI_PTR * PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
Definition: vulkan_core.h:4013
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR
Definition: vulkan_core.h:8357
VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
struct VkAccelerationStructureSRTMotionInstanceNV VkAccelerationStructureSRTMotionInstanceNV
const VkSparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds
Definition: vulkan_core.h:3290
VkValidationCacheCreateFlagsEXT flags
VkRayTracingShaderGroupTypeKHR type
VkPipelineColorBlendStateCreateFlagBits
Definition: vulkan_core.h:2647
const VkAttachmentReference2 * pColorAttachments
Definition: vulkan_core.h:6009
void(VKAPI_PTR * PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
struct VkRenderPassBeginInfo VkRenderPassBeginInfo
struct VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeatures
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
VkDescriptorSet srcSet
Definition: vulkan_core.h:3654
VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
PFN_vkAllocationFunction pfnAllocation
Definition: vulkan_core.h:2921
const VkMutableDescriptorTypeListEXT * pMutableDescriptorTypeLists
VkSwapchainKHR oldSwapchain
Definition: vulkan_core.h:7665
VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
uint64_t desiredPresentTime
VkFlags VkPipelineStageFlags
Definition: vulkan_core.h:2401
VkFlags VkOpticalFlowGridSizeFlagsNV
struct VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfo
struct VkEventCreateInfo VkEventCreateInfo
struct VkPhysicalDeviceCoherentMemoryFeaturesAMD VkPhysicalDeviceCoherentMemoryFeaturesAMD
VkFlags VkGeometryInstanceFlagsKHR
VkExternalMemoryHandleTypeFlags handleTypes
Definition: vulkan_core.h:5468
VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR
Definition: vulkan_core.h:8439
struct VkDescriptorBufferBindingInfoEXT VkDescriptorBufferBindingInfoEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
VkSamplerAddressMode addressModeU
Definition: vulkan_core.h:3637
void(VKAPI_PTR * PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
struct VkPhysicalDeviceCoverageReductionModeFeaturesNV VkPhysicalDeviceCoverageReductionModeFeaturesNV
VkResult(VKAPI_PTR * PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
void(VKAPI_PTR * PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSubgroupSizeControlPropertiesEXT
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
VkPipelineRobustnessBufferBehaviorEXT storageBuffers
VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
struct VkSemaphoreGetFdInfoKHR VkSemaphoreGetFdInfoKHR
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains)
const VkRectLayerKHR * pRectangles
Definition: vulkan_core.h:8381
VkDeviceSize optimalBufferCopyRowPitchAlignment
Definition: vulkan_core.h:3136
VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR
Definition: vulkan_core.h:8263
VkResult(VKAPI_PTR * PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
struct VkDedicatedAllocationImageCreateInfoNV VkDedicatedAllocationImageCreateInfoNV
VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
VkFlags VkExternalMemoryHandleTypeFlagsNV
VkImageLayout initialLayout
Definition: vulkan_core.h:3734
const VkSparseMemoryBind * pBinds
Definition: vulkan_core.h:3258
VkSemaphoreImportFlagBits
Definition: vulkan_core.h:5012
struct VkDeviceGroupSwapchainCreateInfoKHR VkDeviceGroupSwapchainCreateInfoKHR
void(VKAPI_PTR * PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer)
uint32_t maxDrawIndexedIndexValue
Definition: vulkan_core.h:3090
VkFlags VkMicromapCreateFlagsEXT
uint32_t srcQueueFamilyIndex
Definition: vulkan_core.h:2868
const VkDynamicState * pDynamicStates
Definition: vulkan_core.h:3589
VkResult(VKAPI_PTR * PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
Definition: vulkan_core.h:9891
VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
Definition: vulkan_core.h:8034
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue)
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT VkPhysicalDeviceDeviceMemoryReportFeaturesEXT
VkAccessFlags srcAccessMask
Definition: vulkan_core.h:3773
VkFlags VkOpticalFlowUsageFlagsNV
VkExternalMemoryFeatureFlagBitsNV
uint32_t writeMask
Definition: vulkan_core.h:3543
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
Definition: vulkan_core.h:9451
VkFlags VkDebugUtilsMessengerCreateFlagsEXT
VkOffset3D srcOffsets[2]
Definition: vulkan_core.h:3875
void(VKAPI_PTR * PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
struct VkMultisampledRenderToSingleSampledInfoEXT VkMultisampledRenderToSingleSampledInfoEXT
VkStructureType sType
Definition: vulkan_core.h:2811
VkPresentModeKHR
Definition: vulkan_core.h:7517
VkResult(VKAPI_PTR * PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
VkStructureType sType
Definition: vulkan_core.h:6928
VkToolPurposeFlags purposes
Definition: vulkan_core.h:6854
VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
struct VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingProperties
VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
void(VKAPI_PTR * PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
Definition: vulkan_core.h:4024
VkOpticalFlowUsageFlagBitsNV
GLuint sampler
Definition: glcorearb.h:1656
struct VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfo
VkResult(VKAPI_PTR * PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VkPerformanceCounterStorageKHR
Definition: vulkan_core.h:8605
const void * pNext
Definition: vulkan_core.h:6929
char description[VK_MAX_DESCRIPTION_SIZE]
struct VkImageSubresourceRange VkImageSubresourceRange
struct VkTilePropertiesQCOM VkTilePropertiesQCOM
void(VKAPI_PTR * PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
Definition: vulkan_core.h:5536
struct VkPipelineVertexInputStateCreateInfo VkPipelineVertexInputStateCreateInfo
VkResult(VKAPI_PTR * PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkInternalFreeNotification pfnInternalFree
Definition: vulkan_core.h:2925
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfo
uint32_t maxMemoryAllocationCount
Definition: vulkan_core.h:3041
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
const VkGeometryNV * pGeometries
VkPhysicalDeviceInlineUniformBlockFeatures VkPhysicalDeviceInlineUniformBlockFeaturesEXT
void(VKAPI_PTR * PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
void(VKAPI_PTR * PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
Definition: vulkan_core.h:7298
struct VkPhysicalDeviceMemoryDecompressionPropertiesNV VkPhysicalDeviceMemoryDecompressionPropertiesNV
VkOffset3D dstOffset
Definition: vulkan_core.h:7081
void(VKAPI_PTR * PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Definition: vulkan_core.h:4029
VkStructureType sType
Definition: vulkan_core.h:3339
struct VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfo
VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
const VkInputAttachmentAspectReference * pAspectReferences
Definition: vulkan_core.h:5270
struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM
struct VkPhysicalDeviceDescriptorBufferPropertiesEXT VkPhysicalDeviceDescriptorBufferPropertiesEXT
struct VkMemoryBarrier VkMemoryBarrier
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
Definition: vulkan_core.h:8309
VkExternalSemaphoreHandleTypeFlagBits
Definition: vulkan_core.h:5019
struct VkCuFunctionCreateInfoNVX VkCuFunctionCreateInfoNVX
struct VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfo
struct VkDirectDriverLoadingInfoLUNARG VkDirectDriverLoadingInfoLUNARG
VkQueryResultFlagBits
Definition: vulkan_core.h:2451
VkSampleCountFlagBits rasterizationSamples
Definition: vulkan_core.h:3529
void(VKAPI_PTR * PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
Definition: vulkan_core.h:7303
struct VkPhysicalDeviceSampleLocationsPropertiesEXT VkPhysicalDeviceSampleLocationsPropertiesEXT
VkMemoryPropertyFlagBits
Definition: vulkan_core.h:2327
uint8_t deviceLUID[VK_LUID_SIZE]
Definition: vulkan_core.h:5840
VkPipelineStageFlags2 checkpointExecutionStageMask
Definition: vulkan_core.h:9552
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
VkDeviceSize arrayPitch
Definition: vulkan_core.h:3381
VkOffset3D imageOffset
Definition: vulkan_core.h:7030
VkFlags VkShaderCorePropertiesFlagsAMD
VkResult * pResults
Definition: vulkan_core.h:7676
struct VkCopyBufferToImageInfo2 VkCopyBufferToImageInfo2
VkSystemAllocationScope
Definition: vulkan_core.h:1372
struct VkDeviceGroupPresentInfoKHR VkDeviceGroupPresentInfoKHR
VkIndirectCommandsTokenTypeNV
VkCopyMicromapModeEXT
VkStructureType sType
Definition: vulkan_core.h:5181
void(VKAPI_PTR * PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
VkAccessFlags srcAccessMask
Definition: vulkan_core.h:2823
int32_t x
Definition: vulkan_core.h:2800
struct VkPipelineExecutableInternalRepresentationKHR VkPipelineExecutableInternalRepresentationKHR
struct VkPhysicalDeviceCustomBorderColorPropertiesEXT VkPhysicalDeviceCustomBorderColorPropertiesEXT
VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR
Definition: vulkan_core.h:8979
struct VkPipelineCreationFeedback VkPipelineCreationFeedback
const VkPhysicalDevice * pPhysicalDevices
Definition: vulkan_core.h:5159
VkSemaphoreType semaphoreType
Definition: vulkan_core.h:6314
VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT *pSubresource, VkSubresourceLayout2EXT *pLayout)
struct VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfo
VkCoverageReductionModeNV coverageReductionMode
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:8881
struct VkRenderingFragmentDensityMapAttachmentInfoEXT VkRenderingFragmentDensityMapAttachmentInfoEXT
VkRenderPassSubpassFeedbackInfoEXT * pSubpassFeedback
VkResult(VKAPI_PTR * PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
void(VKAPI_PTR * PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3961
VkAttachmentLoadOp
Definition: vulkan_core.h:2071
uint32_t reference
Definition: vulkan_core.h:3544
VkResult(VKAPI_PTR * PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
Definition: vulkan_core.h:3958
VkDeviceSize missShaderBindingTableSize
Definition: vulkan_core.h:9751
VkResult(VKAPI_PTR * PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
VkBool32 integerDotProduct8BitMixedSignednessAccelerated
Definition: vulkan_core.h:6795
VkRect2D renderArea
Definition: vulkan_core.h:7171
VkSamplerReductionMode reductionMode
Definition: vulkan_core.h:6212
GLuint buffer
Definition: glcorearb.h:660
struct VkImageDrmFormatModifierListCreateInfoEXT VkImageDrmFormatModifierListCreateInfoEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
uint32_t maxFragmentDualSrcAttachments
Definition: vulkan_core.h:3081
struct VkSemaphoreSubmitInfo VkSemaphoreSubmitInfo
VkDeviceMemoryReportEventTypeEXT
#define VKAPI_PTR
Definition: vk_platform.h:58
VkResult(VKAPI_PTR * PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:3971
VkExternalMemoryHandleTypeFlagBits
Definition: vulkan_core.h:4947
uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]
Definition: vulkan_core.h:7705
VkOffset3D dstOffset
Definition: vulkan_core.h:3892
struct VkImageBlit2 VkImageBlit2
#define VKAPI_ATTR
Definition: vk_platform.h:56
void(VKAPI_PTR * PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
Definition: vulkan_core.h:7316
VkExternalMemoryHandleTypeFlagBits handleType
Definition: vulkan_core.h:5434
VkFlags64 VkFormatFeatureFlags2
Definition: vulkan_core.h:6678
VkClearColorValue color
Definition: vulkan_core.h:3857
VkResult(VKAPI_PTR * PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
VkImageResolve2 VkImageResolve2KHR
Definition: vulkan_core.h:9690
struct VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentProperties
struct VkMemoryAllocateInfo VkMemoryAllocateInfo
struct VkDisplayModeCreateInfoKHR VkDisplayModeCreateInfoKHR
VkIndirectCommandsLayoutNV indirectCommandsLayout
VkDisplayPlaneCapabilitiesKHR capabilities
Definition: vulkan_core.h:8815
struct VkAttachmentDescription2 VkAttachmentDescription2
VkFlags VkPipelineCompilerControlFlagsAMD
VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV
VkImageUsageFlags stencilUsage
Definition: vulkan_core.h:6206
void(VKAPI_PTR * PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:7296
const VkPipelineStageFlags * pWaitDstStageMask
Definition: vulkan_core.h:3213
VkAcquireProfilingLockFlagBitsKHR
Definition: vulkan_core.h:8624
VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
struct VkBaseInStructure VkBaseInStructure
struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
VkShaderGroupShaderKHR
VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(VkDevice device)
VkImageBlit2 VkImageBlit2KHR
Definition: vulkan_core.h:9686
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
struct VkPhysicalDeviceProvokingVertexFeaturesEXT VkPhysicalDeviceProvokingVertexFeaturesEXT
VkAccessFlags dstAccessMask
Definition: vulkan_core.h:2824
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
Definition: vulkan_core.h:7593
size_t offset
Definition: vulkan_core.h:5394
union VkDeviceOrHostAddressKHR VkDeviceOrHostAddressKHR
struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV VkPhysicalDeviceShaderSMBuiltinsFeaturesNV
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
Definition: vulkan_core.h:5533
VkDeviceAddress deviceAddress
VkGeometryTypeKHR VkGeometryTypeNV
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
struct VkAccelerationStructureMotionInfoNV VkAccelerationStructureMotionInfoNV
void(VKAPI_PTR * PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
struct VkSparseMemoryBind VkSparseMemoryBind
VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
VkStructureType sType
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6375
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
Definition: vulkan_core.h:7858
struct VkSemaphoreSignalInfo VkSemaphoreSignalInfo
uint32_t subTexelPrecisionBits
Definition: vulkan_core.h:3088
void(VKAPI_PTR * PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
Definition: vulkan_core.h:5555
VkPipelineCreateFlags flags
Definition: vulkan_core.h:3595
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated
Definition: vulkan_core.h:6810
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
Definition: vulkan_core.h:8032
VkPipelineCreationFeedbackFlagBits VkPipelineCreationFeedbackFlagBitsEXT
uint32_t waitSemaphoreCount
Definition: vulkan_core.h:3211
VkImageFormatProperties2 VkImageFormatProperties2KHR
Definition: vulkan_core.h:8020
VkPipelineLayout pushconstantPipelineLayout
VkImageSubresourceLayers imageSubresource
Definition: vulkan_core.h:3840
VkPipelineTessellationStateCreateFlags flags
Definition: vulkan_core.h:3486
const VkAccelerationStructureNV * pAccelerationStructures
VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
VkSampleLocationsInfoEXT sampleLocationsInfo
uint32_t srcQueueFamilyIndex
Definition: vulkan_core.h:6921
struct VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
const void *const * pParams
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
const char * pEngineName
Definition: vulkan_core.h:2933
struct VkPipelineRasterizationStateStreamCreateInfoEXT VkPipelineRasterizationStateStreamCreateInfoEXT
VkResult(VKAPI_PTR * PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
struct VkCopyAccelerationStructureInfoKHR VkCopyAccelerationStructureInfoKHR
struct VkSurfaceProtectedCapabilitiesKHR VkSurfaceProtectedCapabilitiesKHR
void(VKAPI_PTR * PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:9992
VkFormatFeatureFlags2 bufferFeatures
Definition: vulkan_core.h:7263
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT
struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT VkPhysicalDeviceExtendedDynamicState2FeaturesEXT
VkDisplayPowerStateEXT powerState
uint32_t baseArrayLayer
Definition: vulkan_core.h:3869
VkResult(VKAPI_PTR * PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
const void * pNext
Definition: vulkan_core.h:7056
VkCompositeAlphaFlagBitsKHR compositeAlpha
Definition: vulkan_core.h:7662
void(VKAPI_PTR * PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
Definition: vulkan_core.h:4008
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
VkStructureType sType
Definition: vulkan_core.h:3714
VkFlags VkStencilFaceFlags
Definition: vulkan_core.h:2782
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
struct VkDirectDriverLoadingListLUNARG VkDirectDriverLoadingListLUNARG
struct VkPhysicalDeviceTilePropertiesFeaturesQCOM VkPhysicalDeviceTilePropertiesFeaturesQCOM
VkCommandBufferSubmitInfo VkCommandBufferSubmitInfoKHR
Definition: vulkan_core.h:9545
VkFlags VkExternalSemaphoreFeatureFlags
Definition: vulkan_core.h:5043
struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT
VkDebugUtilsMessengerCreateFlagsEXT flags
struct VkCommandBufferInheritanceConditionalRenderingInfoEXT VkCommandBufferInheritanceConditionalRenderingInfoEXT
struct VkViewportWScalingNV VkViewportWScalingNV
struct VkXYColorEXT VkXYColorEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
VkPipelineInputAssemblyStateCreateFlags flags
Definition: vulkan_core.h:3478
VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
const VkCoarseSampleLocationNV * pSampleLocations
struct VkPhysicalDevicePushDescriptorPropertiesKHR VkPhysicalDevicePushDescriptorPropertiesKHR
struct VkPhysicalDeviceShaderIntegerDotProductProperties VkPhysicalDeviceShaderIntegerDotProductProperties
struct VkRenderPassCreateInfo VkRenderPassCreateInfo
VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR
Definition: vulkan_core.h:8097
VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs
struct VkClearRect VkClearRect
VkExternalMemoryHandleTypeFlagsNV handleTypes
struct VkImageFormatProperties VkImageFormatProperties
uint32_t dstQueueFamilyIndex
Definition: vulkan_core.h:6922
const VkRenderingAttachmentInfo * pDepthAttachment
Definition: vulkan_core.h:7176
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR
Definition: vulkan_core.h:8024
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
void(VKAPI_PTR * PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
VkStructureType sType
Definition: vulkan_core.h:3393
VkResult(VKAPI_PTR * PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display)
const VkPipelineShaderStageCreateInfo * pStages
VkQueryType
Definition: vulkan_core.h:1715
VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT VkPhysicalDeviceDepthClampZeroOneFeaturesEXT
struct VkRenderPassFragmentDensityMapCreateInfoEXT VkRenderPassFragmentDensityMapCreateInfoEXT
VkImageLayout dstImageLayout
Definition: vulkan_core.h:7018
VkDeviceOrHostAddressConstKHR data
float maxFrameAverageLightLevel
VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind
Definition: vulkan_core.h:5883
VkFlags VkImageUsageFlags
Definition: vulkan_core.h:2311
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
struct VkDebugMarkerObjectTagInfoEXT VkDebugMarkerObjectTagInfoEXT
VkStructureType sType
Definition: vulkan_core.h:3744
VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR
Definition: vulkan_core.h:8099
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
const VkPipelineShaderStageCreateInfo * pStages
VkAccelerationStructureMotionInstanceTypeNV
VkSurfaceTransformFlagBitsKHR currentTransform
VkFragmentShadingRateCombinerOpKHR
Definition: vulkan_core.h:9188
struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT
void(VKAPI_PTR * PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:7325
VkImageUsageFlags usage
Definition: vulkan_core.h:3370
VkBuildMicromapFlagsEXT flags
void(VKAPI_PTR * PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
Definition: vulkan_core.h:4009
VkDisplayPlanePropertiesKHR displayPlaneProperties
Definition: vulkan_core.h:8796
struct VkAccelerationStructureMotionInstanceNV VkAccelerationStructureMotionInstanceNV
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
VkPolygonMode
Definition: vulkan_core.h:1972
VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
VkFrontFace
Definition: vulkan_core.h:1945
struct VkSubpassEndInfo VkSubpassEndInfo
VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR
Definition: vulkan_core.h:8178
uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages
Definition: vulkan_core.h:5950
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
Definition: vulkan_core.h:4032
VkCopyAccelerationStructureModeKHR mode
VkSubpassContents contents
Definition: vulkan_core.h:6046
struct VkPhysicalDeviceLimits VkPhysicalDeviceLimits
const VkAttachmentReference2 * pResolveAttachments
Definition: vulkan_core.h:6010
VkCompositeAlphaFlagsKHR supportedCompositeAlpha
Definition: vulkan_core.h:7580
struct VkRefreshCycleDurationGOOGLE VkRefreshCycleDurationGOOGLE
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
uint32_t imageMemoryBarrierCount
Definition: vulkan_core.h:6935
struct VkAccelerationStructureInfoNV VkAccelerationStructureInfoNV
struct VkGeometryAABBNV VkGeometryAABBNV
VkDeviceSize dstOffset
Definition: vulkan_core.h:3825
VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR
Definition: vulkan_core.h:8186
VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:5539
union VkClearColorValue VkClearColorValue
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
GLenum GLuint GLint GLint layer
Definition: glcorearb.h:1299
struct VkDisplayProperties2KHR VkDisplayProperties2KHR
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
const void * pNext
Definition: vulkan_core.h:9403
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
Definition: vulkan_core.h:9694
VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR
Definition: vulkan_core.h:9328
VkFlags VkPipelineColorBlendStateCreateFlags
Definition: vulkan_core.h:2652
VkBool32 shaderTessellationAndGeometryPointSize
Definition: vulkan_core.h:3001
const VkShadingRatePaletteNV * pShadingRatePalettes
VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR
Definition: vulkan_core.h:8433
VkStructureType sType
Definition: vulkan_core.h:3318
struct VkCommandBufferInheritanceViewportScissorInfoNV VkCommandBufferInheritanceViewportScissorInfoNV
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
VkFormatProperties2 VkFormatProperties2KHR
Definition: vulkan_core.h:8018
struct VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfo
uint32_t memoryBarrierCount
Definition: vulkan_core.h:6931
VkInstanceCreateFlagBits
Definition: vulkan_core.h:2313
struct VkPhysicalDeviceDepthClipEnableFeaturesEXT VkPhysicalDeviceDepthClipEnableFeaturesEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
Definition: vulkan_core.h:7312
struct VkDependencyInfo VkDependencyInfo
void(VKAPI_PTR * PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT
VkSurfaceCounterFlagsEXT supportedSurfaceCounters
struct VkOpticalFlowExecuteInfoNV VkOpticalFlowExecuteInfoNV
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
VkDeviceAddressBindingFlagBitsEXT
VkMemoryDecompressionMethodFlagsNV decompressionMethod
struct _cl_event * event
Definition: glcorearb.h:2961
struct VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2
VkResult(VKAPI_PTR * PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
VkResult(VKAPI_PTR * PFN_vkSetEvent)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3951
#define VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
void(VKAPI_PTR * PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3981
VkDeviceFaultAddressTypeEXT
VkSampleLocationsInfoEXT sampleLocationsInfo
VkDeviceGroupPresentModeFlagBitsKHR mode
Definition: vulkan_core.h:7714
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
VkDeviceSize size
Definition: vulkan_core.h:3342
VkAttachmentLoadOp stencilLoadOp
Definition: vulkan_core.h:5986
VkResult(VKAPI_PTR * PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
Definition: vulkan_core.h:3940
struct VkFramebufferMixedSamplesCombinationNV VkFramebufferMixedSamplesCombinationNV
uint32_t disabledValidationCheckCount
VkGeometryFlagBitsKHR
VkSamplerMipmapMode mipmapMode
Definition: vulkan_core.h:3636
struct VkFormatProperties VkFormatProperties
struct VkPhysicalDeviceDepthClipControlFeaturesEXT VkPhysicalDeviceDepthClipControlFeaturesEXT
struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT VkPhysicalDeviceFragmentDensityMapFeaturesEXT
struct VkImageMemoryBarrier2 VkImageMemoryBarrier2
VkResult(VKAPI_PTR * PFN_vkCreateInstance)(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
Definition: vulkan_core.h:3906
VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4PropertiesKHR
Definition: vulkan_core.h:9783
VkAccelerationStructureGeometryAabbsDataKHR aabbs
struct VkOpticalFlowImageFormatInfoNV VkOpticalFlowImageFormatInfoNV
VkResult(VKAPI_PTR * PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
void(VKAPI_PTR * PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer)
VkResult(VKAPI_PTR * PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
VkImageFormatProperties imageFormatProperties
Definition: vulkan_core.h:5213
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
VkImageUsageFlags sharedPresentSupportedUsageFlags
Definition: vulkan_core.h:8494
uint32_t queueCreateInfoCount
Definition: vulkan_core.h:3187
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
Definition: vulkan_core.h:9149
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV
VkResult(VKAPI_PTR * PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
Definition: vulkan_core.h:3984
VkExtent2D extent
Definition: vulkan_core.h:2807
VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
struct VkClearAttachment VkClearAttachment
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
void(VKAPI_PTR * PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
const VkSampler * pSampler
VkResult(VKAPI_PTR * PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
const GLuint const GLfloat * priorities
Definition: glad.h:2944
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
VkImageLayout imageLayout
Definition: vulkan_core.h:3672
VkIndirectStateFlagBitsNV
VkAccessFlags2 dstAccessMask
Definition: vulkan_core.h:6895
VkDeviceQueueCreateFlags flags
Definition: vulkan_core.h:3177
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT
VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
const VkImageResolve2 * pRegions
Definition: vulkan_core.h:7093
VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated
Definition: vulkan_core.h:6808
uint32_t maxVertexInputAttributeOffset
Definition: vulkan_core.h:3063
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
struct VkPhysicalDevicePCIBusInfoPropertiesEXT VkPhysicalDevicePCIBusInfoPropertiesEXT
VkPipelineExecutableStatisticFormatKHR format
Definition: vulkan_core.h:9435
struct VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfo
VkPipelineStageFlags2 srcStageMask
Definition: vulkan_core.h:6892
struct VkImageCreateInfo VkImageCreateInfo
VkResult(VKAPI_PTR * PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
Definition: vulkan_core.h:3935
#define VK_MAX_DEVICE_GROUP_SIZE
Definition: vulkan_core.h:4850
void *(VKAPI_PTR * PFN_vkAllocationFunction)(void *pUserData, size_t size, size_t alignment, VkSystemAllocationScope allocationScope)
Definition: vulkan_core.h:2889
struct VkDeviceQueueCreateInfo VkDeviceQueueCreateInfo
#define VK_MAX_DESCRIPTION_SIZE
Definition: vulkan_core.h:136
VkFragmentShadingRateTypeNV
void(VKAPI_PTR * PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3992
VkResult(VKAPI_PTR * PFN_vkQueueWaitIdle)(VkQueue queue)
Definition: vulkan_core.h:3925
const VkPipelineMultisampleStateCreateInfo * pMultisampleState
Definition: vulkan_core.h:3603
VkBool32 shaderStorageImageExtendedFormats
Definition: vulkan_core.h:3003
struct VkExtent3D VkExtent3D
VkDescriptorType
Definition: vulkan_core.h:2048
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
Definition: vulkan_core.h:8406
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:8879
char description[VK_MAX_DESCRIPTION_SIZE]
Definition: vulkan_core.h:9434
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
VkShaderStageFlags requiredSubgroupSizeStages
Definition: vulkan_core.h:6786
VkResult(VKAPI_PTR * PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
Definition: vulkan_core.h:3948
VkAttachmentStoreOp storeOp
Definition: vulkan_core.h:3731
VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
VkDescriptorUpdateTemplateType templateType
Definition: vulkan_core.h:5404
const void * pNext
Definition: vulkan_core.h:3632
const VkAttachmentReference * pResolveAttachments
Definition: vulkan_core.h:3762
VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
VkPipelineCreationFeedback * pPipelineStageCreationFeedbacks
Definition: vulkan_core.h:6840
const uint32_t * pCommandBufferDeviceMasks
Definition: vulkan_core.h:5119
uint32_t maxDescriptorSetStorageImages
Definition: vulkan_core.h:3059
VkAttachmentSampleCountInfoAMD VkAttachmentSampleCountInfoNV
Definition: vulkan_core.h:7978
struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT
void(VKAPI_PTR * PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VkResolveImageInfo2 VkResolveImageInfo2KHR
Definition: vulkan_core.h:9680
VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR
Definition: vulkan_core.h:8509
VkStructureType sType
VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier)
VkPointClippingBehavior pointClippingBehavior
Definition: vulkan_core.h:5257
struct VkPipelineColorBlendStateCreateInfo VkPipelineColorBlendStateCreateInfo
VkIndirectCommandsTokenTypeNV tokenType
VkIndirectCommandsLayoutNV indirectCommandsLayout
VkStructureType sType
VkStructureType sType
Definition: vulkan_core.h:5993
VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
void(VKAPI_PTR * PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
VkBool32 descriptorBindingUniformBufferUpdateAfterBind
Definition: vulkan_core.h:5878
VkImageSubresourceLayers dstSubresource
Definition: vulkan_core.h:3891
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
Definition: vulkan_core.h:3939
VkResult(VKAPI_PTR * PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:8562
VkDeviceSize uniformTexelBufferOffsetAlignmentBytes
Definition: vulkan_core.h:6825
VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
VkPerformanceOverrideTypeINTEL type
VkAccelerationStructureNV accelerationStructure
VkPipelineCreateFlags flags
Definition: vulkan_core.h:3445
VkPhysicalDeviceMemoryProperties memoryProperties
Definition: vulkan_core.h:5235
struct VkAttachmentReference2 VkAttachmentReference2
void(VKAPI_PTR * PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
VkPhysicalDeviceShaderIntegerDotProductFeatures VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR
Definition: vulkan_core.h:9477
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
Definition: vulkan_core.h:8033
uint32_t maxTessellationEvaluationOutputComponents
Definition: vulkan_core.h:3073
VkDeviceGroupPresentModeFlagsKHR modes
Definition: vulkan_core.h:7706
VkResult(VKAPI_PTR * PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
Definition: vulkan_core.h:5534
VkDebugUtilsMessageSeverityFlagBitsEXT
struct VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsProperties
void(VKAPI_PTR * PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7724
VkStructureType sType
Definition: vulkan_core.h:3779
struct VkPhysicalDeviceCooperativeMatrixFeaturesNV VkPhysicalDeviceCooperativeMatrixFeaturesNV
VkStructureType sType
struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT
struct VkPipelineExecutablePropertiesKHR VkPipelineExecutablePropertiesKHR
VkAccelerationStructureKHR accelerationStructure
struct VkStridedDeviceAddressRegionKHR VkStridedDeviceAddressRegionKHR
GLint GLsizei GLsizei height
Definition: glcorearb.h:103
VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR
Definition: vulkan_core.h:9133
VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR
Definition: vulkan_core.h:8725
struct VkSurfaceCapabilitiesKHR VkSurfaceCapabilitiesKHR
VkStructureType sType
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
Definition: vulkan_core.h:7315
struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures
VkAccelerationStructureTypeKHR type
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
uint32_t computeWorkGroupSize[3]
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR
Definition: vulkan_core.h:8154
struct VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfo
struct VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeatures
const VkPipelineColorBlendStateCreateInfo * pColorBlendState
Definition: vulkan_core.h:3605
VkFlags VkCommandBufferResetFlags
Definition: vulkan_core.h:2773
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
const VkSubpassDescription2 * pSubpasses
Definition: vulkan_core.h:6036
VkSampleCountFlags storageImageSampleCounts
Definition: vulkan_core.h:3121
VkImageSubresourceLayers imageSubresource
Definition: vulkan_core.h:7029
VkFlags VkPipelineInputAssemblyStateCreateFlags
Definition: vulkan_core.h:2632
VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
VkDeviceSize rowPitch
Definition: vulkan_core.h:3380
void(VKAPI_PTR * PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
Definition: vulkan_core.h:5535
void(VKAPI_PTR * PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:5554
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
struct VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2
VkShaderCorePropertiesFlagsAMD shaderCoreFeatures
VkStructureType sType
Definition: vulkan_core.h:3324
struct VkPipelineColorBlendAdvancedStateCreateInfoEXT VkPipelineColorBlendAdvancedStateCreateInfoEXT
VkDeviceMemory memory
Definition: vulkan_core.h:3223
VkSubmitFlags VkSubmitFlagsKHR
Definition: vulkan_core.h:9531
const void * pNext
Definition: vulkan_core.h:8556
VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
struct VkMultiviewPerViewAttributesInfoNVX VkMultiviewPerViewAttributesInfoNVX
VkPerformanceCounterDescriptionFlagsKHR flags
Definition: vulkan_core.h:8653
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
void(VKAPI_PTR * PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
Definition: vulkan_core.h:4007
VkFlags VkMemoryMapFlags
Definition: vulkan_core.h:2402
VkDeviceSize srcOffset
Definition: vulkan_core.h:3824
VkExternalSemaphoreHandleTypeFlagBits handleType
Definition: vulkan_core.h:5500
VkDeviceSize offset
Definition: vulkan_core.h:3224
VkSubmitInfo2 VkSubmitInfo2KHR
Definition: vulkan_core.h:9541
uint64_t(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:9331
const void * pNext
Definition: vulkan_core.h:7065
VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
VkFormatFeatureFlags drmFormatModifierTilingFeatures
void(VKAPI_PTR * PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
Definition: vulkan_core.h:4012
const VkPipelineDynamicStateCreateInfo * pDynamicState
VkShaderStageFlags stageFlags
Definition: vulkan_core.h:3615
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
VkImageLayout srcImageLayout
Definition: vulkan_core.h:7016
struct VkPipelineInputAssemblyStateCreateInfo VkPipelineInputAssemblyStateCreateInfo
GLuint framebuffer
Definition: glcorearb.h:1287
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
VkRenderingFlagBits VkRenderingFlagBitsKHR
Definition: vulkan_core.h:7943
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:9565
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
const VkVertexInputAttributeDescription * pVertexAttributeDescriptions
Definition: vulkan_core.h:3472
struct VkCopyDescriptorSet VkCopyDescriptorSet
VkCommandBufferLevel level
Definition: vulkan_core.h:3801
uint32_t maxDescriptorSetSampledImages
Definition: vulkan_core.h:3058
VkResult(VKAPI_PTR * PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
Definition: vulkan_core.h:7590
struct VkDescriptorPoolSize VkDescriptorPoolSize
const VkAttachmentDescription2 * pAttachments
Definition: vulkan_core.h:6034
struct VkPhysicalDeviceShaderClockFeaturesKHR VkPhysicalDeviceShaderClockFeaturesKHR
VkColorSpaceKHR colorSpace
Definition: vulkan_core.h:7586
VkStructureType sType
Definition: vulkan_core.h:7003
struct VkAttachmentDescription VkAttachmentDescription
VkResult(VKAPI_PTR * PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
Definition: vulkan_core.h:8957
VkPhysicalDeviceSparseProperties sparseProperties
Definition: vulkan_core.h:3164
VkFlags VkPipelineDepthStencilStateCreateFlags
Definition: vulkan_core.h:2645
VkChromaLocation
Definition: vulkan_core.h:4892
VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display)
VkOpticalFlowExecuteFlagsNV flags
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
Definition: vulkan_core.h:9695
struct VkMultiDrawInfoEXT VkMultiDrawInfoEXT
VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
char description[VK_MAX_DESCRIPTION_SIZE]
Definition: vulkan_core.h:3205
VkDriverId VkDriverIdKHR
Definition: vulkan_core.h:9093
GLintptr offset
Definition: glcorearb.h:665
void(VKAPI_PTR * PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
Definition: vulkan_core.h:7321
VkImageLayout dstImageLayout
Definition: vulkan_core.h:7039
const VkAccelerationStructureKHR * pAccelerationStructures
VkDebugReportFlagBitsEXT
Definition: vulkan_core.h:9864
VkBlendOp
Definition: vulkan_core.h:1791
struct VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeatures
VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated
Definition: vulkan_core.h:6816
VkResult(VKAPI_PTR * PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
Definition: vulkan_core.h:3929
VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated
Definition: vulkan_core.h:6822
VkPipelineStageFlags2 srcStageMask
Definition: vulkan_core.h:6915
VkResult(VKAPI_PTR * PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
Definition: vulkan_core.h:3956
struct VkPhysicalDeviceImageProcessingFeaturesQCOM VkPhysicalDeviceImageProcessingFeaturesQCOM
const VkAttachmentReference2 * pFragmentShadingRateAttachment
Definition: vulkan_core.h:9199
uint32_t maxTessellationPatchSize
Definition: vulkan_core.h:3067
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:8995
VkImageLayout finalLayout
Definition: vulkan_core.h:3735
struct VkGeometryNV VkGeometryNV
VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR
Definition: vulkan_core.h:8259
struct VkDescriptorSetBindingReferenceVALVE VkDescriptorSetBindingReferenceVALVE
VkGraphicsPipelineLibraryFlagsEXT flags
struct VkDisplayModePropertiesKHR VkDisplayModePropertiesKHR
VkResult(VKAPI_PTR * PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
Definition: vulkan_core.h:3996
VkStructureType sType
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
struct VkImportSemaphoreFdInfoKHR VkImportSemaphoreFdInfoKHR
struct VkDeviceFaultInfoEXT VkDeviceFaultInfoEXT
uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]
VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR
Definition: vulkan_core.h:9284
const VkSubpassDescription * pSubpasses
Definition: vulkan_core.h:3785
VkComponentSwizzle a
Definition: vulkan_core.h:3389
const VkDescriptorImageInfo * pInputAttachmentImage
size_t size
Definition: vulkan_core.h:3422
struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT
VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
const VkMicromapUsageEXT *const * ppUsageCounts
VkDisplayModeParametersKHR parameters
Definition: vulkan_core.h:7810
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
void(VKAPI_PTR * PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
Definition: vulkan_core.h:7313
struct VkPhysicalDeviceCustomBorderColorFeaturesEXT VkPhysicalDeviceCustomBorderColorFeaturesEXT
uint32_t regionCount
Definition: vulkan_core.h:6998
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
Definition: vulkan_core.h:8689
VkFlags VkEventCreateFlags
Definition: vulkan_core.h:2430
void(VKAPI_PTR * PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
struct VkDrawIndexedIndirectCommand VkDrawIndexedIndirectCommand
VkDeviceAddress dstAddress
VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
struct VkPipelineTessellationStateCreateInfo VkPipelineTessellationStateCreateInfo
VkOpacityMicromapSpecialIndexEXT
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfoKHR
Definition: vulkan_core.h:7949
uint32_t maxComputeWorkGroupCount[3]
Definition: vulkan_core.h:3084
struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT
VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT
VkFlags VkExternalSemaphoreHandleTypeFlags
Definition: vulkan_core.h:5034
VkDeviceAddress hitShaderBindingTableAddress
Definition: vulkan_core.h:9753
VkDeviceSize memoryOffset
Definition: vulkan_core.h:5066
VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL
VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
VkDebugReportObjectTypeEXT objectType
Definition: vulkan_core.h:9967
struct VkBufferCreateInfo VkBufferCreateInfo
VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated
Definition: vulkan_core.h:6818
VkSemaphoreCreateFlags flags
Definition: vulkan_core.h:3320
VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
struct VkVertexInputAttributeDescription2EXT VkVertexInputAttributeDescription2EXT
uint32_t imageOpaqueBindCount
Definition: vulkan_core.h:3289
const VkSubresourceLayout * pPlaneLayouts
VkXYColorEXT whitePoint
VkBuildAccelerationStructureFlagsNV flags
VkStructureType sType
Definition: vulkan_core.h:7914
uint32_t queueFamilyIndexCount
Definition: vulkan_core.h:3345
VkDeviceAddress missShaderBindingTableAddress
Definition: vulkan_core.h:9750
VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
VkRenderPass renderPass
Definition: vulkan_core.h:3899
struct VkMicromapBuildInfoEXT VkMicromapBuildInfoEXT
VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR
Definition: vulkan_core.h:8780
struct VkDisplaySurfaceCreateInfoKHR VkDisplaySurfaceCreateInfoKHR
const VkDirectDriverLoadingInfoLUNARG * pDrivers
VkResult(VKAPI_PTR * PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
struct VkImageCopy2 VkImageCopy2
void(VKAPI_PTR * PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
void(VKAPI_PTR * PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
Definition: vulkan_core.h:4010
VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR
Definition: vulkan_core.h:9106
VkResolveModeFlagBits stencilResolveMode
Definition: vulkan_core.h:6184
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
const VkSemaphore * pWaitSemaphores
Definition: vulkan_core.h:3286
VkDescriptorType type
Definition: vulkan_core.h:3676
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
Definition: vulkan_core.h:3913
VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
struct VkAccelerationStructureMemoryRequirementsInfoNV VkAccelerationStructureMemoryRequirementsInfoNV
VkAttachmentDescriptionFlags flags
Definition: vulkan_core.h:3727
VkBuildMicromapModeEXT
VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures
Definition: vulkan_core.h:5508
struct VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfo
VkStructureType sType
Definition: vulkan_core.h:2953
VkResult(VKAPI_PTR * PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
VkPipelineStageFlags2 dstStageMask
Definition: vulkan_core.h:6894
uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages
Definition: vulkan_core.h:5949
VkCopyImageInfo2 VkCopyImageInfo2KHR
Definition: vulkan_core.h:9672
const VkAttachmentReference2 * pDepthStencilAttachment
Definition: vulkan_core.h:6011
VkStructureType sType
Definition: vulkan_core.h:6001
struct VkMemoryHostPointerPropertiesEXT VkMemoryHostPointerPropertiesEXT
VkVendorId
Definition: vulkan_core.h:1362
void(VKAPI_PTR * PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
VkQueueGlobalPriorityKHR
Definition: vulkan_core.h:9056
uint8_t deviceLUID[VK_LUID_SIZE]
Definition: vulkan_core.h:5448
VkExternalMemoryHandleTypeFlagBits handleType
Definition: vulkan_core.h:5420
VkExternalFenceProperties VkExternalFencePropertiesKHR
Definition: vulkan_core.h:8519
VkResult(VKAPI_PTR * PFN_vkDeviceWaitIdle)(VkDevice device)
Definition: vulkan_core.h:3926
VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
struct VkPhysicalDeviceRayQueryFeaturesKHR VkPhysicalDeviceRayQueryFeaturesKHR
struct VkPhysicalDeviceVulkan11Features VkPhysicalDeviceVulkan11Features
VkResult(VKAPI_PTR * PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
const uint8_t * pVersionData
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
struct VkPerformanceValueINTEL VkPerformanceValueINTEL
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VkImageAspectFlags aspectMask
Definition: vulkan_core.h:3830
VkSparseImageFormatFlagBits
Definition: vulkan_core.h:2410
struct VkSharedPresentSurfaceCapabilitiesKHR VkSharedPresentSurfaceCapabilitiesKHR
VkSampleCountFlags framebufferDepthSampleCounts
Definition: vulkan_core.h:3113
VkSurfaceTransformFlagBitsKHR currentTransform
Definition: vulkan_core.h:7579
VkPipelineVertexInputStateCreateFlags flags
Definition: vulkan_core.h:3468
VkAccessFlags srcAccessMask
Definition: vulkan_core.h:2877
struct VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfo
VkAccelerationStructureMemoryRequirementsTypeNV
VkResult(VKAPI_PTR * PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
Definition: vulkan_core.h:6383
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
struct VkPhysicalDeviceMeshShaderPropertiesNV VkPhysicalDeviceMeshShaderPropertiesNV
void(VKAPI_PTR * PFN_vkVoidFunction)(void)
Definition: vulkan_core.h:2918
VkDisplayModeKHR displayMode
Definition: vulkan_core.h:7849
VkDeviceAddressBindingFlagsEXT flags
uint32_t descriptorCount
Definition: vulkan_core.h:5392
VkFenceImportFlagBits
Definition: vulkan_core.h:5005
struct VkSemaphoreWaitInfo VkSemaphoreWaitInfo
struct VkImageSubresourceLayers VkImageSubresourceLayers
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
struct VkSamplerCreateInfo VkSamplerCreateInfo
uint32_t maxImageDimensionCube
Definition: vulkan_core.h:3035
struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT
const VkGraphicsShaderGroupCreateInfoNV * pGroups
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
struct VkPerformanceCounterKHR VkPerformanceCounterKHR
VkCompareOp
Definition: vulkan_core.h:1846
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:6377
VkCoverageReductionModeNV coverageReductionMode
VkImageSubresourceLayers dstSubresource
Definition: vulkan_core.h:7007
struct VkPhysicalDeviceSurfaceInfo2KHR VkPhysicalDeviceSurfaceInfo2KHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
struct VkDescriptorImageInfo VkDescriptorImageInfo
void(VKAPI_PTR * PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
Definition: vulkan_core.h:8101
void *(VKAPI_PTR * PFN_vkReallocationFunction)(void *pUserData, void *pOriginal, size_t size, size_t alignment, VkSystemAllocationScope allocationScope)
Definition: vulkan_core.h:2911
struct VkPhysicalDeviceImageProcessingPropertiesQCOM VkPhysicalDeviceImageProcessingPropertiesQCOM
void(VKAPI_PTR * PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:7327
GLbitfield GLuint64 timeout
Definition: glcorearb.h:1599
struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR VkPhysicalDeviceRayTracingPipelinePropertiesKHR
void(VKAPI_PTR * PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3928
VkResult(VKAPI_PTR * PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
struct VkPhysicalDeviceShadingRateImageFeaturesNV VkPhysicalDeviceShadingRateImageFeaturesNV
uint32_t heapIndex
Definition: vulkan_core.h:2970
VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
VkDescriptorType descriptorType
struct VkSubpassShadingPipelineCreateInfoHUAWEI VkSubpassShadingPipelineCreateInfoHUAWEI
VkPipelineCreationFeedback VkPipelineCreationFeedbackEXT
struct VkExportMemoryAllocateInfoNV VkExportMemoryAllocateInfoNV
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:5541
VkStructureType sType
Definition: vulkan_core.h:3330
VkPerformanceConfigurationTypeINTEL type
VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchronization2FeaturesKHR
Definition: vulkan_core.h:9547
VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated
Definition: vulkan_core.h:6820
struct VkAccelerationStructureTrianglesOpacityMicromapEXT VkAccelerationStructureTrianglesOpacityMicromapEXT
VkBool32 timestampComputeAndGraphics
Definition: vulkan_core.h:3123
struct VkExportFenceCreateInfo VkExportFenceCreateInfo
VkXYColorEXT displayPrimaryRed
VkSurfaceCapabilitiesKHR surfaceCapabilities
Definition: vulkan_core.h:8749
VkCommandBufferUsageFlagBits
Definition: vulkan_core.h:2755
VkQueryPipelineStatisticFlags pipelineStatistics
Definition: vulkan_core.h:3813
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
VkAttachmentStoreOp stencilStoreOp
Definition: vulkan_core.h:3733
void(VKAPI_PTR * PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
struct VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfo
void(VKAPI_PTR * PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
Definition: vulkan_core.h:4026
VkFormatFeatureFlags2 optimalTilingFeatures
Definition: vulkan_core.h:7262
VkPipelineRobustnessBufferBehaviorEXT vertexInputs
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
void(VKAPI_PTR * PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
VkChromaLocation VkChromaLocationKHR
Definition: vulkan_core.h:8918
struct VkPresentTimesInfoGOOGLE VkPresentTimesInfoGOOGLE
void(VKAPI_PTR * PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:5537
uint64_t(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:6386
VkStructureType sType
Definition: vulkan_core.h:6913
VkStructureType sType
Definition: vulkan_core.h:3184
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR
Definition: vulkan_core.h:8394
VkFlags VkFenceImportFlags
Definition: vulkan_core.h:5010
VkSemaphoreType
Definition: vulkan_core.h:5776
VkRenderPassCreationFeedbackInfoEXT * pRenderPassFeedback
VkResult(VKAPI_PTR * PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:9356
uint32_t enabledLayerCount
Definition: vulkan_core.h:2957
uint8_t driverUUID[VK_UUID_SIZE]
Definition: vulkan_core.h:5447
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
VkResult(VKAPI_PTR * PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
VkSemaphoreType VkSemaphoreTypeKHR
Definition: vulkan_core.h:9131
struct VkPhysicalDeviceMemoryProperties VkPhysicalDeviceMemoryProperties
struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE
struct VkSamplerCaptureDescriptorDataInfoEXT VkSamplerCaptureDescriptorDataInfoEXT
const VkPresentRegionKHR * pRegions
Definition: vulkan_core.h:8388
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:9566
struct VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeatures
uint32_t maxGeometryShaderInvocations
Definition: vulkan_core.h:3074
struct VkSparseBufferMemoryBindInfo VkSparseBufferMemoryBindInfo
uint32_t maxGeometryOutputVertices
Definition: vulkan_core.h:3077
VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
const void * pNext
Definition: vulkan_core.h:6891
uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers
Definition: vulkan_core.h:5948
struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT
void(VKAPI_PTR * PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
Definition: vulkan_core.h:9568
const VkPipelineColorBlendAttachmentState * pAttachments
Definition: vulkan_core.h:3580
VkStructureType sType
struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT
VkResult(VKAPI_PTR * PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_core.h:7864
void * VkRemoteAddressNV
VkExternalMemoryHandleTypeFlags handleTypes
Definition: vulkan_core.h:5462
VkDeviceAddress(VKAPI_PTR * PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetInstanceProcAddr)(VkInstance instance, const char *pName)
Definition: vulkan_core.h:3915
VkBool32 shaderSampledImageArrayNonUniformIndexing
Definition: vulkan_core.h:5872
VkExternalSemaphoreFeatureFlagBits
Definition: vulkan_core.h:5036
VkResult(VKAPI_PTR * PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
VkSampleCountFlags sampledImageColorSampleCounts
Definition: vulkan_core.h:3117
VkCopyMicromapModeEXT mode
VkFenceImportFlags VkFenceImportFlagsKHR
Definition: vulkan_core.h:8534
struct VkPhysicalDeviceMeshShaderFeaturesEXT VkPhysicalDeviceMeshShaderFeaturesEXT
VkPerformanceCounterUnitKHR
Definition: vulkan_core.h:8580
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
VkPipelineStageFlags dstStageMask
Definition: vulkan_core.h:3772
struct VkDeviceMemoryOverallocationCreateInfoAMD VkDeviceMemoryOverallocationCreateInfoAMD
VkStructureType sType
Definition: vulkan_core.h:5341
VkImageUsageFlags imageUsage
Definition: vulkan_core.h:7657
VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR
Definition: vulkan_core.h:8517
struct VkAccelerationStructureMatrixMotionInstanceNV VkAccelerationStructureMatrixMotionInstanceNV
struct VkMemoryType VkMemoryType
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
VkSampleCountFlags framebufferNoAttachmentsSampleCounts
Definition: vulkan_core.h:3115
VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR
Definition: vulkan_core.h:8400
VkBuildAccelerationStructureModeKHR mode
VkStructureType sType
Definition: vulkan_core.h:7669
struct VkPhysicalDevice4444FormatsFeaturesEXT VkPhysicalDevice4444FormatsFeaturesEXT
VkGraphicsPipelineLibraryFlagBitsEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
void(VKAPI_PTR * PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
VkRenderingInfo VkRenderingInfoKHR
Definition: vulkan_core.h:7945
VkGeometryFlagsKHR VkGeometryFlagsNV
VkFlags VkQueryControlFlags
Definition: vulkan_core.h:2767
struct VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfo
VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd)
void(VKAPI_PTR * PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:4042
struct VkPresentInfoKHR VkPresentInfoKHR
uint32_t maxTessellationControlPerPatchOutputComponents
Definition: vulkan_core.h:3070
uint32_t maxUniformBufferRange
Definition: vulkan_core.h:3038
VkCoverageModulationModeNV coverageModulationMode
struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT VkPhysicalDeviceYcbcrImageArraysFeaturesEXT
VkDependencyFlags dependencyFlags
Definition: vulkan_core.h:6025
VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VkFlags VkImageViewCreateFlags
Definition: vulkan_core.h:2524
void(VKAPI_PTR * PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3907
VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR
Definition: vulkan_core.h:9322
struct VkPhysicalDeviceVulkan11Properties VkPhysicalDeviceVulkan11Properties
struct VkShaderModuleValidationCacheCreateInfoEXT VkShaderModuleValidationCacheCreateInfoEXT
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceVersion)(uint32_t *pApiVersion)
Definition: vulkan_core.h:5532
struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT
void(VKAPI_PTR * PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
VkPipelineExecutableStatisticFormatKHR
Definition: vulkan_core.h:9388
VkExternalMemoryHandleTypeFlagBits handleType
VkConditionalRenderingFlagBitsEXT
VkDeviceOrHostAddressKHR scratchData
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain)
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:108
void(VKAPI_PTR * PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
Definition: vulkan_core.h:4001
VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR
Definition: vulkan_core.h:8030
VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
struct VkPhysicalDeviceExclusiveScissorFeaturesNV VkPhysicalDeviceExclusiveScissorFeaturesNV
uint32_t(VKAPI_PTR * PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:9355
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
VkComponentSwizzle r
Definition: vulkan_core.h:3386
uint32_t signalSemaphoreCount
Definition: vulkan_core.h:3216
VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR
Definition: vulkan_core.h:8091
struct VkAccelerationStructureGeometryMotionTrianglesDataNV VkAccelerationStructureGeometryMotionTrianglesDataNV
void(VKAPI_PTR * PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
VkDeviceMemoryReportFlagsEXT flags
VkStructureType sType
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
Definition: vulkan_core.h:5538
VkOffset3D srcOffset
Definition: vulkan_core.h:7006
VkCopyMicromapModeEXT mode
VkCompareOp compareOp
Definition: vulkan_core.h:3644
VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:3988
VkResult(VKAPI_PTR * PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
VkSubgroupFeatureFlagBits
Definition: vulkan_core.h:4907
VkDeviceAddress accelerationStructure
VkQueryPipelineStatisticFlags pipelineStatistics
Definition: vulkan_core.h:3335
struct VkBindImageMemoryInfo VkBindImageMemoryInfo
struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT
struct VkPipelineDiscardRectangleStateCreateInfoEXT VkPipelineDiscardRectangleStateCreateInfoEXT
VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR
Definition: vulkan_core.h:8977
VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR
Definition: vulkan_core.h:8095
struct VkPhysicalDeviceMultiDrawPropertiesEXT VkPhysicalDeviceMultiDrawPropertiesEXT
struct VkRayTracingPipelineCreateInfoNV VkRayTracingPipelineCreateInfoNV
VkResult(VKAPI_PTR * PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
const uint32_t * pPreserveAttachments
Definition: vulkan_core.h:6013
struct VkSurfaceFormat2KHR VkSurfaceFormat2KHR
struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI VkPhysicalDeviceInvocationMaskFeaturesHUAWEI
VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT
GLint GLenum GLboolean GLsizei stride
Definition: glcorearb.h:872
VkFlags VkMemoryHeapFlags
Definition: vulkan_core.h:2325
VkStructureType sType
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR
Definition: vulkan_core.h:9141
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
uint32_t maxTessellationEvaluationInputComponents
Definition: vulkan_core.h:3072
VkResult(VKAPI_PTR * PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
struct VkOpticalFlowSessionCreatePrivateDataInfoNV VkOpticalFlowSessionCreatePrivateDataInfoNV
struct VkPipelineRobustnessCreateInfoEXT VkPipelineRobustnessCreateInfoEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
VkGeometryAABBNV aabbs
uint32_t maxDescriptorSetStorageBuffersDynamic
Definition: vulkan_core.h:3057
struct VkAttachmentReference VkAttachmentReference
VkShaderStageFlagBits stage
Definition: vulkan_core.h:3436
void(VKAPI_PTR * PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:9790
VkDeviceSize offset
VkStructureType sType
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:5540
GLint GLuint mask
Definition: glcorearb.h:124
void(VKAPI_PTR * PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3947
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
VkDeviceSize resourceOffset
Definition: vulkan_core.h:3242
const VkImageCopy2 * pRegions
Definition: vulkan_core.h:7020
VkResult(VKAPI_PTR * PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains)
Definition: vulkan_core.h:7921
#define VK_DEFINE_HANDLE(object)
Definition: vulkan_core.h:25
VkStructureType sType
Definition: vulkan_core.h:3817
VkResult(VKAPI_PTR * PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
VkConservativeRasterizationModeEXT conservativeRasterizationMode
struct VkPhysicalDevicePerformanceQueryFeaturesKHR VkPhysicalDevicePerformanceQueryFeaturesKHR
VkDeviceMemory memory
Definition: vulkan_core.h:8233
void(VKAPI_PTR * PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
Definition: vulkan_core.h:3933
struct VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfo
struct VkImageCopy VkImageCopy
struct VkPhysicalDeviceLegacyDitheringFeaturesEXT VkPhysicalDeviceLegacyDitheringFeaturesEXT
struct VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolPerformanceQueryCreateInfoINTEL
VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
VkDescriptorType descriptorType
Definition: vulkan_core.h:3699
void(VKAPI_PTR * PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers
struct VkBindSparseInfo VkBindSparseInfo
VkAccessFlags dstAccessMask
Definition: vulkan_core.h:2865
struct VkDisplayPropertiesKHR VkDisplayPropertiesKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
struct VkImportMemoryHostPointerInfoEXT VkImportMemoryHostPointerInfoEXT
VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR
Definition: vulkan_core.h:9143
const VkPhysicalDeviceFeatures * pEnabledFeatures
Definition: vulkan_core.h:3193
VkFlags VkAccelerationStructureMotionInstanceFlagsNV
VkCopyAccelerationStructureModeKHR
const VkCommandBufferSubmitInfo * pCommandBufferInfos
Definition: vulkan_core.h:6962
void(VKAPI_PTR * PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
Definition: vulkan_core.h:4025
struct VkDeviceImageMemoryRequirements VkDeviceImageMemoryRequirements
struct VkPhysicalDeviceVulkan12Properties VkPhysicalDeviceVulkan12Properties
void(VKAPI_PTR * PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
Definition: vulkan_core.h:9569
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR
Definition: vulkan_core.h:8028
VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes
Definition: vulkan_core.h:5507
VkMutableDescriptorTypeListEXT VkMutableDescriptorTypeListVALVE
VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT
VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR
Definition: vulkan_core.h:8916
VkDescriptorSetLayoutCreateFlags flags
Definition: vulkan_core.h:3708
VkResult(VKAPI_PTR * PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration)
VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT
void(VKAPI_PTR * PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
const VkRenderingAttachmentInfo * pColorAttachments
Definition: vulkan_core.h:7175
struct VkPipelineCompilerControlCreateInfoAMD VkPipelineCompilerControlCreateInfoAMD
struct VkColorBlendAdvancedEXT VkColorBlendAdvancedEXT
VkStencilFaceFlagBits
Definition: vulkan_core.h:2775
VkFlags VkSamplerCreateFlags
Definition: vulkan_core.h:2670
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
struct VkSamplerBorderColorComponentMappingCreateInfoEXT VkSamplerBorderColorComponentMappingCreateInfoEXT
VkResult(VKAPI_PTR * PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
Definition: vulkan_core.h:3932
struct VkPhysicalDevicePresentIdFeaturesKHR VkPhysicalDevicePresentIdFeaturesKHR
VkMemoryRequirements memoryRequirements
Definition: vulkan_core.h:5183
VkShaderFloatControlsIndependence denormBehaviorIndependence
Definition: vulkan_core.h:6088
struct VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupport
void(VKAPI_PTR * PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
Definition: vulkan_core.h:9764
VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
struct VkImageSubresource2EXT VkImageSubresource2EXT
struct VkImageViewSampleWeightCreateInfoQCOM VkImageViewSampleWeightCreateInfoQCOM
VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT
void(VKAPI_PTR * PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:8462
VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
struct VkMicromapCreateInfoEXT VkMicromapCreateInfoEXT
VkDebugUtilsMessageTypeFlagBitsEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
VkStructureType sType
Definition: vulkan_core.h:8218
VkDeviceSize nonCoherentAtomSize
Definition: vulkan_core.h:3137
VkPerformanceCounterDescriptionFlagBitsKHR
Definition: vulkan_core.h:8615
VkResult(VKAPI_PTR * PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Definition: vulkan_core.h:8932
VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR
Definition: vulkan_core.h:8869
struct VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfo
VkFlags VkCommandPoolCreateFlags
Definition: vulkan_core.h:2747
struct VkPresentRegionKHR VkPresentRegionKHR
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
struct VkDebugUtilsMessengerCreateInfoEXT VkDebugUtilsMessengerCreateInfoEXT
uint32_t width
Definition: vulkan_core.h:2784
struct VkPresentIdKHR VkPresentIdKHR
const uint32_t * pCorrelatedViewMasks
Definition: vulkan_core.h:6040
void(VKAPI_PTR * PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
Definition: vulkan_core.h:5549
VkPerformanceValueTypeINTEL
VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR
Definition: vulkan_core.h:8261
VkImageTiling
Definition: vulkan_core.h:1692
const void * pNext
Definition: vulkan_core.h:6018
VkCommandBufferUsageFlags flags
Definition: vulkan_core.h:3819
VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
VkDeviceSize triangleArrayStride
VkFlags VkAccelerationStructureMotionInfoFlagsNV
void(VKAPI_PTR * PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
VkAccelerationStructureTypeKHR type
VkDeviceSize vertexOffset
void(VKAPI_PTR * PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3954
VkAccelerationStructureCompatibilityKHR
VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR
Definition: vulkan_core.h:8398
VkSamplerAddressMode addressModeV
Definition: vulkan_core.h:3638
struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV VkPipelineViewportCoarseSampleOrderStateCreateInfoNV
void(VKAPI_PTR * PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
struct VkDrmFormatModifierPropertiesListEXT VkDrmFormatModifierPropertiesListEXT
VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
VkFlags VkSwapchainCreateFlagsKHR
Definition: vulkan_core.h:7637
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the queue
Definition: thread.h:623
uint32_t preserveAttachmentCount
Definition: vulkan_core.h:3764
VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags
VkBuildMicromapFlagBitsEXT
VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
uint32_t regionCount
Definition: vulkan_core.h:7019
VkFenceCreateFlags flags
Definition: vulkan_core.h:3314
GLint location
Definition: glcorearb.h:805
VkAccelerationStructureBuildTypeKHR
VkDeviceAddress callableShaderBindingTableAddress
Definition: vulkan_core.h:9756
uint32_t signalSemaphoreInfoCount
Definition: vulkan_core.h:6963
struct VkPhysicalDeviceConditionalRenderingFeaturesEXT VkPhysicalDeviceConditionalRenderingFeaturesEXT
VkSampleCountFlags sampleCounts
Definition: vulkan_core.h:2948
struct VkPhysicalDeviceShaderImageFootprintFeaturesNV VkPhysicalDeviceShaderImageFootprintFeaturesNV
VkDirectDriverLoadingFlagsLUNARG flags
VkFlags VkPipelineViewportStateCreateFlags
Definition: vulkan_core.h:2634
VkResult(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VkStructureType sType
VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
uint32_t queueFamilyIndex
Definition: vulkan_core.h:5336
VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
const void * pNext
Definition: vulkan_core.h:3715
VkDeviceSize size
Definition: vulkan_core.h:6990
VkResolveModeFlagBits resolveMode
Definition: vulkan_core.h:7159
VkImageLayout srcImageLayout
Definition: vulkan_core.h:7089
VkBool32 descriptorBindingSampledImageUpdateAfterBind
Definition: vulkan_core.h:5879
void(VKAPI_PTR * PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR
Definition: vulkan_core.h:8513
struct VkImportMemoryFdInfoKHR VkImportMemoryFdInfoKHR
char description[VK_MAX_DESCRIPTION_SIZE]
Definition: vulkan_core.h:9443
struct VkCommandPoolCreateInfo VkCommandPoolCreateInfo
void(VKAPI_PTR * PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
VkFramebuffer framebuffer
Definition: vulkan_core.h:3900
void(VKAPI_PTR * PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:9562
VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
VkImageLayout srcImageLayout
Definition: vulkan_core.h:7067
struct VkCopyCommandTransformInfoQCOM VkCopyCommandTransformInfoQCOM
VkExtent2D physicalDimensions
Definition: vulkan_core.h:7838
VkComponentSwizzle b
Definition: vulkan_core.h:3388
VkFlags VkGeometryFlagsKHR
struct VkImageCaptureDescriptorDataInfoEXT VkImageCaptureDescriptorDataInfoEXT
struct VkConformanceVersion VkConformanceVersion
void(VKAPI_PTR * PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7293
struct VkMutableDescriptorTypeListEXT VkMutableDescriptorTypeListEXT
const void * pNext
Definition: vulkan_core.h:2930
struct VkShaderStatisticsInfoAMD VkShaderStatisticsInfoAMD
VkDeviceSize bufferOffset
Definition: vulkan_core.h:3837
VkStructureType sType
Definition: vulkan_core.h:6899
VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
struct VkAllocationCallbacks VkAllocationCallbacks
struct VkDrmFormatModifierPropertiesList2EXT VkDrmFormatModifierPropertiesList2EXT
struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT
VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]
Definition: vulkan_core.h:3144
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
VkTimeDomainEXT
struct VkDedicatedAllocationMemoryAllocateInfoNV VkDedicatedAllocationMemoryAllocateInfoNV
VkFlags VkMemoryAllocateFlags
Definition: vulkan_core.h:4943
struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures
VkPipelineLayoutCreateFlags flags
Definition: vulkan_core.h:3623
VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR
Definition: vulkan_core.h:9104
VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated
Definition: vulkan_core.h:6798
struct VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeatures
VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated
Definition: vulkan_core.h:6819
float height
Definition: vulkan_core.h:3494
void(VKAPI_PTR * PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR
Definition: vulkan_core.h:8359
char driverInfo[VK_MAX_DRIVER_INFO_SIZE]
Definition: vulkan_core.h:5919
const void * pNext
Definition: vulkan_core.h:9505
VkImageUsageFlags supportedUsageFlags
Definition: vulkan_core.h:7581
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
struct VkPhysicalDeviceOpticalFlowFeaturesNV VkPhysicalDeviceOpticalFlowFeaturesNV
struct VkPhysicalDeviceShaderIntegerDotProductFeatures VkPhysicalDeviceShaderIntegerDotProductFeatures
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VkRemoteAddressNV *pAddress)
VkInstanceCreateFlags flags
Definition: vulkan_core.h:2955
uint32_t dstArrayElement
Definition: vulkan_core.h:5391
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
VkImageViewCreateFlags flags
Definition: vulkan_core.h:3395
VkResult(VKAPI_PTR * PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
Definition: vulkan_core.h:3983
struct VkDebugUtilsMessengerCallbackDataEXT VkDebugUtilsMessengerCallbackDataEXT
VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
const uint32_t * pQueueFamilyIndices
Definition: vulkan_core.h:3373
const void * pNext
Definition: vulkan_core.h:2954
VkFlags VkImageCompressionFixedRateFlagsEXT
VkImageCompressionFlagBitsEXT
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName)
VkAccelerationStructureMotionInfoFlagsNV flags
VkShaderStageFlagBits
Definition: vulkan_core.h:2594
VkResult(VKAPI_PTR * PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
struct VkRenderPassCreationControlEXT VkRenderPassCreationControlEXT
void(VKAPI_PTR * PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
Definition: vulkan_core.h:3990
void(VKAPI_PTR * PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
struct VkRenderPassCreationFeedbackCreateInfoEXT VkRenderPassCreationFeedbackCreateInfoEXT
VkDisplayModeParametersKHR parameters
Definition: vulkan_core.h:7815
VkImageCompressionFlagsEXT imageCompressionFlags
VkPresentModeKHR presentMode
Definition: vulkan_core.h:7663
VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
VkIndirectCommandsLayoutUsageFlagsNV flags
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
Definition: vulkan_core.h:8461
VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind
Definition: vulkan_core.h:6765
struct VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxProperties
VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR
Definition: vulkan_core.h:8282
struct VkBindBufferMemoryInfo VkBindBufferMemoryInfo
VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
VkResult(VKAPI_PTR * PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
struct VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfo
VkMemoryDecompressionMethodFlagsNV decompressionMethods
VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT
uint32_t dstQueueFamilyIndex
Definition: vulkan_core.h:2869
VkShaderModuleCreateFlags flags
Definition: vulkan_core.h:3406
VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
VkResult(VKAPI_PTR * PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
void(VKAPI_PTR * PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
struct VkImageCompressionControlEXT VkImageCompressionControlEXT
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
struct VkAccelerationStructureGeometryInstancesDataKHR VkAccelerationStructureGeometryInstancesDataKHR
VkDeviceSize callableShaderBindingTableSize
Definition: vulkan_core.h:9757
VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
VkFlags VkValidationCacheCreateFlagsEXT
VkDeviceSize sequencesIndexOffset
uint32_t maxCombinedClipAndCullDistances
Definition: vulkan_core.h:3127
VkOffset3D srcOffsets[2]
Definition: vulkan_core.h:7058
struct VkImageViewCreateInfo VkImageViewCreateInfo
VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
void(VKAPI_PTR * PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
Definition: vulkan_core.h:9692
const void * pNext
Definition: vulkan_core.h:7025
struct VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfo
VkStructureType sType
Definition: vulkan_core.h:5333
void(VKAPI_PTR * PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
void(VKAPI_PTR * PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
Definition: vulkan_core.h:8334
VkFlags VkSemaphoreCreateFlags
Definition: vulkan_core.h:2423
struct VkDescriptorSetLayoutHostMappingInfoVALVE VkDescriptorSetLayoutHostMappingInfoVALVE
uint8_t pipelineIdentifier[VK_UUID_SIZE]
struct VkPipelineShaderStageCreateInfo VkPipelineShaderStageCreateInfo
VkFlags VkAttachmentDescriptionFlags
Definition: vulkan_core.h:2699
struct VkDispatchIndirectCommand VkDispatchIndirectCommand
const void * pNext
Definition: vulkan_core.h:7670
VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR
Definition: vulkan_core.h:9523
VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV
struct VkCopyMemoryToMicromapInfoEXT VkCopyMemoryToMicromapInfoEXT
VkVertexInputRate
Definition: vulkan_core.h:1951
GLuint const GLchar * name
Definition: glcorearb.h:786
const VkRayTracingShaderGroupCreateInfoNV * pGroups
VkFlags VkDebugReportFlagsEXT
Definition: vulkan_core.h:9872
VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
VkCommandPoolCreateFlagBits
Definition: vulkan_core.h:2741
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
struct VkAccelerationStructureBuildSizesInfoKHR VkAccelerationStructureBuildSizesInfoKHR
struct VkDrmFormatModifierProperties2EXT VkDrmFormatModifierProperties2EXT
VkFormatFeatureFlagBits
Definition: vulkan_core.h:2178
struct VkSubmitInfo2 VkSubmitInfo2
struct VkRectLayerKHR VkRectLayerKHR
struct VkPushConstantRange VkPushConstantRange
VkResult(VKAPI_PTR * PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
Definition: vulkan_core.h:7301
struct VkIndirectCommandsLayoutCreateInfoNV VkIndirectCommandsLayoutCreateInfoNV
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
VkCoverageReductionModeNV
VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
struct VkPipelineRasterizationDepthClipStateCreateInfoEXT VkPipelineRasterizationDepthClipStateCreateInfoEXT
VkValidationCheckEXT
struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV VkPhysicalDeviceCopyMemoryIndirectFeaturesNV
const struct VkBaseInStructure * pNext
Definition: vulkan_core.h:2812
uint32_t enabledExtensionCount
Definition: vulkan_core.h:3191
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
Definition: vulkan_core.h:7860
VkAttachmentStoreOp storeOp
Definition: vulkan_core.h:5985
VkOffset3D imageOffset
Definition: vulkan_core.h:3841
const VkPipelineDynamicStateCreateInfo * pDynamicState
Definition: vulkan_core.h:3606
struct VkImageViewAddressPropertiesNVX VkImageViewAddressPropertiesNVX
VkResult(VKAPI_PTR * PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR
Definition: vulkan_core.h:8914
VkGeometryTrianglesNV triangles
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
Definition: vulkan_core.h:7324
struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT VkDescriptorBufferBindingPushDescriptorBufferHandleEXT
uint32_t enabledLayerCount
Definition: vulkan_core.h:3189
VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV
VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks
Definition: vulkan_core.h:6791
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
VkResult(VKAPI_PTR * PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
Definition: vulkan_core.h:3993
struct VkCopyMicromapToMemoryInfoEXT VkCopyMicromapToMemoryInfoEXT
VkStructureType sType
Definition: vulkan_core.h:8231
VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
void(VKAPI_PTR * PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
Definition: vulkan_core.h:4028
struct VkBaseOutStructure VkBaseOutStructure
void(VKAPI_PTR * PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
VkExternalMemoryHandleTypeFlags compatibleHandleTypes
Definition: vulkan_core.h:5414
VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR
Definition: vulkan_core.h:9326
struct VkPipelineCacheHeaderVersionOne VkPipelineCacheHeaderVersionOne
VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR
Definition: vulkan_core.h:9028
VkResolveModeFlagBits
Definition: vulkan_core.h:5784
VkResult(VKAPI_PTR * PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
Definition: vulkan_core.h:7292
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
const void * pNext
Definition: vulkan_core.h:7169
uint32_t maxVertexInputBindingStride
Definition: vulkan_core.h:3064
struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT VkPhysicalDeviceBorderColorSwizzleFeaturesEXT
VkSharingMode imageSharingMode
Definition: vulkan_core.h:7658
VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
struct VkVertexInputAttributeDescription VkVertexInputAttributeDescription
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
struct VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingProperties
struct VkBindImageMemorySwapchainInfoKHR VkBindImageMemorySwapchainInfoKHR
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties)
VkDeviceGroupPresentModeFlagsKHR modes
Definition: vulkan_core.h:7720
uint8_t pipelineCacheUUID[VK_UUID_SIZE]
Definition: vulkan_core.h:2886
struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT VkPhysicalDeviceExtendedDynamicState3FeaturesEXT
VkBool32 descriptorBindingUpdateUnusedWhilePending
Definition: vulkan_core.h:5884
VkStructureType sType
Definition: vulkan_core.h:7013
const VkSubpassSampleLocationsEXT * pPostSubpassSampleLocations
VkResult(VKAPI_PTR * PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
uint32_t inputAttachmentCount
Definition: vulkan_core.h:3758
struct VkLayerProperties VkLayerProperties
void(VKAPI_PTR * PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
VkAttachmentReference fragmentDensityMapAttachment
struct VkSubpassDescription2 VkSubpassDescription2
VkResult(VKAPI_PTR * PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
VkExternalMemoryFeatureFlags externalMemoryFeatures
Definition: vulkan_core.h:5412
VkSurfaceTransformFlagsKHR supportedTransforms
Definition: vulkan_core.h:7840
const VkAttachmentDescription * pAttachments
Definition: vulkan_core.h:3783
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Definition: vulkan_core.h:5558
struct VkSemaphoreCreateInfo VkSemaphoreCreateInfo
VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT
VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority)
struct VkExternalSemaphoreProperties VkExternalSemaphoreProperties
struct VkDescriptorPoolInlineUniformBlockCreateInfo VkDescriptorPoolInlineUniformBlockCreateInfo
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
VkExtent3D extent
Definition: vulkan_core.h:3893
VkFlags VkDescriptorPoolCreateFlags
Definition: vulkan_core.h:2680
uint32_t shadingRatePaletteEntryCount
void(VKAPI_PTR * PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
VkImageSubresourceLayers srcSubresource
Definition: vulkan_core.h:3889
void(VKAPI_PTR * PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
VkPerformanceOverrideTypeINTEL
void(VKAPI_PTR * PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
Definition: vulkan_core.h:4038
VkFenceImportFlags flags
Definition: vulkan_core.h:8549
struct VkRenderingFragmentShadingRateAttachmentInfoKHR VkRenderingFragmentShadingRateAttachmentInfoKHR
VkExternalMemoryHandleTypeFlagBits handleType
VkOpticalFlowPerformanceLevelNV
VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
uint32_t maxComputeWorkGroupSize[3]
Definition: vulkan_core.h:3086
const VkDescriptorSetLayoutBinding * pBindings
Definition: vulkan_core.h:3710
VkImageLayout layout
Definition: vulkan_core.h:3740
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
void(VKAPI_PTR * PFN_vkInternalAllocationNotification)(void *pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope)
Definition: vulkan_core.h:2899
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
void(VKAPI_PTR * PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
union VkPipelineExecutableStatisticValueKHR VkPipelineExecutableStatisticValueKHR
VkResult(VKAPI_PTR * PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:8880
struct VkMemoryFdPropertiesKHR VkMemoryFdPropertiesKHR
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:8460
uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic
Definition: vulkan_core.h:5957
VkStructureType sType
Definition: vulkan_core.h:6030
VkExternalFenceHandleTypeFlags compatibleHandleTypes
Definition: vulkan_core.h:5481
VkBlendOverlapEXT
VkSparseMemoryBindFlagBits
Definition: vulkan_core.h:2404
const VkRayTracingShaderGroupCreateInfoKHR * pGroups
struct VkSubpassDependency VkSubpassDependency
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
Definition: vulkan_core.h:3978
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
const VkPipelineVertexInputStateCreateInfo * pVertexInputState
void(VKAPI_PTR * PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
struct VkCommandBufferSubmitInfo VkCommandBufferSubmitInfo
VkValidationFeatureEnableEXT
VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR
Definition: vulkan_core.h:9021
struct VkMemoryRequirements2 VkMemoryRequirements2
struct VkImageSwapchainCreateInfoKHR VkImageSwapchainCreateInfoKHR
VkSubmitFlagBits VkSubmitFlagBitsKHR
Definition: vulkan_core.h:9529
void(VKAPI_PTR * PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
Definition: vulkan_core.h:3999
VkFlags VkIndirectCommandsLayoutUsageFlagsNV
VkImageSubresourceLayers dstSubresource
Definition: vulkan_core.h:7059
VkImageType
Definition: vulkan_core.h:1699
VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRobustnessFeaturesEXT
VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR
Definition: vulkan_core.h:8081
void(VKAPI_PTR * PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
struct VkBindIndexBufferIndirectCommandNV VkBindIndexBufferIndirectCommandNV
struct VkImageResolve2 VkImageResolve2
void(VKAPI_PTR * PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT
uint32_t maxFragmentOutputAttachments
Definition: vulkan_core.h:3080
const VkDeviceQueueCreateInfo * pQueueCreateInfos
Definition: vulkan_core.h:3188
VkDeviceSize callableShaderBindingTableStride
Definition: vulkan_core.h:9758
VkPipelineRobustnessBufferBehaviorEXT uniformBuffers
struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures
VkConformanceVersion conformanceVersion
Definition: vulkan_core.h:5920
VkDeviceAddress reportedAddress
VkImageAspectFlags aspectMask
Definition: vulkan_core.h:5997
VkFlags VkSurfaceTransformFlagsKHR
Definition: vulkan_core.h:7570
VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
Definition: vulkan_core.h:3912
VkResult(VKAPI_PTR * PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:9357
void(VKAPI_PTR * PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
Definition: vulkan_core.h:7306
struct VkDeviceQueueInfo2 VkDeviceQueueInfo2
const VkDescriptorImageInfo * pStorageImage
const VkAttachmentReference2 * pInputAttachments
Definition: vulkan_core.h:6007
VkFlags64 VkMemoryDecompressionMethodFlagsNV
struct VkDeviceQueueGlobalPriorityCreateInfoKHR VkDeviceQueueGlobalPriorityCreateInfoKHR
VkPipelineCreationFeedbackFlags flags
Definition: vulkan_core.h:6831
VkBool32 anisotropyEnable
Definition: vulkan_core.h:3641
struct VkCopyMicromapInfoEXT VkCopyMicromapInfoEXT
void(VKAPI_PTR * PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
VkStructureType sType
Definition: vulkan_core.h:6986
VkStructureType sType
Definition: vulkan_core.h:2862
VkPipelineColorBlendStateCreateFlags flags
Definition: vulkan_core.h:3576
VkPrivateDataSlotCreateInfo VkPrivateDataSlotCreateInfoEXT
VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR
Definition: vulkan_core.h:8515
void(VKAPI_PTR * PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
Definition: vulkan_core.h:8140
VkDirectDriverLoadingModeLUNARG
VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
struct VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8Features
VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE
const VkAccelerationStructureGeometryKHR *const * ppGeometries
VkDeviceMemory memory
Definition: vulkan_core.h:5065
VkMemoryRequirements2 VkMemoryRequirements2KHR
Definition: vulkan_core.h:8875
VkImageViewCreateFlagBits
Definition: vulkan_core.h:2518
void(VKAPI_PTR * PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
VkSampleCountFlagBits samples
Definition: vulkan_core.h:5983
struct VkQueryPoolPerformanceCreateInfoKHR VkQueryPoolPerformanceCreateInfoKHR
VkResult(VKAPI_PTR * PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
Definition: vulkan_core.h:7725
VkFlags VkQueryPoolCreateFlags
Definition: vulkan_core.h:2449
VkImageCompressionFixedRateFlagsEXT * pFixedRateFlags
struct VkPerformanceMarkerInfoINTEL VkPerformanceMarkerInfoINTEL
#define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR
Definition: vulkan_core.h:9052
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
VkSampleCountFlagBits samples
Definition: vulkan_core.h:3368
const VkSemaphoreSubmitInfo * pSignalSemaphoreInfos
Definition: vulkan_core.h:6964
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
union VkDeviceOrHostAddressConstKHR VkDeviceOrHostAddressConstKHR
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
Definition: vulkan_core.h:3936
struct VkAccelerationStructureCaptureDescriptorDataInfoEXT VkAccelerationStructureCaptureDescriptorDataInfoEXT
VkResult(VKAPI_PTR * PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
struct VkFenceCreateInfo VkFenceCreateInfo
struct VkProtectedSubmitInfo VkProtectedSubmitInfo
VkOpticalFlowGridSizeFlagsNV hintGridSize
VkValidationCacheHeaderVersionEXT
VkBuildMicromapModeEXT mode
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
struct VkSparseImageMemoryBind VkSparseImageMemoryBind
VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
VkConservativeRasterizationModeEXT
GLsizei samples
Definition: glcorearb.h:1298
VkFlags VkGraphicsPipelineLibraryFlagsEXT
VkStructureType sType
struct VkBlitImageInfo2 VkBlitImageInfo2
VkDriverId
Definition: vulkan_core.h:5716
VkImageSubresourceLayers dstSubresource
Definition: vulkan_core.h:3883
VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated
Definition: vulkan_core.h:6821
struct VkPrivateDataSlotCreateInfo VkPrivateDataSlotCreateInfo
void(VKAPI_PTR * PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
uint32_t maxComputeWorkGroupInvocations
Definition: vulkan_core.h:3085
struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV VkPhysicalDeviceComputeShaderDerivativesFeaturesNV
VkPipelineCreationFeedbackCreateInfo VkPipelineCreationFeedbackCreateInfoEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
const VkPipelineViewportStateCreateInfo * pViewportState
Definition: vulkan_core.h:3601
const VkMicromapUsageEXT * pUsageCounts
const uint32_t * pCode
Definition: vulkan_core.h:3408
struct VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamicRenderingFeatures
VkStructureType sType
Definition: vulkan_core.h:5979
VkFlags VkDebugUtilsMessageSeverityFlagsEXT
VkFlags VkBuildAccelerationStructureFlagsKHR
struct VkDeviceEventInfoEXT VkDeviceEventInfoEXT
VkImageAspectFlagBits planeAspect
Definition: vulkan_core.h:5368
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
Definition: vulkan_core.h:5553
VkFlags VkPipelineTessellationStateCreateFlags
Definition: vulkan_core.h:2633
VkResult(VKAPI_PTR * PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:3994
struct VkPhysicalDevicePipelineRobustnessPropertiesEXT VkPhysicalDevicePipelineRobustnessPropertiesEXT
struct VkFramebufferCreateInfo VkFramebufferCreateInfo
VkExternalFenceHandleTypeFlagBits handleType
Definition: vulkan_core.h:5474
VkBool32 descriptorBindingStorageBufferUpdateAfterBind
Definition: vulkan_core.h:5881
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
GLenum mode
Definition: glcorearb.h:99
uint8_t pipelineCacheUUID[VK_UUID_SIZE]
Definition: vulkan_core.h:3162
VkStructureType sType
VkResult(VKAPI_PTR * PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
Definition: vulkan_core.h:7723
struct VkPhysicalDeviceOpacityMicromapFeaturesEXT VkPhysicalDeviceOpacityMicromapFeaturesEXT
VkPhysicalDeviceType
Definition: vulkan_core.h:1706
VkResult(VKAPI_PTR * PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
GLint GLint GLsizei GLsizei GLsizei depth
Definition: glcorearb.h:476
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
struct VkDeviceFaultVendorInfoEXT VkDeviceFaultVendorInfoEXT
VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamicRenderingFeaturesKHR
Definition: vulkan_core.h:7951
VkPipelineMultisampleStateCreateFlags flags
Definition: vulkan_core.h:3528
const VkSampleLocationEXT * pSampleLocations
uint64_t(VKAPI_PTR * PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
Definition: vulkan_core.h:9332
struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT
struct VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfo
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
VkFragmentShadingRateCombinerOpKHR combinerOps[2]
VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeaturesEXT
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
uint32_t bufferRowLength
Definition: vulkan_core.h:7027
VkCopyAccelerationStructureModeKHR mode
uint32_t subdivisionLevel
struct VkDeviceDiagnosticsConfigCreateInfoNV VkDeviceDiagnosticsConfigCreateInfoNV
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
VkFlags VkDeviceGroupPresentModeFlagsKHR
Definition: vulkan_core.h:7646
VkAccessFlagBits2 VkAccessFlagBits2KHR
Definition: vulkan_core.h:9527
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkFlags VkSemaphoreImportFlags
Definition: vulkan_core.h:5017
VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
VkDeviceQueueCreateFlags flags
Definition: vulkan_core.h:5335
VkFlags VkOpticalFlowSessionCreateFlagsNV
struct VkValidationFeaturesEXT VkValidationFeaturesEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
struct VkSwapchainPresentBarrierCreateInfoNV VkSwapchainPresentBarrierCreateInfoNV
VkAttachmentLoadOp loadOp
Definition: vulkan_core.h:7162
struct VkBindShaderGroupIndirectCommandNV VkBindShaderGroupIndirectCommandNV
VkPipelineInfoKHR VkPipelineInfoEXT
VkViewportCoordinateSwizzleNV z
VkFlags VkDependencyFlags
Definition: vulkan_core.h:2710
VkResult(VKAPI_PTR * PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
void(VKAPI_PTR * PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3968
struct VkDisplayNativeHdrSurfaceCapabilitiesAMD VkDisplayNativeHdrSurfaceCapabilitiesAMD
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
Definition: vulkan_core.h:8037
struct VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeatures
uint32_t maxVertexInputBindings
Definition: vulkan_core.h:3062
VkDescriptorUpdateTemplateType
Definition: vulkan_core.h:4900
void(VKAPI_PTR * PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3973
VkBlendOverlapEXT blendOverlap
VkPerformanceValueTypeINTEL type
struct VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2
struct VkDisplayModeProperties2KHR VkDisplayModeProperties2KHR
struct VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2
struct VkAccelerationStructureGeometryAabbsDataKHR VkAccelerationStructureGeometryAabbsDataKHR
const VkDebugUtilsLabelEXT * pQueueLabels
VkImageSubresourceRange subresourceRange
Definition: vulkan_core.h:2871
VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering(VkCommandBuffer commandBuffer)
VkResult(VKAPI_PTR * PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
VkFlags VkImageAspectFlags
Definition: vulkan_core.h:2176
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:7300
VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
VkQueueGlobalPriorityKHR VkQueueGlobalPriorityEXT
struct VkDescriptorSetLayoutBinding VkDescriptorSetLayoutBinding
struct VkPerformanceQuerySubmitInfoKHR VkPerformanceQuerySubmitInfoKHR
struct VkClearDepthStencilValue VkClearDepthStencilValue
uint32_t bufferImageHeight
Definition: vulkan_core.h:3839
VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
struct VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSubgroupSizeControlProperties
VkSurfaceCounterFlagsEXT surfaceCounters
struct VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubgroupSizeControlFeatures
VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR
Definition: vulkan_core.h:8156
VkFormatProperties3 VkFormatProperties3KHR
Definition: vulkan_core.h:9733
struct VkSparseImageFormatProperties VkSparseImageFormatProperties
VkFlags VkPrivateDataSlotCreateFlags
Definition: vulkan_core.h:6496
VkShaderFloatControlsIndependence
Definition: vulkan_core.h:5756
VkDeviceSize srcOffset
Definition: vulkan_core.h:6988
float minDepth
Definition: vulkan_core.h:3495
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
VkAccessFlags srcAccessMask
Definition: vulkan_core.h:6023
uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers
Definition: vulkan_core.h:5947
VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes
VkFlags VkQueryPipelineStatisticFlags
Definition: vulkan_core.h:2448
void(VKAPI_PTR * PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3918
VkRect2D rect
Definition: vulkan_core.h:3868
VkPipelineBindPoint pipelineBindPoint
Definition: vulkan_core.h:3757
struct VkImageViewUsageCreateInfo VkImageViewUsageCreateInfo
uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks
Definition: vulkan_core.h:6789
struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT VkPhysicalDeviceExtendedDynamicState3PropertiesEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VkResult(VKAPI_PTR * PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR
Definition: vulkan_core.h:8924
VkResult(VKAPI_PTR * PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing
Definition: vulkan_core.h:5877
struct VkSampleLocationsInfoEXT VkSampleLocationsInfoEXT
void(VKAPI_PTR * PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
Definition: vulkan_core.h:9697
struct VkShaderModuleCreateInfo VkShaderModuleCreateInfo
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
Definition: vulkan_core.h:5559
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
struct VkPipelineSampleLocationsStateCreateInfoEXT VkPipelineSampleLocationsStateCreateInfoEXT
void(VKAPI_PTR * PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
Definition: vulkan_core.h:8102
struct VkCheckpointDataNV VkCheckpointDataNV
uint32_t maxFragmentInputComponents
Definition: vulkan_core.h:3079
struct VkSubpassBeginInfo VkSubpassBeginInfo
char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]
Definition: vulkan_core.h:3161
VkFlags VkDescriptorSetLayoutCreateFlags
Definition: vulkan_core.h:2693
VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]
Definition: vulkan_core.h:5151
const VkDescriptorImageInfo * pCombinedImageSampler
struct VkPipelineViewportShadingRateImageStateCreateInfoNV VkPipelineViewportShadingRateImageStateCreateInfoNV
VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR
Definition: vulkan_core.h:9324
const uint64_t * pWaitSemaphoreValues
Definition: vulkan_core.h:6322
VkFormatProperties formatProperties
Definition: vulkan_core.h:5207
VkSubpassEndInfo VkSubpassEndInfoKHR
Definition: vulkan_core.h:8458
#define VK_MAX_EXTENSION_NAME_SIZE
Definition: vulkan_core.h:135
VkPerformanceCounterUnitKHR unit
Definition: vulkan_core.h:8644
VkAccelerationStructureMotionInstanceDataNV data
const VkRect2D * pSplitInstanceBindRegions
Definition: vulkan_core.h:5144
VkStructureType sType
Definition: vulkan_core.h:3221
void(VKAPI_PTR * PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR
Definition: vulkan_core.h:8366
VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes
Definition: vulkan_core.h:5480
VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated
Definition: vulkan_core.h:6814
VkDeviceBufferMemoryRequirements VkDeviceBufferMemoryRequirementsKHR
Definition: vulkan_core.h:9785
const VkSpecializationMapEntry * pMapEntries
Definition: vulkan_core.h:3427
struct VkOpaqueCaptureDescriptorDataCreateInfoEXT VkOpaqueCaptureDescriptorDataCreateInfoEXT
const VkFormat * pViewFormats
Definition: vulkan_core.h:5975
uint32_t maxDescriptorSetInputAttachments
Definition: vulkan_core.h:3060
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
struct VkValidationFlagsEXT VkValidationFlagsEXT
struct VkImageMemoryBarrier VkImageMemoryBarrier
uint32_t commandBufferCount
Definition: vulkan_core.h:3214
const VkSubpassDependency2 * pDependencies
Definition: vulkan_core.h:6038
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
VkOffset3D dstOffsets[2]
Definition: vulkan_core.h:3877
struct VkVertexInputBindingDescription2EXT VkVertexInputBindingDescription2EXT
VkBlitImageInfo2 VkBlitImageInfo2KHR
Definition: vulkan_core.h:9678
VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
Definition: vulkan_core.h:9248
void(VKAPI_PTR * PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:3995
const void * pNext
VkImageCreateFlagBits
Definition: vulkan_core.h:2233
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR
Definition: vulkan_core.h:8402
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
GLsizeiptr size
Definition: glcorearb.h:664
struct VkMultisamplePropertiesEXT VkMultisamplePropertiesEXT
VkDescriptorPoolCreateFlagBits
Definition: vulkan_core.h:2672
void(VKAPI_PTR * PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
struct VkPipelineViewportSwizzleStateCreateInfoNV VkPipelineViewportSwizzleStateCreateInfoNV
VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR
Definition: vulkan_core.h:8026
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
VkDirectDriverLoadingModeLUNARG mode
struct VkVertexInputBindingDescription VkVertexInputBindingDescription
struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV
GLenum GLenum dst
Definition: glcorearb.h:1793
VkPipelineStageFlags2 stageMask
Definition: vulkan_core.h:6944
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
const void * pNext
Definition: vulkan_core.h:8232
struct VkPhysicalDeviceSparseProperties VkPhysicalDeviceSparseProperties
VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR
Definition: vulkan_core.h:9119
VkBufferImageCopy2 VkBufferImageCopy2KHR
Definition: vulkan_core.h:9688
struct VkPresentRegionsKHR VkPresentRegionsKHR
void(VKAPI_PTR * PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:4014
struct VkPhysicalDeviceLineRasterizationPropertiesEXT VkPhysicalDeviceLineRasterizationPropertiesEXT
VkFlags VkFramebufferCreateFlags
Definition: vulkan_core.h:2717
struct VkExternalBufferProperties VkExternalBufferProperties
void(VKAPI_PTR * PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
GLuint shader
Definition: glcorearb.h:785
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
const VkPipelineTessellationStateCreateInfo * pTessellationState
VkResult(VKAPI_PTR * PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
Definition: vulkan_core.h:3991
VkComponentSwizzle
Definition: vulkan_core.h:1746
const VkPipelineLibraryCreateInfoKHR * pLibraryInfo
uint8_t deviceUUID[VK_UUID_SIZE]
Definition: vulkan_core.h:5446
VkResolveModeFlagBits VkResolveModeFlagBitsKHR
Definition: vulkan_core.h:9113
VkAttachmentDescriptionFlags flags
Definition: vulkan_core.h:5981
VkObjectType
Definition: vulkan_core.h:1303
VkToolPurposeFlagBits VkToolPurposeFlagBitsEXT
const VkAttachmentReference * pInputAttachments
Definition: vulkan_core.h:3759
VkStructureType sType
Definition: vulkan_core.h:8753
VkShadingRatePaletteEntryNV shadingRate
void(VKAPI_PTR * PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
Definition: vulkan_core.h:4019
const VkCoarseSampleOrderCustomNV * pCustomSampleOrders
VkEventCreateFlags flags
Definition: vulkan_core.h:3326
void(VKAPI_PTR * PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
GLsizeiptr const void GLenum usage
Definition: glcorearb.h:664
VkFragmentShadingRateNV
VkBool32 shaderStorageTexelBufferArrayDynamicIndexing
Definition: vulkan_core.h:5870
void(VKAPI_PTR * PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
Definition: vulkan_core.h:4023
VkBool32(VKAPI_PTR * PFN_vkDebugUtilsMessengerCallbackEXT)(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData, void *pUserData)
VkResult(VKAPI_PTR * PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
uint32_t VkFlags
Definition: vulkan_core.h:96
VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer)
VkStructureType sType
Definition: vulkan_core.h:8225
VkDeviceMemoryReportFlagsEXT flags
VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
struct VkRenderPassSubpassFeedbackCreateInfoEXT VkRenderPassSubpassFeedbackCreateInfoEXT
VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT
struct VkPhysicalDeviceLineRasterizationFeaturesEXT VkPhysicalDeviceLineRasterizationFeaturesEXT
VkPipelineRasterizationConservativeStateCreateFlagsEXT flags
void(VKAPI_PTR * PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
Definition: vulkan_core.h:7317
VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated
Definition: vulkan_core.h:6796
VkFlags VkBufferCreateFlags
Definition: vulkan_core.h:2474
VkDeviceSize size
Definition: vulkan_core.h:3826
Definition: vulkan_core.h:5389
VkDeviceAddress srcAddress
uint32_t maxPerStageDescriptorStorageImages
Definition: vulkan_core.h:3050
VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance
uint32_t maxVertexInputAttributes
Definition: vulkan_core.h:3061
VkImageSubresourceLayers srcSubresource
Definition: vulkan_core.h:7078
VkStructureType sType
Definition: vulkan_core.h:3229
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(uint32_t *pApiVersion)
VkImageAspectFlags aspectMask
Definition: vulkan_core.h:2854
VkResolveModeFlags VkResolveModeFlagsKHR
Definition: vulkan_core.h:9115
struct VkPipelineRasterizationConservativeStateCreateInfoEXT VkPipelineRasterizationConservativeStateCreateInfoEXT
VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing
Definition: vulkan_core.h:5876
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
VkStructureType sType
Definition: vulkan_core.h:8555
VkPipelineBindPoint
Definition: vulkan_core.h:2089
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
uint32_t layer
Definition: vulkan_core.h:8376
VkFlags VkAccessFlags
Definition: vulkan_core.h:2155
struct VkApplicationInfo VkApplicationInfo
VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR
Definition: vulkan_core.h:8727
VkResult(VKAPI_PTR * PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
Definition: vulkan_core.h:3931
VkDeviceDiagnosticsConfigFlagBitsNV
VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR
Definition: vulkan_core.h:8910
VkBool32 shaderUniformTexelBufferArrayDynamicIndexing
Definition: vulkan_core.h:5869
VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
VkSampleCountFlags sampledImageIntegerSampleCounts
Definition: vulkan_core.h:3118
VkViewportCoordinateSwizzleNV
VkCompositeAlphaFlagsKHR supportedCompositeAlpha
VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
Definition: vulkan_core.h:9450
const float * pQueuePriorities
Definition: vulkan_core.h:3180
const VkAttachmentReference2 * pDepthStencilResolveAttachment
Definition: vulkan_core.h:6185
VkDisplayModePropertiesKHR displayModeProperties
Definition: vulkan_core.h:8802
VkDeviceSize sequencesCountOffset
struct VkSparseImageOpaqueMemoryBindInfo VkSparseImageOpaqueMemoryBindInfo
struct VkImageResolve VkImageResolve
char version[VK_MAX_EXTENSION_NAME_SIZE]
Definition: vulkan_core.h:6853
VkImageAspectFlags aspectMask
Definition: vulkan_core.h:3262
void(VKAPI_PTR * PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
Definition: vulkan_core.h:4035
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes)
VkPipelineDiscardRectangleStateCreateFlagsEXT flags
VkResult(VKAPI_PTR * PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
Definition: vulkan_core.h:7726
uint32_t maxPerStageDescriptorSampledImages
Definition: vulkan_core.h:3049
VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR
Definition: vulkan_core.h:8206
const VkDescriptorBufferInfo * pBufferInfo
Definition: vulkan_core.h:3722
VkPipelineCacheHeaderVersion headerVersion
Definition: vulkan_core.h:2883
VkDiscardRectangleModeEXT discardRectangleMode
VkBool32 shaderStorageImageReadWithoutFormat
Definition: vulkan_core.h:3005
VkAttachmentLoadOp loadOp
Definition: vulkan_core.h:5984
const void *const * pExtras
VkImageCompressionFlagsEXT flags
struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR
VkQueryPoolSamplingModeINTEL performanceCountersSampling
VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR
Definition: vulkan_core.h:8208
VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative
Definition: vulkan_core.h:5943
struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
struct VkGeneratedCommandsInfoNV VkGeneratedCommandsInfoNV
struct VkDeviceMemoryReportCallbackDataEXT VkDeviceMemoryReportCallbackDataEXT
VkConformanceVersion conformanceVersion
Definition: vulkan_core.h:6068
struct VkPipelineViewportExclusiveScissorStateCreateInfoNV VkPipelineViewportExclusiveScissorStateCreateInfoNV
VkStructureType sType
Definition: vulkan_core.h:7045
VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain)
Definition: vulkan_core.h:8497
void(VKAPI_PTR * PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
Definition: vulkan_core.h:4020
VkFlags VkSubmitFlags
Definition: vulkan_core.h:6665
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:4036
VkDeviceSize vertexStride
struct VkFormatProperties3 VkFormatProperties3
struct VkSpecializationInfo VkSpecializationInfo
VkStructureType sType
Definition: vulkan_core.h:8303
VkDeviceSize sparseAddressSpaceSize
Definition: vulkan_core.h:3044
VkStructureType sType
struct VkFragmentShadingRateAttachmentInfoKHR VkFragmentShadingRateAttachmentInfoKHR
VkMicromapTypeEXT
VkPipelineCompilerControlFlagBitsAMD
VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
VkDisplayPlaneAlphaFlagBitsKHR
Definition: vulkan_core.h:7792
VkCompositeAlphaFlagBitsKHR
Definition: vulkan_core.h:7562
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
VkRenderingAttachmentInfo VkRenderingAttachmentInfoKHR
Definition: vulkan_core.h:7947
VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR
Definition: vulkan_core.h:8286
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
struct VkPerformanceOverrideInfoINTEL VkPerformanceOverrideInfoINTEL
const VkDescriptorAddressInfoEXT * pUniformTexelBuffer
const VkImageCreateInfo * pCreateInfo
Definition: vulkan_core.h:7287
VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
struct VkSubpassResolvePerformanceQueryEXT VkSubpassResolvePerformanceQueryEXT
struct VkDescriptorSetAllocateInfo VkDescriptorSetAllocateInfo
struct VkPhysicalDeviceImageViewMinLodFeaturesEXT VkPhysicalDeviceImageViewMinLodFeaturesEXT
VkExtent3D extent
Definition: vulkan_core.h:3885
void(VKAPI_PTR * PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
VkFormatFeatureFlags optimalTilingFeatures
Definition: vulkan_core.h:2940
VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR
Definition: vulkan_core.h:8022
VkSharingMode
Definition: vulkan_core.h:1740
struct VkAabbPositionsKHR VkAabbPositionsKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
VkClearValue clearValue
Definition: vulkan_core.h:3864
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
void(VKAPI_PTR * PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
Definition: vulkan_core.h:5550
VkDeviceSize memoryOffset
Definition: vulkan_core.h:5058
VkImageLayout finalLayout
Definition: vulkan_core.h:5989
VkExternalFenceHandleTypeFlagBits handleType
Definition: vulkan_core.h:8558
struct VkCopyMemoryToAccelerationStructureInfoKHR VkCopyMemoryToAccelerationStructureInfoKHR
VkEventCreateFlagBits
Definition: vulkan_core.h:2425
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
void(VKAPI_PTR * PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents)
Definition: vulkan_core.h:4040
VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT
VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR
Definition: vulkan_core.h:8007
VkResult(VKAPI_PTR * PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
struct VkSubresourceLayout2EXT VkSubresourceLayout2EXT
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
VkPipelineBindPoint pipelineBindPoint
Definition: vulkan_core.h:6004
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
void(VKAPI_PTR * PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:4016
VkBufferCreateFlags flags
Definition: vulkan_core.h:3341
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
Definition: vulkan_core.h:8521
struct VkPipelineRasterizationLineStateCreateInfoEXT VkPipelineRasterizationLineStateCreateInfoEXT
struct VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphoreProperties
uint32_t maxPerStageDescriptorStorageBuffers
Definition: vulkan_core.h:3048
struct VkCommandBufferInheritanceInfo VkCommandBufferInheritanceInfo
VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
VkSparseMemoryBindFlags flags
Definition: vulkan_core.h:3273
struct VkFenceGetFdInfoKHR VkFenceGetFdInfoKHR
Definition: vulkan_core.h:3419
VkResult(VKAPI_PTR * PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
VkSampleCountFlagBits
Definition: vulkan_core.h:2263
VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
VkShaderFloatControlsIndependence roundingModeIndependence
Definition: vulkan_core.h:5922
const VkAttachmentReference * pDepthStencilAttachment
Definition: vulkan_core.h:3763
VkAccelerationStructureCreateFlagsKHR createFlags
VkCoverageModulationModeNV
GLuint color
Definition: glcorearb.h:1261
struct VkPhysicalDeviceProvokingVertexPropertiesEXT VkPhysicalDeviceProvokingVertexPropertiesEXT
struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT VkPipelineRasterizationProvokingVertexStateCreateInfoEXT
VkDeviceSize optimalBufferCopyOffsetAlignment
Definition: vulkan_core.h:3135
void(VKAPI_PTR * PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
struct VkDeviceFaultAddressInfoEXT VkDeviceFaultAddressInfoEXT
VkAccelerationStructureInstanceKHR staticInstance
VkFlags VkSparseMemoryBindFlags
Definition: vulkan_core.h:2408
VkResult(VKAPI_PTR * PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
Definition: vulkan_core.h:3953
#define VK_UUID_SIZE
Definition: vulkan_core.h:134
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
struct VkCuLaunchInfoNVX VkCuLaunchInfoNVX
VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
struct VkMemoryBarrier2 VkMemoryBarrier2
void(VKAPI_PTR * PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:6379
VkResult(VKAPI_PTR * PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
uint32_t colorAttachmentCount
Definition: vulkan_core.h:3760
VkDeviceSize missShaderBindingTableStride
Definition: vulkan_core.h:9752
VkStencilOp failOp
Definition: vulkan_core.h:3538
void(VKAPI_PTR * PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
Definition: vulkan_core.h:9564
const uint64_t * pValues
Definition: vulkan_core.h:6333
VkImageLayout
Definition: vulkan_core.h:1250
VkStructureType sType
VkSurfaceFormatKHR surfaceFormat
Definition: vulkan_core.h:8755
VkFlags VkImageCompressionFlagsEXT
VkPipelineCoverageModulationStateCreateFlagsNV flags
uint32_t maxFragmentCombinedOutputResources
Definition: vulkan_core.h:3082
void(VKAPI_PTR * PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
VkLineRasterizationModeEXT lineRasterizationMode
VkBool32 shaderStorageBufferArrayNonUniformIndexingNative
Definition: vulkan_core.h:5941
struct VkDeviceGroupPresentCapabilitiesKHR VkDeviceGroupPresentCapabilitiesKHR
VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR
Definition: vulkan_core.h:8952
void(VKAPI_PTR * PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:9791
VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
VkComponentMapping components
Definition: vulkan_core.h:3399
VkMicromapCreateFlagBitsEXT
VkPipelineStageFlags2 srcStageMask
Definition: vulkan_core.h:6901
void(VKAPI_PTR * PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:7326
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
Definition: vulkan_core.h:5548
VkImageSubresource subresource
Definition: vulkan_core.h:3268
VkStructureType sType
Definition: vulkan_core.h:7076
uint32_t layerCount
Definition: vulkan_core.h:7172
VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR
Definition: vulkan_core.h:8729
VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT
VkDependencyInfo VkDependencyInfoKHR
Definition: vulkan_core.h:9539
VkPerformanceValueDataINTEL data
VkStructureType sType
Definition: vulkan_core.h:6017
VkFlags VkExternalFenceHandleTypeFlags
Definition: vulkan_core.h:4994
struct VkPhysicalDeviceVulkan13Properties VkPhysicalDeviceVulkan13Properties
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
VkDeviceSize(VKAPI_PTR * PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
struct VkPhysicalDeviceImageCompressionControlFeaturesEXT VkPhysicalDeviceImageCompressionControlFeaturesEXT
VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
VkLogicOp
Definition: vulkan_core.h:1992
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
VkSamplerMipmapMode
Definition: vulkan_core.h:2042
VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
const VkShadingRatePaletteEntryNV * pShadingRatePaletteEntries
VkExternalFenceFeatureFlags externalFenceFeatures
Definition: vulkan_core.h:5482
VkDeviceSize size
Definition: vulkan_core.h:3379
VkDisplaySurfaceCreateFlagsKHR flags
Definition: vulkan_core.h:7848
void(VKAPI_PTR * PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
VkImageSubresourceLayers dstSubresource
Definition: vulkan_core.h:7080
struct VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeatures
VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR
Definition: vulkan_core.h:9313
const char *const * ppEnabledExtensionNames
Definition: vulkan_core.h:2960
VkFlags VkDeviceQueueCreateFlags
Definition: vulkan_core.h:2363
uint32_t viewMask
Definition: vulkan_core.h:7173
uint32_t constantID
Definition: vulkan_core.h:3420
VkAccelerationStructureTypeKHR
VkMemoryPropertyFlags propertyFlags
Definition: vulkan_core.h:2969
void(VKAPI_PTR * PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
Definition: vulkan_core.h:9993
const VkBufferImageCopy2 * pRegions
Definition: vulkan_core.h:7051
uint64_t VkFlags64
Definition: vulkan_core.h:6466
const VkCommandBufferInheritanceInfo * pInheritanceInfo
Definition: vulkan_core.h:3820
VkPipelineStageFlagBits
Definition: vulkan_core.h:2365
VkCommandPoolCreateFlags flags
Definition: vulkan_core.h:3793
const uint32_t * pPreserveAttachments
Definition: vulkan_core.h:3765
VkMemoryAllocateFlags flags
Definition: vulkan_core.h:5095
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
VkStructureType sType
Definition: vulkan_core.h:6994
void(VKAPI_PTR * PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory)
Definition: vulkan_core.h:3930
VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubgroupSizeControlFeaturesEXT
const VkVertexInputBindingDivisorDescriptionEXT * pVertexBindingDivisors
struct VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2
VkFlags VkPeerMemoryFeatureFlags
Definition: vulkan_core.h:4932
struct VkInitializePerformanceApiInfoINTEL VkInitializePerformanceApiInfoINTEL
struct VkCuModuleCreateInfoNVX VkCuModuleCreateInfoNVX
void(VKAPI_PTR * PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
struct VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchronization2Features
VkDebugReportObjectTypeEXT objectType
Definition: vulkan_core.h:9975
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
uint32_t waitSemaphoreCount
Definition: vulkan_core.h:3285
const void * pNext
Definition: vulkan_core.h:7087
VkResult(VKAPI_PTR * PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:3997
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
uint32_t maxVertexOutputComponents
Definition: vulkan_core.h:3065
void(VKAPI_PTR * PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
const VkValidationFeatureDisableEXT * pDisabledValidationFeatures
VkStructureType sType
Definition: vulkan_core.h:5486
const void * pNext
Definition: vulkan_core.h:6051
const void * pNext
Definition: vulkan_core.h:7004
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
Definition: vulkan_core.h:9247
struct VkPhysicalDeviceFeatures VkPhysicalDeviceFeatures
struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI VkPhysicalDeviceSubpassShadingPropertiesHUAWEI
struct VkFilterCubicImageViewImageFormatPropertiesEXT VkFilterCubicImageViewImageFormatPropertiesEXT
VkSamplerCreateFlagBits
Definition: vulkan_core.h:2662
VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion
uint32_t arrayLayers
Definition: vulkan_core.h:3367
struct VkPhysicalDeviceTransformFeedbackFeaturesEXT VkPhysicalDeviceTransformFeedbackFeaturesEXT
VkResult(VKAPI_PTR * PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
Definition: vulkan_core.h:3965
void(VKAPI_PTR * PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:7988
GLuint index
Definition: glcorearb.h:786
VkBuildAccelerationStructureFlagBitsKHR
VkSubpassMergeStatusEXT subpassMergeStatus
VkDeviceMemory memory
Definition: vulkan_core.h:3271
struct VkSamplerCustomBorderColorCreateInfoEXT VkSamplerCustomBorderColorCreateInfoEXT
VkShaderFloatControlsIndependence denormBehaviorIndependence
Definition: vulkan_core.h:5921
VkPipelineStageFlags srcStageMask
Definition: vulkan_core.h:3771
VkCopyBufferInfo2 VkCopyBufferInfo2KHR
Definition: vulkan_core.h:9670
int32_t y
Definition: vulkan_core.h:2796
VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT
VkPipelineDepthStencilStateCreateFlags flags
Definition: vulkan_core.h:3550
VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes
Definition: vulkan_core.h:5413
const VkPipelineShaderStageCreateInfo * pStages
Definition: vulkan_core.h:3597
void(VKAPI_PTR * PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
Definition: vulkan_core.h:3985
union VkClearValue VkClearValue
struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV
VkResult(VKAPI_PTR * PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
struct VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfo
VkSemaphoreImportFlags flags
Definition: vulkan_core.h:8297
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities)
Definition: vulkan_core.h:8821
VkBufferUsageFlagBits
Definition: vulkan_core.h:2476
struct VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceKHR
#define VK_MAX_MEMORY_HEAPS
Definition: vulkan_core.h:137
VkAttachmentStoreOp storeOp
Definition: vulkan_core.h:7163
VkBool32 vertexPipelineStoresAndAtomics
Definition: vulkan_core.h:2999
VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes
void(VKAPI_PTR * PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:8933
struct VkDisplayEventInfoEXT VkDisplayEventInfoEXT
void(VKAPI_PTR * PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
Definition: vulkan_core.h:4031
const VkDescriptorPoolSize * pPoolSizes
Definition: vulkan_core.h:3686
struct VkTraceRaysIndirectCommand2KHR VkTraceRaysIndirectCommand2KHR
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
VkMemoryBarrier2 VkMemoryBarrier2KHR
Definition: vulkan_core.h:9533
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
Definition: vulkan_core.h:3908
void(VKAPI_PTR * PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
struct VkBufferMemoryBarrier2 VkBufferMemoryBarrier2
VkDrmFormatModifierPropertiesEXT * pDrmFormatModifierProperties
VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
VkPipelineShaderStageCreateFlagBits
Definition: vulkan_core.h:2585
struct VkAcquireProfilingLockInfoKHR VkAcquireProfilingLockInfoKHR
VkBlendFactor srcColorBlendFactor
void(VKAPI_PTR * PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
const VkFormat * pColorAttachmentFormats
Definition: vulkan_core.h:7185
VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
VkResult(VKAPI_PTR * PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
struct VkDrawMeshTasksIndirectCommandEXT VkDrawMeshTasksIndirectCommandEXT
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
Definition: vulkan_core.h:7304
VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR
Definition: vulkan_core.h:9139
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
VkDeviceCreateFlags flags
Definition: vulkan_core.h:3186
VkPipelineViewportSwizzleStateCreateFlagsNV flags
struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT
VkStructureType sType
void(VKAPI_PTR * PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
VkMicromapEXT dstMicromap
VkImageSubresourceLayers srcSubresource
Definition: vulkan_core.h:3881
VkMemoryHeapFlagBits
Definition: vulkan_core.h:2319
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
Definition: vulkan_core.h:8192
struct VkPhysicalDeviceDrmPropertiesEXT VkPhysicalDeviceDrmPropertiesEXT
VkAttachmentReference2 VkAttachmentReference2KHR
Definition: vulkan_core.h:8450
VkImageAspectFlags aspectMask
Definition: vulkan_core.h:3298
VkInternalAllocationType
Definition: vulkan_core.h:1381
VkSubpassBeginInfo VkSubpassBeginInfoKHR
Definition: vulkan_core.h:8456
struct VkSurfaceCapabilitiesPresentBarrierNV VkSurfaceCapabilitiesPresentBarrierNV
struct VkPhysicalDeviceShadingRateImagePropertiesNV VkPhysicalDeviceShadingRateImagePropertiesNV
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
Definition: vulkan_core.h:3910
VkPipelineShaderStageCreateFlags flags
Definition: vulkan_core.h:3435
VkStructureType sType
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR
Definition: vulkan_core.h:8731
VkSwapchainKHR swapchain
Definition: vulkan_core.h:7695
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
VkCopyBufferToImageInfo2 VkCopyBufferToImageInfo2KHR
Definition: vulkan_core.h:9674
struct VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfo
VkQueryControlFlagBits
Definition: vulkan_core.h:2763
VkDiscardRectangleModeEXT
VkStructureType sType
Definition: vulkan_core.h:3791
VkDisplayPropertiesKHR displayProperties
Definition: vulkan_core.h:8790
void(VKAPI_PTR * PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
uint32_t disabledValidationFeatureCount
VkResult(VKAPI_PTR * PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
struct VkPipelineMultisampleStateCreateInfo VkPipelineMultisampleStateCreateInfo
VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR
Definition: vulkan_core.h:8184
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
Definition: vulkan_core.h:4022
void(VKAPI_PTR * PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
Definition: vulkan_core.h:3923
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
const VkMemoryBarrier2 * pMemoryBarriers
Definition: vulkan_core.h:6932
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
const uint32_t * pWaitSemaphoreDeviceIndices
Definition: vulkan_core.h:5117
VkAccessFlags2 dstAccessMask
Definition: vulkan_core.h:6904
VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
struct VkDescriptorBufferInfo VkDescriptorBufferInfo
struct VkCopyBufferInfo2 VkCopyBufferInfo2
struct VkImageFormatListCreateInfo VkImageFormatListCreateInfo
struct VkPhysicalDeviceMeshShaderFeaturesNV VkPhysicalDeviceMeshShaderFeaturesNV
VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings)
VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR
Definition: vulkan_core.h:9147
struct VkQueryPoolCreateInfo VkQueryPoolCreateInfo
struct VkDebugReportCallbackCreateInfoEXT VkDebugReportCallbackCreateInfoEXT
VkSubpassDescriptionFlags flags
Definition: vulkan_core.h:3756
const VkDebugUtilsLabelEXT * pCmdBufLabels
VkShaderStageFlags shaderStageMask
VkRenderingFlagBits
Definition: vulkan_core.h:6667
VkDeviceFaultVendorInfoEXT * pVendorInfos
struct VkDecompressMemoryRegionNV VkDecompressMemoryRegionNV
void(VKAPI_PTR * PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
Definition: vulkan_core.h:7311
VkAccelerationStructureInfoNV info
struct VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:7299
const VkSparseImageMemoryBindInfo * pImageBinds
Definition: vulkan_core.h:3292
VkFlags64 VkFormatFeatureFlagBits2
Definition: vulkan_core.h:6681
void(VKAPI_PTR * PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
Definition: vulkan_core.h:7318
const void * pNext
Definition: vulkan_core.h:5334
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode)
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
Definition: vulkan_core.h:3934
VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages
struct VkImageBlit VkImageBlit
VkResult(VKAPI_PTR * PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
Definition: vulkan_core.h:7727
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR
Definition: vulkan_core.h:9137
const VkValidationFeatureEnableEXT * pEnabledValidationFeatures
VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR
Definition: vulkan_core.h:8265
VkPrivateDataSlotCreateFlags flags
Definition: vulkan_core.h:6880
struct VkSurfaceCapabilities2EXT VkSurfaceCapabilities2EXT
struct VkPhysicalDeviceIDProperties VkPhysicalDeviceIDProperties
void(VKAPI_PTR * PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR
Definition: vulkan_core.h:8404
VkFlags VkCommandPoolResetFlags
Definition: vulkan_core.h:2753
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
VkBool32 shaderUniformBufferArrayNonUniformIndexing
Definition: vulkan_core.h:5871
struct VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatProperties
struct VkImageViewCaptureDescriptorDataInfoEXT VkImageViewCaptureDescriptorDataInfoEXT
VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR
Definition: vulkan_core.h:8176
const VkValidationCheckEXT * pDisabledValidationChecks
VkOffset3D srcOffset
Definition: vulkan_core.h:7079
struct VkPhysicalDeviceVulkan12Features VkPhysicalDeviceVulkan12Features
int32_t z
Definition: vulkan_core.h:2802
VkFlags VkImageCreateFlags
Definition: vulkan_core.h:2261
VkXYColorEXT displayPrimaryBlue
struct VkAcquireNextImageInfoKHR VkAcquireNextImageInfoKHR
VkFlags VkPipelineCreateFlags
Definition: vulkan_core.h:2583
struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT VkPhysicalDeviceExternalMemoryHostPropertiesEXT
struct VkCopyMemoryIndirectCommandNV VkCopyMemoryIndirectCommandNV
struct VkPipelineColorWriteCreateInfoEXT VkPipelineColorWriteCreateInfoEXT
VkResult(VKAPI_PTR * PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
Definition: vulkan_core.h:3946
VkBufferMemoryBarrier2 VkBufferMemoryBarrier2KHR
Definition: vulkan_core.h:9535
struct VkExternalMemoryProperties VkExternalMemoryProperties
VkAttachmentLoadOp stencilLoadOp
Definition: vulkan_core.h:3732
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
VkColorSpaceKHR imageColorSpace
Definition: vulkan_core.h:7654
VkPipelineRobustnessBufferBehaviorEXT
uint32_t srcArrayElement
Definition: vulkan_core.h:3656
VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
VkDeviceSize minTexelBufferOffsetAlignment
Definition: vulkan_core.h:3099
VkResult(VKAPI_PTR * PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
Definition: vulkan_core.h:3922
struct VkAccelerationStructureGeometryKHR VkAccelerationStructureGeometryKHR
struct VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfo
VkStructureType sType
Definition: vulkan_core.h:5114
struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT VkDeviceFaultVendorBinaryHeaderVersionOneEXT
void(VKAPI_PTR * PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR
Definition: vulkan_core.h:8437
uint32_t maxTessellationControlTotalOutputComponents
Definition: vulkan_core.h:3071
struct VkImageViewHandleInfoNVX VkImageViewHandleInfoNVX
VkColorSpaceKHR
Definition: vulkan_core.h:7527
const VkSemaphore * pSignalSemaphores
Definition: vulkan_core.h:3217
union VkDescriptorDataEXT VkDescriptorDataEXT
union VkPerformanceValueDataINTEL VkPerformanceValueDataINTEL
struct VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfo
VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
const VkBufferMemoryBarrier2 * pBufferMemoryBarriers
Definition: vulkan_core.h:6934
VkBool32 integerDotProduct16BitMixedSignednessAccelerated
Definition: vulkan_core.h:6801
VkTransformMatrixKHR VkTransformMatrixNV
VkSurfaceTransformFlagsKHR supportedTransforms
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
Definition: vulkan_core.h:3911
struct VkColorBlendEquationEXT VkColorBlendEquationEXT
VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated
Definition: vulkan_core.h:7237
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
Definition: vulkan_core.h:8038
size_t stride
Definition: vulkan_core.h:5395
VkDeviceSize storageTexelBufferOffsetAlignmentBytes
Definition: vulkan_core.h:6823
VkFormat
Definition: vulkan_core.h:1386
VkBindImageMemoryInfo VkBindImageMemoryInfoKHR
Definition: vulkan_core.h:8954
VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
VkAccessFlags dstAccessMask
Definition: vulkan_core.h:3774
VkDeviceSize maxResourceSize
Definition: vulkan_core.h:2949
VkOffset2D offset
Definition: vulkan_core.h:2806
struct VkMicromapVersionInfoEXT VkMicromapVersionInfoEXT
const VkPipelineVertexInputStateCreateInfo * pVertexInputState
Definition: vulkan_core.h:3598
const VkDescriptorUpdateTemplateEntry * pDescriptorUpdateEntries
Definition: vulkan_core.h:5403
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
void(VKAPI_PTR * PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
void(VKAPI_PTR * PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
Definition: vulkan_core.h:4033
VkFlags VkPipelineShaderStageCreateFlags
Definition: vulkan_core.h:2592
VkBool32 shaderStorageImageMultisample
Definition: vulkan_core.h:3004
VkExternalMemoryHandleTypeFlagsNV handleTypes
unsigned int uint32
Definition: SYS_Types.h:40
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
Definition: vulkan_core.h:5545
const VkPipeline * pLibraries
Definition: vulkan_core.h:9490
VkDeviceSize bufferOffset
Definition: vulkan_core.h:7026
struct VkMappedMemoryRange VkMappedMemoryRange
struct VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayout
struct VkPhysicalDeviceProperties VkPhysicalDeviceProperties
VkFenceImportFlagBits VkFenceImportFlagBitsKHR
Definition: vulkan_core.h:8536
VkBool32 shaderSampledImageArrayDynamicIndexing
Definition: vulkan_core.h:3008
VkDeviceMemoryReportEventTypeEXT type
VkDescriptorType descriptorType
Definition: vulkan_core.h:5393
struct VkImageDrmFormatModifierExplicitCreateInfoEXT VkImageDrmFormatModifierExplicitCreateInfoEXT
VkAccelerationStructureKHR srcAccelerationStructure
struct VkDisplayPlaneCapabilities2KHR VkDisplayPlaneCapabilities2KHR
VkStructureType sType
Definition: vulkan_core.h:3652
VkBool32 shaderStorageImageWriteWithoutFormat
Definition: vulkan_core.h:3006
struct VkOffset2D VkOffset2D
void(VKAPI_PTR * PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
VkStructureType sType
Definition: vulkan_core.h:6940
void(VKAPI_PTR * PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3975
GLint GLsizei width
Definition: glcorearb.h:103
VkSubmitFlags flags
Definition: vulkan_core.h:6958
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
const void * pNext
Definition: vulkan_core.h:3185
struct VkDisplayPlaneInfo2KHR VkDisplayPlaneInfo2KHR
VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT VkPhysicalDeviceIndexTypeUint8FeaturesEXT
VkSparseImageMemoryRequirements memoryRequirements
Definition: vulkan_core.h:5189
VkResult(VKAPI_PTR * PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
Definition: vulkan_core.h:3982
VkPipelineStageFlags2 stage
Definition: vulkan_core.h:9558
VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
VkImageSubresourceLayers srcSubresource
Definition: vulkan_core.h:7057
void(VKAPI_PTR * PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:9354
const char *const * ppEnabledLayerNames
Definition: vulkan_core.h:3190
VkDeviceSize size
Definition: vulkan_core.h:3243
uint32_t commandBufferInfoCount
Definition: vulkan_core.h:6961
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
struct VkSurfaceCapabilities2KHR VkSurfaceCapabilities2KHR
VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR
Definition: vulkan_core.h:8852
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
uint32_t maxGeometryOutputComponents
Definition: vulkan_core.h:3076
VkStructureType sType
Definition: vulkan_core.h:3631
VkFlags VkToolPurposeFlags
Definition: vulkan_core.h:6495
VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
uint32_t waitSemaphoreCount
Definition: vulkan_core.h:7671
VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback
void(VKAPI_PTR * PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
struct VkShaderResourceUsageAMD VkShaderResourceUsageAMD
struct VkAccelerationStructureCreateInfoNV VkAccelerationStructureCreateInfoNV
uint32_t maxGeometryTotalOutputComponents
Definition: vulkan_core.h:3078
Definition: core.h:982
struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
const VkSparseMemoryBind * pBinds
Definition: vulkan_core.h:3252
VkExtent3D imageExtent
Definition: vulkan_core.h:3842
VkBool32 shaderUniformBufferArrayNonUniformIndexingNative
Definition: vulkan_core.h:5939
struct VkGraphicsPipelineCreateInfo VkGraphicsPipelineCreateInfo
VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer)
VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
int32_t y
Definition: vulkan_core.h:2801
VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
uint32_t maxDescriptorSetUniformBuffersDynamic
Definition: vulkan_core.h:3055
uint64_t VkDeviceSize
Definition: vulkan_core.h:95
struct VkSwapchainDisplayNativeHdrCreateInfoAMD VkSwapchainDisplayNativeHdrCreateInfoAMD
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
struct VkCommandBufferBeginInfo VkCommandBufferBeginInfo
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
VkGeometryTypeKHR
struct VkCopyImageToBufferInfo2 VkCopyImageToBufferInfo2
VkResult(VKAPI_PTR * PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
Definition: vulkan_core.h:3974
VkBlendFactor srcAlphaBlendFactor
VkDescriptorBindingFlagBits
Definition: vulkan_core.h:5799
struct VkPipelineCoverageToColorStateCreateInfoNV VkPipelineCoverageToColorStateCreateInfoNV
VkBufferViewCreateFlags flags
Definition: vulkan_core.h:3352
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
VkBool32 shaderStorageImageArrayNonUniformIndexingNative
Definition: vulkan_core.h:5942
VkFlags VkDeviceAddressBindingFlagsEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
VkLineRasterizationModeEXT
struct VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeatures
void(VKAPI_PTR * PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
struct VkPerformanceCounterDescriptionKHR VkPerformanceCounterDescriptionKHR
uint32_t subPixelInterpolationOffsetBits
Definition: vulkan_core.h:3108
void(VKAPI_PTR * PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
VkFlags VkSurfaceCounterFlagsEXT
uint32_t bufferMemoryBarrierCount
Definition: vulkan_core.h:6933
struct VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2
struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM
const VkDescriptorType * pDescriptorTypes
VkExternalMemoryFeatureFlagsNV externalMemoryFeatures
VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR
Definition: vulkan_core.h:8005
VkExtent3D extent
Definition: vulkan_core.h:3365
struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT VkPhysicalDeviceConservativeRasterizationPropertiesEXT
void(VKAPI_PTR * PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR
Definition: vulkan_core.h:8083
uint8_t driverUUID[VK_UUID_SIZE]
Definition: vulkan_core.h:5839
VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR
Definition: vulkan_core.h:9731
const char * pApplicationName
Definition: vulkan_core.h:2931
VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures
Definition: vulkan_core.h:5318
const VkSubpassDependency * pDependencies
Definition: vulkan_core.h:3787
VkImageViewType
Definition: vulkan_core.h:1757
const VkClearValue * pClearValues
Definition: vulkan_core.h:3903
VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR
Definition: vulkan_core.h:8877
struct VkPhysicalDeviceVulkan13Features VkPhysicalDeviceVulkan13Features
const void * pNext
Definition: vulkan_core.h:3210
struct VkPipelinePropertiesIdentifierEXT VkPipelinePropertiesIdentifierEXT
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
VkResult(VKAPI_PTR * PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
Definition: vulkan_core.h:8820
struct VkDedicatedAllocationBufferCreateInfoNV VkDedicatedAllocationBufferCreateInfoNV
struct VkPipelineCreationFeedbackCreateInfo VkPipelineCreationFeedbackCreateInfo
struct VkQueueFamilyCheckpointProperties2NV VkQueueFamilyCheckpointProperties2NV
const VkSpecializationInfo * pSpecializationInfo
Definition: vulkan_core.h:3439
VkOpticalFlowSessionCreateFlagsNV flags
VkFlags VkBuildMicromapFlagsEXT
VkStructureType sType
VkDescriptorPoolInlineUniformBlockCreateInfo VkDescriptorPoolInlineUniformBlockCreateInfoEXT
struct VkCheckpointData2NV VkCheckpointData2NV
struct VkRect2D VkRect2D
struct VkSwapchainCounterCreateInfoEXT VkSwapchainCounterCreateInfoEXT
uint32_t maxDescriptorSetSamplers
Definition: vulkan_core.h:3053
VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated
Definition: vulkan_core.h:6815
VkFlags VkSubgroupFeatureFlags
Definition: vulkan_core.h:4919
struct VkDebugUtilsLabelEXT VkDebugUtilsLabelEXT
const void * pData
Definition: vulkan_core.h:3429
VkBufferUsageFlags usage
Definition: vulkan_core.h:3343
const void * pNext
Definition: vulkan_core.h:6329
uint32_t depth
Definition: vulkan_core.h:2791
void(VKAPI_PTR * PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
Definition: vulkan_core.h:4018
VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
VkDeviceOrHostAddressConstKHR triangleArray
struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT VkPhysicalDevicePipelineProtectedAccessFeaturesEXT
VkStructureType sType
Definition: vulkan_core.h:5227
struct VkPhysicalDeviceSubgroupProperties VkPhysicalDeviceSubgroupProperties
struct VkDeviceAddressBindingCallbackDataEXT VkDeviceAddressBindingCallbackDataEXT
void(VKAPI_PTR * PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT
VkExternalMemoryHandleTypeFlagBitsNV
uint32_t VkSampleMask
Definition: vulkan_core.h:97
VkFlags VkDeviceMemoryReportFlagsEXT
struct VkPipelineViewportStateCreateInfo VkPipelineViewportStateCreateInfo
struct VkDisplayModeParametersKHR VkDisplayModeParametersKHR
void(VKAPI_PTR * PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets)
void(VKAPI_PTR * PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3942
struct VkWriteDescriptorSetAccelerationStructureKHR VkWriteDescriptorSetAccelerationStructureKHR
const VkAttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
Definition: vulkan_core.h:7728
VkBufferCreateFlagBits
Definition: vulkan_core.h:2463
char description[VK_MAX_DESCRIPTION_SIZE]
Definition: vulkan_core.h:6855
VkBool32 integerDotProduct4x8BitPackedSignedAccelerated
Definition: vulkan_core.h:6797
char driverName[VK_MAX_DRIVER_NAME_SIZE]
Definition: vulkan_core.h:6066
VkSubpassMergeStatusEXT
VkResult(VKAPI_PTR * PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
Definition: vulkan_core.h:8238
VkImageSubresourceRange subresourceRange
Definition: vulkan_core.h:6924
VkSamplerReductionMode
Definition: vulkan_core.h:5766
struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV VkPhysicalDeviceDiagnosticsConfigFeaturesNV
struct VkDebugMarkerObjectNameInfoEXT VkDebugMarkerObjectNameInfoEXT
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object)
Definition: vulkan_core.h:57
VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
struct VkDebugUtilsObjectTagInfoEXT VkDebugUtilsObjectTagInfoEXT
VkCoarseSampleOrderTypeNV
PFN_vkInternalAllocationNotification pfnInternalAllocation
Definition: vulkan_core.h:2924
VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT
void(VKAPI_PTR * PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
Definition: vulkan_core.h:7295
struct VkPipelineCacheCreateInfo VkPipelineCacheCreateInfo
uint32_t implementationVersion
Definition: vulkan_core.h:3204
VkAttachmentDescriptionFlagBits
Definition: vulkan_core.h:2695
struct VkAccelerationStructureVersionInfoKHR VkAccelerationStructureVersionInfoKHR
char layerName[VK_MAX_EXTENSION_NAME_SIZE]
Definition: vulkan_core.h:3202
struct VkPhysicalDeviceColorWriteEnableFeaturesEXT VkPhysicalDeviceColorWriteEnableFeaturesEXT
VkExtent3D imageExtent
Definition: vulkan_core.h:7031
const void * pNext
Definition: vulkan_core.h:3230
VkAccessFlagBits
Definition: vulkan_core.h:2119
struct VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfo
VkPhysicalDeviceFeatures features
Definition: vulkan_core.h:5195
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
Definition: vulkan_core.h:5546
VkGeometryTypeKHR geometryType
void(VKAPI_PTR * PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3966
struct VkDisplayPowerInfoEXT VkDisplayPowerInfoEXT
VkImageSubresourceLayers imageSubresource
VkSparseImageFormatProperties properties
Definition: vulkan_core.h:5241
VkCopyAccelerationStructureModeKHR mode
VkOffset3D dstOffset
Definition: vulkan_core.h:3884
VkSampleCountFlagBits rasterizationSamples
Definition: vulkan_core.h:7205
VkAccessFlags2 dstAccessMask
Definition: vulkan_core.h:6918
VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
struct VkMicromapBuildSizesInfoEXT VkMicromapBuildSizesInfoEXT
void(VKAPI_PTR * PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
Definition: vulkan_core.h:9893
VkDeviceSize size
Definition: vulkan_core.h:3225
VkAccessFlags dstAccessMask
Definition: vulkan_core.h:2878
VkFlags VkDisplayModeCreateFlagsKHR
Definition: vulkan_core.h:7790
struct VkPhysicalDeviceShaderCorePropertiesAMD VkPhysicalDeviceShaderCorePropertiesAMD
void(VKAPI_PTR * PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
VkDependencyFlags dependencyFlags
Definition: vulkan_core.h:6930
const VkFramebufferAttachmentImageInfo * pAttachmentImageInfos
Definition: vulkan_core.h:6252
struct VkSparseImageFormatProperties2 VkSparseImageFormatProperties2
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes
VkExternalFenceHandleTypeFlagBits
Definition: vulkan_core.h:4983
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
Definition: vulkan_core.h:8690
const VkPresentTimeGOOGLE * pTimes
VkResolveModeFlags supportedStencilResolveModes
Definition: vulkan_core.h:5962
VkBuildAccelerationStructureModeKHR
VkSamplerYcbcrModelConversion
Definition: vulkan_core.h:4870
VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV
VkShadingRatePaletteEntryNV
VkResult(VKAPI_PTR * PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
VkMemoryHeapFlags flags
Definition: vulkan_core.h:2965
struct VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfo
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
void(VKAPI_PTR * PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
VkCullModeFlagBits
Definition: vulkan_core.h:2623
const VkImageView * pAttachments
Definition: vulkan_core.h:6259
VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
struct VkSpecializationMapEntry VkSpecializationMapEntry
const VkDescriptorSetLayout * pSetLayouts
Definition: vulkan_core.h:3625
VkStructureType sType
VkFragmentShadingRateCombinerOpKHR combinerOps[2]
Definition: vulkan_core.h:9207
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
Definition: vulkan_core.h:3980
VkDescriptorType descriptorType
Definition: vulkan_core.h:3720
VkDeviceSize transformOffset
VkFlags VkDescriptorUpdateTemplateCreateFlags
Definition: vulkan_core.h:4945
VkRenderingFlags VkRenderingFlagsKHR
Definition: vulkan_core.h:7941
VkResult(VKAPI_PTR * PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
Definition: vulkan_core.h:3998
struct VkDrmFormatModifierPropertiesEXT VkDrmFormatModifierPropertiesEXT
struct VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupProperties
VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
VkImageLayout oldLayout
Definition: vulkan_core.h:2866
VkShaderInfoTypeAMD
VkOffset3D dstOffsets[2]
Definition: vulkan_core.h:7060
struct VkExtent2D VkExtent2D
const void * pNext
VkFlags64 VkAccessFlagBits2
Definition: vulkan_core.h:6582
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
VkStructureType sType
Definition: vulkan_core.h:2929
VkFlags VkDeviceDiagnosticsConfigFlagsNV
struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM VkSubpassFragmentDensityMapOffsetEndInfoQCOM
struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT VkPhysicalDeviceShaderAtomicFloatFeaturesEXT
VkQueueGlobalPriorityKHR globalPriority
Definition: vulkan_core.h:9070
struct VkCommandBufferAllocateInfo VkCommandBufferAllocateInfo
struct VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfo
VkDescriptorUpdateTemplateCreateFlags flags
Definition: vulkan_core.h:5401
VkRenderingFlags flags
Definition: vulkan_core.h:7170
VkPipelineRasterizationStateCreateFlags flags
Definition: vulkan_core.h:3512
VkImageLayout oldLayout
Definition: vulkan_core.h:6919
struct VkMicromapTriangleEXT VkMicromapTriangleEXT
struct VkMemoryHeap VkMemoryHeap
VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR
Definition: vulkan_core.h:8014
VkRasterizationOrderAMD
Definition: vulkan_core.h:9938
VkImageLayout newLayout
Definition: vulkan_core.h:6920
VkDeviceEventTypeEXT
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceExtensionProperties)(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
Definition: vulkan_core.h:3919
VkSubpassDescriptionFlagBits
Definition: vulkan_core.h:2725
VkPipelineStageFlagBits stage
VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event)
VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
VkResult(VKAPI_PTR * PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:8237
VkFlags VkRenderingFlags
Definition: vulkan_core.h:6677
VkResult(VKAPI_PTR * PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
Definition: vulkan_core.h:6384
VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR
Definition: vulkan_core.h:9173
VkDebugUtilsMessengerCallbackDataFlagsEXT flags
VkFormatFeatureFlags2 linearTilingFeatures
Definition: vulkan_core.h:7261
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
Definition: vulkan_core.h:6378
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName)
struct VkGraphicsShaderGroupCreateInfoNV VkGraphicsShaderGroupCreateInfoNV
struct VkBufferDeviceAddressCreateInfoEXT VkBufferDeviceAddressCreateInfoEXT
VkQueryControlFlags queryFlags
Definition: vulkan_core.h:3812
VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
struct VkCopyImageInfo2 VkCopyImageInfo2
const void * pNext
Definition: vulkan_core.h:7014
VkSubgroupFeatureFlags subgroupSupportedOperations
Definition: vulkan_core.h:5845
VkResult(VKAPI_PTR * PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
Definition: vulkan_core.h:3920
const VkBufferView * pTexelBufferView
Definition: vulkan_core.h:3723
VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
VkBlendFactor dstAlphaBlendFactor
VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind
Definition: vulkan_core.h:5882
VkStructureType sType
Definition: vulkan_core.h:6328
VkPipelineCoverageToColorStateCreateFlagsNV flags
void(VKAPI_PTR * PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
VKAPI_ATTR void VKAPI_CALL vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
uint32_t maxBoundDescriptorSets
Definition: vulkan_core.h:3045
uint32_t(VKAPI_PTR * PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
VkBool32 shaderStorageBufferArrayNonUniformIndexing
Definition: vulkan_core.h:5873
VkResult(VKAPI_PTR * PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
struct VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3Properties
struct VkBufferViewCreateInfo VkBufferViewCreateInfo
struct VkPipelineFragmentShadingRateStateCreateInfoKHR VkPipelineFragmentShadingRateStateCreateInfoKHR
const void * pNext
Definition: vulkan_core.h:6987
VkBool32 unnormalizedCoordinates
Definition: vulkan_core.h:3648
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlineUniformBlockEXT
VkFlags VkDirectDriverLoadingFlagsLUNARG
VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
uint32_t queueFamilyIndexCount
Definition: vulkan_core.h:3372
VkResult(VKAPI_PTR * PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
Definition: vulkan_core.h:3924
VkShaderStageFlags subgroupSupportedStages
Definition: vulkan_core.h:5844
struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT VkPhysicalDeviceFragmentDensityMap2PropertiesEXT
VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT
struct VkPipelineExecutableInfoKHR VkPipelineExecutableInfoKHR
struct VkHeadlessSurfaceCreateInfoEXT VkHeadlessSurfaceCreateInfoEXT
VkResult(VKAPI_PTR * PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
Definition: vulkan_core.h:9567
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VkStructureType sType
Definition: vulkan_core.h:6890
VkExtent2D sampleLocationGridSize
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
struct VkAccelerationStructureGeometryTrianglesDataKHR VkAccelerationStructureGeometryTrianglesDataKHR
void(VKAPI_PTR * PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
struct VkMutableDescriptorTypeCreateInfoEXT VkMutableDescriptorTypeCreateInfoEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
void(VKAPI_PTR * PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3964
uint32_t applicationVersion
Definition: vulkan_core.h:2932
VkPhysicalDeviceLimits limits
Definition: vulkan_core.h:3163
VkPipelineStageFlags dstStageMask
Definition: vulkan_core.h:6022
void(VKAPI_PTR * PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
struct VkRenderPassCreationFeedbackInfoEXT VkRenderPassCreationFeedbackInfoEXT
VkExternalMemoryProperties externalMemoryProperties
Definition: vulkan_core.h:5426
VkDeviceImageMemoryRequirements VkDeviceImageMemoryRequirementsKHR
Definition: vulkan_core.h:9787
VkStructureType sType
Definition: vulkan_core.h:6050
VkSubmitFlagBits
Definition: vulkan_core.h:6660
char driverName[VK_MAX_DRIVER_NAME_SIZE]
Definition: vulkan_core.h:5918
VkImageCreateFlags flags
Definition: vulkan_core.h:3362
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR
Definition: vulkan_core.h:8435
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
PFN_vkReallocationFunction pfnReallocation
Definition: vulkan_core.h:2922
VkFlags VkQueueFlags
Definition: vulkan_core.h:2356
VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
VkRayTracingShaderGroupTypeKHR type
VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
void(VKAPI_PTR * PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3949
VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
struct VkImageCompressionPropertiesEXT VkImageCompressionPropertiesEXT
VkToolPurposeFlagBits
Definition: vulkan_core.h:6480
#define VK_LUID_SIZE
Definition: vulkan_core.h:4851
const uint32_t * pQueueFamilyIndices
Definition: vulkan_core.h:7660
VkSemaphoreSubmitInfo VkSemaphoreSubmitInfoKHR
Definition: vulkan_core.h:9543
VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR
Definition: vulkan_core.h:9035
VkDeviceSize dstOffset
Definition: vulkan_core.h:6989
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
VkSparseImageFormatFlags flags
Definition: vulkan_core.h:3300
VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
VkXYColorEXT displayPrimaryGreen
VkImageType imageType
Definition: vulkan_core.h:3363
VkExternalMemoryProperties VkExternalMemoryPropertiesKHR
Definition: vulkan_core.h:8180
struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
VkResult(VKAPI_PTR * PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
Definition: vulkan_core.h:3963
struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI VkPhysicalDeviceSubpassShadingFeaturesHUAWEI
VkSampleCountFlags sampledImageStencilSampleCounts
Definition: vulkan_core.h:3120
const void * pNext
Definition: vulkan_core.h:3313
VkFlags64 VkMemoryDecompressionMethodFlagBitsNV
VkDeviceSize minUniformBufferOffsetAlignment
Definition: vulkan_core.h:3100
VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
VkExternalMemoryHandleTypeFlagBits handleType
Definition: vulkan_core.h:8220
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
const VkIndirectCommandsStreamNV * pStreams
struct VkSRTDataNV VkSRTDataNV
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
Definition: vulkan_core.h:4021
VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV
VkStencilOp
Definition: vulkan_core.h:1980
struct VkCalibratedTimestampInfoEXT VkCalibratedTimestampInfoEXT
struct VkQueueFamilyCheckpointPropertiesNV VkQueueFamilyCheckpointPropertiesNV
VkImageUsageFlags supportedUsageFlags
VkOpticalFlowSessionCreateFlagBitsNV
const VkIndirectCommandsLayoutTokenNV * pTokens
VkValidationFeatureDisableEXT
VkFlags VkQueryResultFlags
Definition: vulkan_core.h:2461
VkSubresourceLayout subresourceLayout
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
Definition: vulkan_core.h:8758
void(VKAPI_PTR * PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:8463
type
Definition: core.h:1059
const void * pNext
Definition: vulkan_core.h:7077
void(VKAPI_PTR * PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
Definition: vulkan_core.h:4017
const VkMicromapUsageEXT *const * ppUsageCounts
VkFlags VkCommandBufferUsageFlags
Definition: vulkan_core.h:2761
VkRenderPassCreateFlags flags
Definition: vulkan_core.h:3781
struct VkQueueFamilyProperties2 VkQueueFamilyProperties2
VkDeviceSize hitShaderBindingTableSize
Definition: vulkan_core.h:9754
uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers
Definition: vulkan_core.h:5956
VkFormatFeatureFlags linearTilingFeatures
Definition: vulkan_core.h:2939
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfoEXT
const VkDescriptorBindingFlags * pBindingFlags
Definition: vulkan_core.h:6111
VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
VkFlags VkPipelineCreationFeedbackFlags
Definition: vulkan_core.h:6478
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
VkBlendFactor dstColorBlendFactor
struct VkPhysicalDeviceAccelerationStructureFeaturesKHR VkPhysicalDeviceAccelerationStructureFeaturesKHR
struct VkPipelineLibraryCreateInfoKHR VkPipelineLibraryCreateInfoKHR
VkExternalBufferProperties VkExternalBufferPropertiesKHR
Definition: vulkan_core.h:8188
VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
VkStructureType sType
Definition: vulkan_core.h:8546
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
Definition: vulkan_core.h:8333
VkDeviceSize allocationSize
Definition: vulkan_core.h:3231
VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT
VkShaderFloatControlsIndependence roundingModeIndependence
Definition: vulkan_core.h:6089
struct VkPhysicalDeviceMemoryPriorityFeaturesEXT VkPhysicalDeviceMemoryPriorityFeaturesEXT
VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
void(VKAPI_PTR * PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
void(VKAPI_PTR * PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
VkSwapchainCreateFlagsKHR flags
Definition: vulkan_core.h:7650
VkDisplayPlaneAlphaFlagsKHR supportedAlpha
Definition: vulkan_core.h:7819
VkResult(VKAPI_PTR * PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
Definition: vulkan_core.h:9151
struct VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfo
const uint32_t * pQueueFamilyIndices
Definition: vulkan_core.h:3346
uint32_t maxTessellationGenerationLevel
Definition: vulkan_core.h:3066
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
VkDisplayModeKHR mode
Definition: vulkan_core.h:8808
VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR
Definition: vulkan_core.h:8930
VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue)
uint32_t maxPerStageDescriptorUniformBuffers
Definition: vulkan_core.h:3047
uint32_t maxPerStageDescriptorSamplers
Definition: vulkan_core.h:3046
const VkDescriptorAddressInfoEXT * pUniformBuffer
VkResult(VKAPI_PTR * PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
Definition: vulkan_core.h:3986
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
Definition: vulkan_core.h:4011
VkResult(VKAPI_PTR * PFN_vkGetFenceStatus)(VkDevice device, VkFence fence)
Definition: vulkan_core.h:3944
struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
const void * pNext
VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR
Definition: vulkan_core.h:8922
void(VKAPI_PTR * PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
VkOffset3D srcOffset
Definition: vulkan_core.h:3890
VkIndirectCommandsLayoutUsageFlagBitsNV
VkImageAspectFlags aspectMask
Definition: vulkan_core.h:3862
VkFlags VkHeadlessSurfaceCreateFlagsEXT
char description[VK_MAX_DESCRIPTION_SIZE]
Definition: vulkan_core.h:9412
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
uint64_t VkDeviceAddress
Definition: vulkan_core.h:94
VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
uint32_t discreteQueuePriorities
Definition: vulkan_core.h:3128
void(VKAPI_PTR * PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue)
VkFlags VkPipelineRasterizationStateCreateFlags
Definition: vulkan_core.h:2635
VkSubpassContents
Definition: vulkan_core.h:2113
struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR
VkDeviceOrHostAddressKHR dst
struct VkImageViewASTCDecodeModeEXT VkImageViewASTCDecodeModeEXT
VkResult(VKAPI_PTR * PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
Definition: vulkan_core.h:8561
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
VkComponentTypeNV
VkSubgroupFeatureFlags supportedOperations
Definition: vulkan_core.h:5049
VkAccelerationStructureMemoryRequirementsTypeNV type
struct VkExternalImageFormatPropertiesNV VkExternalImageFormatPropertiesNV
VkDeviceSize memoryOffset
Definition: vulkan_core.h:3245
void(VKAPI_PTR * PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Definition: vulkan_core.h:4030
VkPipelineViewportStateCreateFlags flags
Definition: vulkan_core.h:3502
VkFlags VkMemoryPropertyFlags
Definition: vulkan_core.h:2339
uint32_t width
Definition: vulkan_core.h:2789
VkFlags VkExternalMemoryFeatureFlagsNV
VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated
Definition: vulkan_core.h:6817
uint32_t maxGeometryInputComponents
Definition: vulkan_core.h:3075
struct VkDeviceFaultCountsEXT VkDeviceFaultCountsEXT
VkImageSubresourceLayers srcSubresource
Definition: vulkan_core.h:3874
void(VKAPI_PTR * PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:4034
uint32_t bufferRowLength
Definition: vulkan_core.h:3838
struct VkCoarseSampleLocationNV VkCoarseSampleLocationNV
PFN_vkFreeFunction pfnFree
Definition: vulkan_core.h:2923
VkAccelerationStructureGeometryDataKHR geometry
struct VkPipelineCoverageModulationStateCreateInfoNV VkPipelineCoverageModulationStateCreateInfoNV
VkFlags VkPipelineCoverageModulationStateCreateFlagsNV
VkSubpassDescriptionFlags flags
Definition: vulkan_core.h:6003
VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
VkStructureType sType
Definition: vulkan_core.h:3404
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
Definition: vulkan_core.h:6382
VkResult(VKAPI_PTR * PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Definition: vulkan_core.h:5551
VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR
Definition: vulkan_core.h:8089
VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
VkShaderStageFlags supportedStages
Definition: vulkan_core.h:5048
struct VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeatures
const VkDescriptorImageInfo * pImageInfo
Definition: vulkan_core.h:3721
struct VkGeometryTrianglesNV VkGeometryTrianglesNV
VkAccelerationStructureGeometryInstancesDataKHR instances
VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
VkResult(VKAPI_PTR * PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VkRemoteAddressNV *pAddress)
VkSampleCountFlagBits sampleLocationsPerPixel
VkResult(VKAPI_PTR * PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
Definition: vulkan_core.h:3976
struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT
VkPipelineRasterizationStateStreamCreateFlagsEXT flags
uint32_t bufferImageHeight
Definition: vulkan_core.h:7028
struct VkMultiDrawIndexedInfoEXT VkMultiDrawIndexedInfoEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
struct VkPhysicalDeviceShaderCoreProperties2AMD VkPhysicalDeviceShaderCoreProperties2AMD
VkBool32 standardSampleLocations
Definition: vulkan_core.h:3134
struct VkDescriptorAddressInfoEXT VkDescriptorAddressInfoEXT
VkFlags VkAcquireProfilingLockFlagsKHR
Definition: vulkan_core.h:8627
struct VkRenderPassTransformBeginInfoQCOM VkRenderPassTransformBeginInfoQCOM
VkFlags VkIndirectStateFlagsNV
VkFlags VkSubpassDescriptionFlags
Definition: vulkan_core.h:2739
struct VkTransformMatrixKHR VkTransformMatrixKHR
VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
struct VkRayTracingPipelineInterfaceCreateInfoKHR VkRayTracingPipelineInterfaceCreateInfoKHR
VkDisplayEventTypeEXT displayEvent
struct VkTextureLODGatherFormatPropertiesAMD VkTextureLODGatherFormatPropertiesAMD
VkStructureType sType
struct VkPipelineRasterizationStateCreateInfo VkPipelineRasterizationStateCreateInfo
VkCommandBufferLevel
Definition: vulkan_core.h:2098
VkAccelerationStructureKHR dstAccelerationStructure
void(VKAPI_PTR * PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
Definition: vulkan_core.h:4005
VkPipelineBindPoint pipelineBindPoint
Definition: vulkan_core.h:5406
VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VkDeviceDiagnosticsConfigFlagsNV flags
struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeatures
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
Definition: vulkan_core.h:8818
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
Definition: vulkan_core.h:8981
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
GLuint64 GLenum GLint fd
Definition: RE_OGL.h:262
void(VKAPI_PTR * PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:7309
VkViewportCoordinateSwizzleNV x
VkBorderColor borderColor
Definition: vulkan_core.h:3647
VkAabbPositionsKHR VkAabbPositionsNV
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR
Definition: vulkan_core.h:8210
struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV VkPhysicalDeviceShaderSMBuiltinsPropertiesNV
struct VkPhysicalDeviceToolProperties VkPhysicalDeviceToolProperties
VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance
VkTessellationDomainOrigin VkTessellationDomainOriginKHR
Definition: vulkan_core.h:8723
struct VkMemoryDedicatedRequirements VkMemoryDedicatedRequirements
VkResult(VKAPI_PTR * PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
Definition: vulkan_core.h:5547
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkMicromapTypeEXT type
VkImageLayout layout
Definition: vulkan_core.h:5996
VkDeviceOrHostAddressConstKHR vertexData
VkStructureType sType
Definition: vulkan_core.h:5062
VkOffset3D dstOffset
Definition: vulkan_core.h:7008
VkDeviceSize depthPitch
Definition: vulkan_core.h:3382
const void * pNext
Definition: vulkan_core.h:2876
VkPhysicalDeviceToolProperties VkPhysicalDeviceToolPropertiesEXT
VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkQueryPoolCreateFlags flags
Definition: vulkan_core.h:3332
struct VkImageDrmFormatModifierPropertiesEXT VkImageDrmFormatModifierPropertiesEXT
uint32_t height
Definition: vulkan_core.h:2785
VkFlags VkDeviceCreateFlags
Definition: vulkan_core.h:2357
const void * pNext
Definition: vulkan_core.h:3653
VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
void(VKAPI_PTR * PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
VkStructureType sType
Definition: vulkan_core.h:3350
VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT
struct VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolveProperties
struct VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeatures
struct VkInstanceCreateInfo VkInstanceCreateInfo
struct VkPhysicalDeviceMeshShaderPropertiesEXT VkPhysicalDeviceMeshShaderPropertiesEXT
VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes
Definition: vulkan_core.h:5506
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
Definition: vulkan_core.h:7730
VkExternalMemoryFeatureFlagBits
Definition: vulkan_core.h:4972
VkFlags VkExternalMemoryFeatureFlags
Definition: vulkan_core.h:4981
VkFlags VkResolveModeFlags
Definition: vulkan_core.h:5797
uint32_t compareMask
Definition: vulkan_core.h:3542
VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV VkPhysicalDeviceLinearColorAttachmentFeaturesNV
VkExternalSemaphoreHandleTypeFlags handleTypes
Definition: vulkan_core.h:5494
struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR
VkFlags VkAccelerationStructureCreateFlagsKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
Definition: format.h:895
VkStructureType sType
Definition: vulkan_core.h:7259
struct VkHdrMetadataEXT VkHdrMetadataEXT
VkAccessFlags2 srcAccessMask
Definition: vulkan_core.h:6902
struct VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4Properties
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR
Definition: vulkan_core.h:8085
VkResult(VKAPI_PTR * PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
Definition: vulkan_core.h:3960
struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM VkCommandBufferInheritanceRenderPassTransformInfoQCOM
VkSamplerReductionMode VkSamplerReductionModeEXT
struct VkPipelineViewportWScalingStateCreateInfoNV VkPipelineViewportWScalingStateCreateInfoNV
VkStructureType sType
Definition: vulkan_core.h:2821
struct VkViewportSwizzleNV VkViewportSwizzleNV
void(VKAPI_PTR * PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3977
struct VkPhysicalDeviceAmigoProfilingFeaturesSEC VkPhysicalDeviceAmigoProfilingFeaturesSEC
VkFlags64 VkPipelineStageFlags2
Definition: vulkan_core.h:6497
struct VkCopyMemoryToImageIndirectCommandNV VkCopyMemoryToImageIndirectCommandNV
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
Definition: vulkan_core.h:5544
struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM
VkSampleCountFlags framebufferIntegerColorSampleCounts
Definition: vulkan_core.h:5968
const VkVertexInputBindingDescription * pVertexBindingDescriptions
Definition: vulkan_core.h:3470
uint32_t maxStorageBufferRange
Definition: vulkan_core.h:3039
struct VkSparseImageMemoryBindInfo VkSparseImageMemoryBindInfo
struct VkPhysicalDeviceMultiDrawFeaturesEXT VkPhysicalDeviceMultiDrawFeaturesEXT
void(VKAPI_PTR * PFN_vkInternalFreeNotification)(void *pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope)
Definition: vulkan_core.h:2905
PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr
struct VkPhysicalDeviceMemoryBudgetPropertiesEXT VkPhysicalDeviceMemoryBudgetPropertiesEXT
struct VkPhysicalDeviceImageViewImageFormatInfoEXT VkPhysicalDeviceImageViewImageFormatInfoEXT
VkBool32 vulkanMemoryModelAvailabilityVisibilityChains
Definition: vulkan_core.h:5901
void(VKAPI_PTR * PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR
Definition: vulkan_core.h:9097
const VkRect2D * pRegions
struct VkPhysicalDevicePipelineRobustnessFeaturesEXT VkPhysicalDevicePipelineRobustnessFeaturesEXT
uint32_t colorAttachmentCount
Definition: vulkan_core.h:7174
VkDeviceGroupPresentModeFlagBitsKHR
Definition: vulkan_core.h:7639
uint32_t srcQueueFamilyIndex
Definition: vulkan_core.h:2825
uint64_t(VKAPI_PTR * PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
Definition: vulkan_core.h:6387
VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(VKAPI_PTR * PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
struct VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfo
VkPipelineBindPoint pipelineBindPoint
VkConformanceVersion VkConformanceVersionKHR
Definition: vulkan_core.h:9095
VkDeviceQueueGlobalPriorityCreateInfoKHR VkDeviceQueueGlobalPriorityCreateInfoEXT
VkPipelineCreateFlags flags
struct VkPhysicalDeviceCornerSampledImageFeaturesNV VkPhysicalDeviceCornerSampledImageFeaturesNV
VkDescriptorPoolCreateFlags flags
Definition: vulkan_core.h:3683
VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT
VkSubpassDescription2 VkSubpassDescription2KHR
Definition: vulkan_core.h:8452
VkSurfaceTransformFlagBitsKHR transform
VkHeadlessSurfaceCreateFlagsEXT flags
struct VkExternalMemoryImageCreateInfoNV VkExternalMemoryImageCreateInfoNV
VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR
Definition: vulkan_core.h:8850
VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
Definition: vulkan_core.h:7863
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
VkPointClippingBehavior
Definition: vulkan_core.h:4854
VkFlags VkOpticalFlowExecuteFlagsNV
VkBool32 shaderStorageBufferArrayDynamicIndexing
Definition: vulkan_core.h:3009
VkFlags VkFenceCreateFlags
Definition: vulkan_core.h:2422
VkDescriptorSet dstSet
Definition: vulkan_core.h:3716
VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR
Definition: vulkan_core.h:8093
VkAcquireProfilingLockFlagsKHR flags
Definition: vulkan_core.h:8679
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
void(VKAPI_PTR * PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
const VkPipelineTessellationStateCreateInfo * pTessellationState
Definition: vulkan_core.h:3600
void(VKAPI_PTR * PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
VkFlags VkShaderStageFlags
Definition: vulkan_core.h:2660
union VkAccelerationStructureMotionInstanceDataNV VkAccelerationStructureMotionInstanceDataNV
VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
uint32_t dstArrayElement
Definition: vulkan_core.h:3659
void(VKAPI_PTR * PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
Definition: vulkan_core.h:7320
VkExternalMemoryHandleTypeFlagBits handleType
Definition: vulkan_core.h:8234
struct VkSubpassSampleLocationsEXT VkSubpassSampleLocationsEXT
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
VkStructureType sType
Definition: vulkan_core.h:7024
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
const char *const * ppEnabledLayerNames
Definition: vulkan_core.h:2958
struct VkBaseOutStructure * pNext
Definition: vulkan_core.h:2817
VkIndexType
Definition: vulkan_core.h:2104
VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
struct VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfo
void(VKAPI_PTR * PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:8407
VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
VkPeerMemoryFeatureFlagBits
Definition: vulkan_core.h:4921
struct VkConditionalRenderingBeginInfoEXT VkConditionalRenderingBeginInfoEXT
VkShaderResourceUsageAMD resourceUsage
struct VkPhysicalDevicePipelinePropertiesFeaturesEXT VkPhysicalDevicePipelinePropertiesFeaturesEXT
VkDeviceFaultAddressInfoEXT * pAddressInfos
struct VkRenderingInfo VkRenderingInfo
VkDependencyFlagBits
Definition: vulkan_core.h:2701
VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
#define VK_MAX_MEMORY_TYPES
Definition: vulkan_core.h:132
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkResult(VKAPI_PTR * PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
Definition: vulkan_core.h:9990
struct VkBufferMemoryBarrier VkBufferMemoryBarrier
void(VKAPI_PTR * PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
Definition: vulkan_core.h:4037
const VkPipelineDepthStencilStateCreateInfo * pDepthStencilState
Definition: vulkan_core.h:3604
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
void(VKAPI_PTR * PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
Definition: vulkan_core.h:7314
VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR
Definition: vulkan_core.h:9145
struct VkWriteDescriptorSet VkWriteDescriptorSet
const VkRenderingAttachmentInfo * pStencilAttachment
Definition: vulkan_core.h:7177
VkPerformanceParameterTypeINTEL
struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT
uint32_t maxTessellationControlPerVertexInputComponents
Definition: vulkan_core.h:3068
VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
struct VkPipelineInfoKHR VkPipelineInfoKHR
VkSurfaceTransformFlagBitsKHR
Definition: vulkan_core.h:7549
VkQueueFlagBits
Definition: vulkan_core.h:2341
VkImageFormatProperties imageFormatProperties
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glcorearb.h:1297
GLenum src
Definition: glcorearb.h:1793
VkOpticalFlowExecuteFlagBitsNV
struct VkPhysicalDeviceOpacityMicromapPropertiesEXT VkPhysicalDeviceOpacityMicromapPropertiesEXT
struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
struct VkPhysicalDeviceFragmentShadingRateKHR VkPhysicalDeviceFragmentShadingRateKHR
struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT
VkCommandBufferInheritanceRenderingInfo VkCommandBufferInheritanceRenderingInfoKHR
Definition: vulkan_core.h:7953
VkBool32 shaderStorageImageArrayNonUniformIndexing
Definition: vulkan_core.h:5874
struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT VkPhysicalDeviceFragmentDensityMap2FeaturesEXT
VkResult(VKAPI_PTR * PFN_vkGetEventStatus)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3950
VkResult(VKAPI_PTR * PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
Definition: vulkan_core.h:9989
struct VkPhysicalDeviceInlineUniformBlockProperties VkPhysicalDeviceInlineUniformBlockProperties
struct VkPhysicalDeviceRayTracingPropertiesNV VkPhysicalDeviceRayTracingPropertiesNV
void(VKAPI_PTR * PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
uint8_t uuid[VK_UUID_SIZE]
Definition: vulkan_core.h:8647
struct VkSurfaceFormatKHR VkSurfaceFormatKHR
VkPipelineStageFlags2 VkPipelineStageFlags2KHR
Definition: vulkan_core.h:9521
VkDebugUtilsMessageTypeFlagsEXT messageType
struct VkExternalFenceProperties VkExternalFenceProperties
struct VkPipelineLayoutCreateInfo VkPipelineLayoutCreateInfo
struct VkDebugMarkerMarkerInfoEXT VkDebugMarkerMarkerInfoEXT
char description[VK_MAX_DESCRIPTION_SIZE]
Definition: vulkan_core.h:8656
struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures VkPhysicalDeviceTextureCompressionASTCHDRFeatures
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
Definition: vulkan_core.h:8158
struct VkPipelineColorBlendAttachmentState VkPipelineColorBlendAttachmentState
struct VkResolveImageInfo2 VkResolveImageInfo2
VkQueueFamilyProperties queueFamilyProperties
Definition: vulkan_core.h:5229
struct VkSetStateFlagsIndirectCommandNV VkSetStateFlagsIndirectCommandNV
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
struct VkPhysicalDevicePerformanceQueryPropertiesKHR VkPhysicalDevicePerformanceQueryPropertiesKHR
VkDescriptorPool descriptorPool
Definition: vulkan_core.h:3692
VkFlags VkDescriptorBindingFlags
Definition: vulkan_core.h:5810
VkToolPurposeFlags VkToolPurposeFlagsEXT