vulkan.h

00001 // TAGRELEASE: CUSTOM
00002 #ifndef VULKAN_H_
00003 #define VULKAN_H_ 1
00004 
00005 #ifdef __cplusplus
00006 extern "C" {
00007 #endif
00008 
00009         /*
00010         ** Copyright (c) 2015-2017 The Khronos Group Inc.
00011         **
00012         ** Licensed under the Apache License, Version 2.0 (the "License");
00013         ** you may not use this file except in compliance with the License.
00014         ** You may obtain a copy of the License at
00015         **
00016         **     http://www.apache.org/licenses/LICENSE-2.0
00017         **
00018         ** Unless required by applicable law or agreed to in writing, software
00019         ** distributed under the License is distributed on an "AS IS" BASIS,
00020         ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00021         ** See the License for the specific language governing permissions and
00022         ** limitations under the License.
00023         */
00024 
00025         /*
00026         ** This header is generated from the Khronos Vulkan XML API Registry.
00027         **
00028         */
00029 
00030 
00031 #define VK_VERSION_1_0 1
00032 #include "vk_platform.h"
00033 
00034 #define VK_MAKE_VERSION(major, minor, patch) \
00035     (((major) << 22) | ((minor) << 12) | (patch))
00036 
00037         // 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.
00038         //#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0)
00039 
00040         // Vulkan 1.0 version number
00041 #define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)
00042 
00043 #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
00044 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
00045 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
00046         // Version of this file
00047 #define VK_HEADER_VERSION 39
00048 
00049 
00050 #define VK_NULL_HANDLE 0
00051 
00052 
00053 
00054 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
00055 
00056 
00057 #if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
00058 #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
00059 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
00060 #else
00061 #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
00062 #endif
00063 #endif
00064 
00065 
00066 
00067         typedef uint32_t VkFlags;
00068         typedef uint32_t VkBool32;
00069         typedef uint64_t VkDeviceSize;
00070         typedef uint32_t VkSampleMask;
00071 
00072         VK_DEFINE_HANDLE(VkInstance)
00073                 VK_DEFINE_HANDLE(VkPhysicalDevice)
00074                 VK_DEFINE_HANDLE(VkDevice)
00075                 VK_DEFINE_HANDLE(VkQueue)
00076                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
00077                 VK_DEFINE_HANDLE(VkCommandBuffer)
00078                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
00079                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
00080                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
00081                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
00082                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
00083                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
00084                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
00085                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
00086                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
00087                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
00088                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
00089                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
00090                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
00091                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
00092                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
00093                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
00094                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
00095                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
00096                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
00097 
00098 #define VK_LOD_CLAMP_NONE                 1000.0f
00099 #define VK_REMAINING_MIP_LEVELS           (~0U)
00100 #define VK_REMAINING_ARRAY_LAYERS         (~0U)
00101 #define VK_WHOLE_SIZE                     (~0ULL)
00102 #define VK_ATTACHMENT_UNUSED              (~0U)
00103 #define VK_TRUE                           1
00104 #define VK_FALSE                          0
00105 #define VK_QUEUE_FAMILY_IGNORED           (~0U)
00106 #define VK_SUBPASS_EXTERNAL               (~0U)
00107 #define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256
00108 #define VK_UUID_SIZE                      16
00109 #define VK_MAX_MEMORY_TYPES               32
00110 #define VK_MAX_MEMORY_HEAPS               16
00111 #define VK_MAX_EXTENSION_NAME_SIZE        256
00112 #define VK_MAX_DESCRIPTION_SIZE           256
00113 
00114 
00115                 typedef enum VkPipelineCacheHeaderVersion {
00116                 VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
00117                 VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
00118                 VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
00119                 VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
00120                 VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
00121         } VkPipelineCacheHeaderVersion;
00122 
00123         typedef enum VkResult {
00124                 VK_SUCCESS = 0,
00125                 VK_NOT_READY = 1,
00126                 VK_TIMEOUT = 2,
00127                 VK_EVENT_SET = 3,
00128                 VK_EVENT_RESET = 4,
00129                 VK_INCOMPLETE = 5,
00130                 VK_ERROR_OUT_OF_HOST_MEMORY = -1,
00131                 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
00132                 VK_ERROR_INITIALIZATION_FAILED = -3,
00133                 VK_ERROR_DEVICE_LOST = -4,
00134                 VK_ERROR_MEMORY_MAP_FAILED = -5,
00135                 VK_ERROR_LAYER_NOT_PRESENT = -6,
00136                 VK_ERROR_EXTENSION_NOT_PRESENT = -7,
00137                 VK_ERROR_FEATURE_NOT_PRESENT = -8,
00138                 VK_ERROR_INCOMPATIBLE_DRIVER = -9,
00139                 VK_ERROR_TOO_MANY_OBJECTS = -10,
00140                 VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
00141                 VK_ERROR_FRAGMENTED_POOL = -12,
00142                 VK_ERROR_SURFACE_LOST_KHR = -1000000000,
00143                 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
00144                 VK_SUBOPTIMAL_KHR = 1000001003,
00145                 VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
00146                 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
00147                 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
00148                 VK_ERROR_INVALID_SHADER_NV = -1000012000,
00149                 VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000,
00150                 VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
00151                 VK_RESULT_END_RANGE = VK_INCOMPLETE,
00152                 VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
00153                 VK_RESULT_MAX_ENUM = 0x7FFFFFFF
00154         } VkResult;
00155 
00156         typedef enum VkStructureType {
00157                 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
00158                 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
00159                 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
00160                 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
00161                 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
00162                 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
00163                 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
00164                 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
00165                 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
00166                 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
00167                 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
00168                 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
00169                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
00170                 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
00171                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
00172                 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
00173                 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
00174                 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
00175                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
00176                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
00177                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
00178                 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
00179                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
00180                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
00181                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
00182                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
00183                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
00184                 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
00185                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
00186                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
00187                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
00188                 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
00189                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
00190                 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
00191                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
00192                 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
00193                 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
00194                 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
00195                 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
00196                 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
00197                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
00198                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
00199                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
00200                 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
00201                 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
00202                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
00203                 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
00204                 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
00205                 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
00206                 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
00207                 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
00208                 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
00209                 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
00210                 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
00211                 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
00212                 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
00213                 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
00214                 VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
00215                 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
00216                 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
00217                 VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
00218                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
00219                 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
00220                 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
00221                 VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
00222                 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
00223                 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
00224                 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
00225                 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
00226                 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
00227                 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
00228                 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
00229                 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
00230                 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000,
00231                 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001,
00232                 VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002,
00233                 VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003,
00234                 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004,
00235                 VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005,
00236                 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006,
00237                 VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007,
00238                 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,
00239                 VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
00240                 VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
00241                 VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
00242                 VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
00243                 VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
00244                 VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
00245                 VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
00246                 VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
00247                 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = 1000090000,
00248                 VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
00249                 VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
00250                 VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
00251                 VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
00252                 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
00253                 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
00254                 VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
00255                 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
00256         } VkStructureType;
00257 
00258         typedef enum VkSystemAllocationScope {
00259                 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
00260                 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
00261                 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
00262                 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
00263                 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
00264                 VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
00265                 VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
00266                 VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
00267                 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
00268         } VkSystemAllocationScope;
00269 
00270         typedef enum VkInternalAllocationType {
00271                 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
00272                 VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
00273                 VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
00274                 VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
00275                 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
00276         } VkInternalAllocationType;
00277 
00278         typedef enum VkFormat {
00279                 VK_FORMAT_UNDEFINED = 0,
00280                 VK_FORMAT_R4G4_UNORM_PACK8 = 1,
00281                 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
00282                 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
00283                 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
00284                 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
00285                 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
00286                 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
00287                 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
00288                 VK_FORMAT_R8_UNORM = 9,
00289                 VK_FORMAT_R8_SNORM = 10,
00290                 VK_FORMAT_R8_USCALED = 11,
00291                 VK_FORMAT_R8_SSCALED = 12,
00292                 VK_FORMAT_R8_UINT = 13,
00293                 VK_FORMAT_R8_SINT = 14,
00294                 VK_FORMAT_R8_SRGB = 15,
00295                 VK_FORMAT_R8G8_UNORM = 16,
00296                 VK_FORMAT_R8G8_SNORM = 17,
00297                 VK_FORMAT_R8G8_USCALED = 18,
00298                 VK_FORMAT_R8G8_SSCALED = 19,
00299                 VK_FORMAT_R8G8_UINT = 20,
00300                 VK_FORMAT_R8G8_SINT = 21,
00301                 VK_FORMAT_R8G8_SRGB = 22,
00302                 VK_FORMAT_R8G8B8_UNORM = 23,
00303                 VK_FORMAT_R8G8B8_SNORM = 24,
00304                 VK_FORMAT_R8G8B8_USCALED = 25,
00305                 VK_FORMAT_R8G8B8_SSCALED = 26,
00306                 VK_FORMAT_R8G8B8_UINT = 27,
00307                 VK_FORMAT_R8G8B8_SINT = 28,
00308                 VK_FORMAT_R8G8B8_SRGB = 29,
00309                 VK_FORMAT_B8G8R8_UNORM = 30,
00310                 VK_FORMAT_B8G8R8_SNORM = 31,
00311                 VK_FORMAT_B8G8R8_USCALED = 32,
00312                 VK_FORMAT_B8G8R8_SSCALED = 33,
00313                 VK_FORMAT_B8G8R8_UINT = 34,
00314                 VK_FORMAT_B8G8R8_SINT = 35,
00315                 VK_FORMAT_B8G8R8_SRGB = 36,
00316                 VK_FORMAT_R8G8B8A8_UNORM = 37,
00317                 VK_FORMAT_R8G8B8A8_SNORM = 38,
00318                 VK_FORMAT_R8G8B8A8_USCALED = 39,
00319                 VK_FORMAT_R8G8B8A8_SSCALED = 40,
00320                 VK_FORMAT_R8G8B8A8_UINT = 41,
00321                 VK_FORMAT_R8G8B8A8_SINT = 42,
00322                 VK_FORMAT_R8G8B8A8_SRGB = 43,
00323                 VK_FORMAT_B8G8R8A8_UNORM = 44,
00324                 VK_FORMAT_B8G8R8A8_SNORM = 45,
00325                 VK_FORMAT_B8G8R8A8_USCALED = 46,
00326                 VK_FORMAT_B8G8R8A8_SSCALED = 47,
00327                 VK_FORMAT_B8G8R8A8_UINT = 48,
00328                 VK_FORMAT_B8G8R8A8_SINT = 49,
00329                 VK_FORMAT_B8G8R8A8_SRGB = 50,
00330                 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
00331                 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
00332                 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
00333                 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
00334                 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
00335                 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
00336                 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
00337                 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
00338                 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
00339                 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
00340                 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
00341                 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
00342                 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
00343                 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
00344                 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
00345                 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
00346                 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
00347                 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
00348                 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
00349                 VK_FORMAT_R16_UNORM = 70,
00350                 VK_FORMAT_R16_SNORM = 71,
00351                 VK_FORMAT_R16_USCALED = 72,
00352                 VK_FORMAT_R16_SSCALED = 73,
00353                 VK_FORMAT_R16_UINT = 74,
00354                 VK_FORMAT_R16_SINT = 75,
00355                 VK_FORMAT_R16_SFLOAT = 76,
00356                 VK_FORMAT_R16G16_UNORM = 77,
00357                 VK_FORMAT_R16G16_SNORM = 78,
00358                 VK_FORMAT_R16G16_USCALED = 79,
00359                 VK_FORMAT_R16G16_SSCALED = 80,
00360                 VK_FORMAT_R16G16_UINT = 81,
00361                 VK_FORMAT_R16G16_SINT = 82,
00362                 VK_FORMAT_R16G16_SFLOAT = 83,
00363                 VK_FORMAT_R16G16B16_UNORM = 84,
00364                 VK_FORMAT_R16G16B16_SNORM = 85,
00365                 VK_FORMAT_R16G16B16_USCALED = 86,
00366                 VK_FORMAT_R16G16B16_SSCALED = 87,
00367                 VK_FORMAT_R16G16B16_UINT = 88,
00368                 VK_FORMAT_R16G16B16_SINT = 89,
00369                 VK_FORMAT_R16G16B16_SFLOAT = 90,
00370                 VK_FORMAT_R16G16B16A16_UNORM = 91,
00371                 VK_FORMAT_R16G16B16A16_SNORM = 92,
00372                 VK_FORMAT_R16G16B16A16_USCALED = 93,
00373                 VK_FORMAT_R16G16B16A16_SSCALED = 94,
00374                 VK_FORMAT_R16G16B16A16_UINT = 95,
00375                 VK_FORMAT_R16G16B16A16_SINT = 96,
00376                 VK_FORMAT_R16G16B16A16_SFLOAT = 97,
00377                 VK_FORMAT_R32_UINT = 98,
00378                 VK_FORMAT_R32_SINT = 99,
00379                 VK_FORMAT_R32_SFLOAT = 100,
00380                 VK_FORMAT_R32G32_UINT = 101,
00381                 VK_FORMAT_R32G32_SINT = 102,
00382                 VK_FORMAT_R32G32_SFLOAT = 103,
00383                 VK_FORMAT_R32G32B32_UINT = 104,
00384                 VK_FORMAT_R32G32B32_SINT = 105,
00385                 VK_FORMAT_R32G32B32_SFLOAT = 106,
00386                 VK_FORMAT_R32G32B32A32_UINT = 107,
00387                 VK_FORMAT_R32G32B32A32_SINT = 108,
00388                 VK_FORMAT_R32G32B32A32_SFLOAT = 109,
00389                 VK_FORMAT_R64_UINT = 110,
00390                 VK_FORMAT_R64_SINT = 111,
00391                 VK_FORMAT_R64_SFLOAT = 112,
00392                 VK_FORMAT_R64G64_UINT = 113,
00393                 VK_FORMAT_R64G64_SINT = 114,
00394                 VK_FORMAT_R64G64_SFLOAT = 115,
00395                 VK_FORMAT_R64G64B64_UINT = 116,
00396                 VK_FORMAT_R64G64B64_SINT = 117,
00397                 VK_FORMAT_R64G64B64_SFLOAT = 118,
00398                 VK_FORMAT_R64G64B64A64_UINT = 119,
00399                 VK_FORMAT_R64G64B64A64_SINT = 120,
00400                 VK_FORMAT_R64G64B64A64_SFLOAT = 121,
00401                 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
00402                 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
00403                 VK_FORMAT_D16_UNORM = 124,
00404                 VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
00405                 VK_FORMAT_D32_SFLOAT = 126,
00406                 VK_FORMAT_S8_UINT = 127,
00407                 VK_FORMAT_D16_UNORM_S8_UINT = 128,
00408                 VK_FORMAT_D24_UNORM_S8_UINT = 129,
00409                 VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
00410                 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
00411                 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
00412                 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
00413                 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
00414                 VK_FORMAT_BC2_UNORM_BLOCK = 135,
00415                 VK_FORMAT_BC2_SRGB_BLOCK = 136,
00416                 VK_FORMAT_BC3_UNORM_BLOCK = 137,
00417                 VK_FORMAT_BC3_SRGB_BLOCK = 138,
00418                 VK_FORMAT_BC4_UNORM_BLOCK = 139,
00419                 VK_FORMAT_BC4_SNORM_BLOCK = 140,
00420                 VK_FORMAT_BC5_UNORM_BLOCK = 141,
00421                 VK_FORMAT_BC5_SNORM_BLOCK = 142,
00422                 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
00423                 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
00424                 VK_FORMAT_BC7_UNORM_BLOCK = 145,
00425                 VK_FORMAT_BC7_SRGB_BLOCK = 146,
00426                 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
00427                 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
00428                 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
00429                 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
00430                 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
00431                 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
00432                 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
00433                 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
00434                 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
00435                 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
00436                 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
00437                 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
00438                 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
00439                 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
00440                 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
00441                 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
00442                 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
00443                 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
00444                 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
00445                 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
00446                 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
00447                 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
00448                 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
00449                 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
00450                 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
00451                 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
00452                 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
00453                 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
00454                 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
00455                 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
00456                 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
00457                 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
00458                 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
00459                 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
00460                 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
00461                 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
00462                 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
00463                 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
00464                 VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
00465                 VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
00466                 VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
00467                 VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
00468                 VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
00469                 VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
00470                 VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
00471                 VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
00472                 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
00473                 VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
00474                 VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
00475                 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
00476         } VkFormat;
00477 
00478         typedef enum VkImageType {
00479                 VK_IMAGE_TYPE_1D = 0,
00480                 VK_IMAGE_TYPE_2D = 1,
00481                 VK_IMAGE_TYPE_3D = 2,
00482                 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
00483                 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
00484                 VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
00485                 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
00486         } VkImageType;
00487 
00488         typedef enum VkImageTiling {
00489                 VK_IMAGE_TILING_OPTIMAL = 0,
00490                 VK_IMAGE_TILING_LINEAR = 1,
00491                 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
00492                 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
00493                 VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
00494                 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
00495         } VkImageTiling;
00496 
00497         typedef enum VkPhysicalDeviceType {
00498                 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
00499                 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
00500                 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
00501                 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
00502                 VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
00503                 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
00504                 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
00505                 VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
00506                 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
00507         } VkPhysicalDeviceType;
00508 
00509         typedef enum VkQueryType {
00510                 VK_QUERY_TYPE_OCCLUSION = 0,
00511                 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
00512                 VK_QUERY_TYPE_TIMESTAMP = 2,
00513                 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
00514                 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
00515                 VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
00516                 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
00517         } VkQueryType;
00518 
00519         typedef enum VkSharingMode {
00520                 VK_SHARING_MODE_EXCLUSIVE = 0,
00521                 VK_SHARING_MODE_CONCURRENT = 1,
00522                 VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
00523                 VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
00524                 VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
00525                 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
00526         } VkSharingMode;
00527 
00528         typedef enum VkImageLayout {
00529                 VK_IMAGE_LAYOUT_UNDEFINED = 0,
00530                 VK_IMAGE_LAYOUT_GENERAL = 1,
00531                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
00532                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
00533                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
00534                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
00535                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
00536                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
00537                 VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
00538                 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
00539                 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
00540                 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
00541                 VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
00542                 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
00543         } VkImageLayout;
00544 
00545         typedef enum VkImageViewType {
00546                 VK_IMAGE_VIEW_TYPE_1D = 0,
00547                 VK_IMAGE_VIEW_TYPE_2D = 1,
00548                 VK_IMAGE_VIEW_TYPE_3D = 2,
00549                 VK_IMAGE_VIEW_TYPE_CUBE = 3,
00550                 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
00551                 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
00552                 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
00553                 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
00554                 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
00555                 VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
00556                 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
00557         } VkImageViewType;
00558 
00559         typedef enum VkComponentSwizzle {
00560                 VK_COMPONENT_SWIZZLE_IDENTITY = 0,
00561                 VK_COMPONENT_SWIZZLE_ZERO = 1,
00562                 VK_COMPONENT_SWIZZLE_ONE = 2,
00563                 VK_COMPONENT_SWIZZLE_R = 3,
00564                 VK_COMPONENT_SWIZZLE_G = 4,
00565                 VK_COMPONENT_SWIZZLE_B = 5,
00566                 VK_COMPONENT_SWIZZLE_A = 6,
00567                 VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
00568                 VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
00569                 VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
00570                 VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
00571         } VkComponentSwizzle;
00572 
00573         typedef enum VkVertexInputRate {
00574                 VK_VERTEX_INPUT_RATE_VERTEX = 0,
00575                 VK_VERTEX_INPUT_RATE_INSTANCE = 1,
00576                 VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
00577                 VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
00578                 VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
00579                 VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
00580         } VkVertexInputRate;
00581 
00582         typedef enum VkPrimitiveTopology {
00583                 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
00584                 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
00585                 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
00586                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
00587                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
00588                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
00589                 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
00590                 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
00591                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
00592                 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
00593                 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
00594                 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
00595                 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
00596                 VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
00597                 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
00598         } VkPrimitiveTopology;
00599 
00600         typedef enum VkPolygonMode {
00601                 VK_POLYGON_MODE_FILL = 0,
00602                 VK_POLYGON_MODE_LINE = 1,
00603                 VK_POLYGON_MODE_POINT = 2,
00604                 VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
00605                 VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
00606                 VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
00607                 VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
00608         } VkPolygonMode;
00609 
00610         typedef enum VkFrontFace {
00611                 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
00612                 VK_FRONT_FACE_CLOCKWISE = 1,
00613                 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
00614                 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
00615                 VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
00616                 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
00617         } VkFrontFace;
00618 
00619         typedef enum VkCompareOp {
00620                 VK_COMPARE_OP_NEVER = 0,
00621                 VK_COMPARE_OP_LESS = 1,
00622                 VK_COMPARE_OP_EQUAL = 2,
00623                 VK_COMPARE_OP_LESS_OR_EQUAL = 3,
00624                 VK_COMPARE_OP_GREATER = 4,
00625                 VK_COMPARE_OP_NOT_EQUAL = 5,
00626                 VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
00627                 VK_COMPARE_OP_ALWAYS = 7,
00628                 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
00629                 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
00630                 VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
00631                 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
00632         } VkCompareOp;
00633 
00634         typedef enum VkStencilOp {
00635                 VK_STENCIL_OP_KEEP = 0,
00636                 VK_STENCIL_OP_ZERO = 1,
00637                 VK_STENCIL_OP_REPLACE = 2,
00638                 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
00639                 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
00640                 VK_STENCIL_OP_INVERT = 5,
00641                 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
00642                 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
00643                 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
00644                 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
00645                 VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
00646                 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
00647         } VkStencilOp;
00648 
00649         typedef enum VkLogicOp {
00650                 VK_LOGIC_OP_CLEAR = 0,
00651                 VK_LOGIC_OP_AND = 1,
00652                 VK_LOGIC_OP_AND_REVERSE = 2,
00653                 VK_LOGIC_OP_COPY = 3,
00654                 VK_LOGIC_OP_AND_INVERTED = 4,
00655                 VK_LOGIC_OP_NO_OP = 5,
00656                 VK_LOGIC_OP_XOR = 6,
00657                 VK_LOGIC_OP_OR = 7,
00658                 VK_LOGIC_OP_NOR = 8,
00659                 VK_LOGIC_OP_EQUIVALENT = 9,
00660                 VK_LOGIC_OP_INVERT = 10,
00661                 VK_LOGIC_OP_OR_REVERSE = 11,
00662                 VK_LOGIC_OP_COPY_INVERTED = 12,
00663                 VK_LOGIC_OP_OR_INVERTED = 13,
00664                 VK_LOGIC_OP_NAND = 14,
00665                 VK_LOGIC_OP_SET = 15,
00666                 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
00667                 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
00668                 VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
00669                 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
00670         } VkLogicOp;
00671 
00672         typedef enum VkBlendFactor {
00673                 VK_BLEND_FACTOR_ZERO = 0,
00674                 VK_BLEND_FACTOR_ONE = 1,
00675                 VK_BLEND_FACTOR_SRC_COLOR = 2,
00676                 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
00677                 VK_BLEND_FACTOR_DST_COLOR = 4,
00678                 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
00679                 VK_BLEND_FACTOR_SRC_ALPHA = 6,
00680                 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
00681                 VK_BLEND_FACTOR_DST_ALPHA = 8,
00682                 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
00683                 VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
00684                 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
00685                 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
00686                 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
00687                 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
00688                 VK_BLEND_FACTOR_SRC1_COLOR = 15,
00689                 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
00690                 VK_BLEND_FACTOR_SRC1_ALPHA = 17,
00691                 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
00692                 VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
00693                 VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
00694                 VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
00695                 VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
00696         } VkBlendFactor;
00697 
00698         typedef enum VkBlendOp {
00699                 VK_BLEND_OP_ADD = 0,
00700                 VK_BLEND_OP_SUBTRACT = 1,
00701                 VK_BLEND_OP_REVERSE_SUBTRACT = 2,
00702                 VK_BLEND_OP_MIN = 3,
00703                 VK_BLEND_OP_MAX = 4,
00704                 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
00705                 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
00706                 VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
00707                 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
00708         } VkBlendOp;
00709 
00710         typedef enum VkDynamicState {
00711                 VK_DYNAMIC_STATE_VIEWPORT = 0,
00712                 VK_DYNAMIC_STATE_SCISSOR = 1,
00713                 VK_DYNAMIC_STATE_LINE_WIDTH = 2,
00714                 VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
00715                 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
00716                 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
00717                 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
00718                 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
00719                 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
00720                 VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
00721                 VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
00722                 VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
00723                 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
00724         } VkDynamicState;
00725 
00726         typedef enum VkFilter {
00727                 VK_FILTER_NEAREST = 0,
00728                 VK_FILTER_LINEAR = 1,
00729                 VK_FILTER_CUBIC_IMG = 1000015000,
00730                 VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
00731                 VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
00732                 VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
00733                 VK_FILTER_MAX_ENUM = 0x7FFFFFFF
00734         } VkFilter;
00735 
00736         typedef enum VkSamplerMipmapMode {
00737                 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
00738                 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
00739                 VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
00740                 VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
00741                 VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
00742                 VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
00743         } VkSamplerMipmapMode;
00744 
00745         typedef enum VkSamplerAddressMode {
00746                 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
00747                 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
00748                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
00749                 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
00750                 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
00751                 VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
00752                 VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
00753                 VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
00754                 VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
00755         } VkSamplerAddressMode;
00756 
00757         typedef enum VkBorderColor {
00758                 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
00759                 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
00760                 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
00761                 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
00762                 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
00763                 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
00764                 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
00765                 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
00766                 VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
00767                 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
00768         } VkBorderColor;
00769 
00770         typedef enum VkDescriptorType {
00771                 VK_DESCRIPTOR_TYPE_SAMPLER = 0,
00772                 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
00773                 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
00774                 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
00775                 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
00776                 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
00777                 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
00778                 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
00779                 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
00780                 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
00781                 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
00782                 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
00783                 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
00784                 VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
00785                 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
00786         } VkDescriptorType;
00787 
00788         typedef enum VkAttachmentLoadOp {
00789                 VK_ATTACHMENT_LOAD_OP_LOAD = 0,
00790                 VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
00791                 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
00792                 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
00793                 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
00794                 VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
00795                 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
00796         } VkAttachmentLoadOp;
00797 
00798         typedef enum VkAttachmentStoreOp {
00799                 VK_ATTACHMENT_STORE_OP_STORE = 0,
00800                 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
00801                 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
00802                 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
00803                 VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
00804                 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
00805         } VkAttachmentStoreOp;
00806 
00807         typedef enum VkPipelineBindPoint {
00808                 VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
00809                 VK_PIPELINE_BIND_POINT_COMPUTE = 1,
00810                 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
00811                 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
00812                 VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
00813                 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
00814         } VkPipelineBindPoint;
00815 
00816         typedef enum VkCommandBufferLevel {
00817                 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
00818                 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
00819                 VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
00820                 VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
00821                 VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
00822                 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
00823         } VkCommandBufferLevel;
00824 
00825         typedef enum VkIndexType {
00826                 VK_INDEX_TYPE_UINT16 = 0,
00827                 VK_INDEX_TYPE_UINT32 = 1,
00828                 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
00829                 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
00830                 VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
00831                 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
00832         } VkIndexType;
00833 
00834         typedef enum VkSubpassContents {
00835                 VK_SUBPASS_CONTENTS_INLINE = 0,
00836                 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
00837                 VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
00838                 VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
00839                 VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
00840                 VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
00841         } VkSubpassContents;
00842 
00843         typedef VkFlags VkInstanceCreateFlags;
00844 
00845         typedef enum VkFormatFeatureFlagBits {
00846                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
00847                 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
00848                 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
00849                 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
00850                 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
00851                 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
00852                 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
00853                 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
00854                 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
00855                 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
00856                 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
00857                 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
00858                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
00859                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
00860                 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000,
00861                 VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000,
00862                 VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00863         } VkFormatFeatureFlagBits;
00864         typedef VkFlags VkFormatFeatureFlags;
00865 
00866         typedef enum VkImageUsageFlagBits {
00867                 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
00868                 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
00869                 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
00870                 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
00871                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
00872                 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
00873                 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
00874                 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
00875                 VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00876         } VkImageUsageFlagBits;
00877         typedef VkFlags VkImageUsageFlags;
00878 
00879         typedef enum VkImageCreateFlagBits {
00880                 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
00881                 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
00882                 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
00883                 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
00884                 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
00885                 VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020,
00886                 VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00887         } VkImageCreateFlagBits;
00888         typedef VkFlags VkImageCreateFlags;
00889 
00890         typedef enum VkSampleCountFlagBits {
00891                 VK_SAMPLE_COUNT_1_BIT = 0x00000001,
00892                 VK_SAMPLE_COUNT_2_BIT = 0x00000002,
00893                 VK_SAMPLE_COUNT_4_BIT = 0x00000004,
00894                 VK_SAMPLE_COUNT_8_BIT = 0x00000008,
00895                 VK_SAMPLE_COUNT_16_BIT = 0x00000010,
00896                 VK_SAMPLE_COUNT_32_BIT = 0x00000020,
00897                 VK_SAMPLE_COUNT_64_BIT = 0x00000040,
00898                 VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00899         } VkSampleCountFlagBits;
00900         typedef VkFlags VkSampleCountFlags;
00901 
00902         typedef enum VkQueueFlagBits {
00903                 VK_QUEUE_GRAPHICS_BIT = 0x00000001,
00904                 VK_QUEUE_COMPUTE_BIT = 0x00000002,
00905                 VK_QUEUE_TRANSFER_BIT = 0x00000004,
00906                 VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
00907                 VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00908         } VkQueueFlagBits;
00909         typedef VkFlags VkQueueFlags;
00910 
00911         typedef enum VkMemoryPropertyFlagBits {
00912                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
00913                 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
00914                 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
00915                 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
00916                 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
00917                 VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00918         } VkMemoryPropertyFlagBits;
00919         typedef VkFlags VkMemoryPropertyFlags;
00920 
00921         typedef enum VkMemoryHeapFlagBits {
00922                 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
00923                 VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00924         } VkMemoryHeapFlagBits;
00925         typedef VkFlags VkMemoryHeapFlags;
00926         typedef VkFlags VkDeviceCreateFlags;
00927         typedef VkFlags VkDeviceQueueCreateFlags;
00928 
00929         typedef enum VkPipelineStageFlagBits {
00930                 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
00931                 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
00932                 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
00933                 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
00934                 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
00935                 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
00936                 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
00937                 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
00938                 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
00939                 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
00940                 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
00941                 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
00942                 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
00943                 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
00944                 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
00945                 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
00946                 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
00947                 VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
00948                 VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00949         } VkPipelineStageFlagBits;
00950         typedef VkFlags VkPipelineStageFlags;
00951         typedef VkFlags VkMemoryMapFlags;
00952 
00953         typedef enum VkImageAspectFlagBits {
00954                 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
00955                 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
00956                 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
00957                 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
00958                 VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00959         } VkImageAspectFlagBits;
00960         typedef VkFlags VkImageAspectFlags;
00961 
00962         typedef enum VkSparseImageFormatFlagBits {
00963                 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
00964                 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
00965                 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
00966                 VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00967         } VkSparseImageFormatFlagBits;
00968         typedef VkFlags VkSparseImageFormatFlags;
00969 
00970         typedef enum VkSparseMemoryBindFlagBits {
00971                 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
00972                 VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00973         } VkSparseMemoryBindFlagBits;
00974         typedef VkFlags VkSparseMemoryBindFlags;
00975 
00976         typedef enum VkFenceCreateFlagBits {
00977                 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
00978                 VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00979         } VkFenceCreateFlagBits;
00980         typedef VkFlags VkFenceCreateFlags;
00981         typedef VkFlags VkSemaphoreCreateFlags;
00982         typedef VkFlags VkEventCreateFlags;
00983         typedef VkFlags VkQueryPoolCreateFlags;
00984 
00985         typedef enum VkQueryPipelineStatisticFlagBits {
00986                 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
00987                 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
00988                 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
00989                 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
00990                 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
00991                 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
00992                 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
00993                 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
00994                 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
00995                 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
00996                 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
00997                 VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
00998         } VkQueryPipelineStatisticFlagBits;
00999         typedef VkFlags VkQueryPipelineStatisticFlags;
01000 
01001         typedef enum VkQueryResultFlagBits {
01002                 VK_QUERY_RESULT_64_BIT = 0x00000001,
01003                 VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
01004                 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
01005                 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
01006                 VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01007         } VkQueryResultFlagBits;
01008         typedef VkFlags VkQueryResultFlags;
01009 
01010         typedef enum VkBufferCreateFlagBits {
01011                 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
01012                 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
01013                 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
01014                 VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01015         } VkBufferCreateFlagBits;
01016         typedef VkFlags VkBufferCreateFlags;
01017 
01018         typedef enum VkBufferUsageFlagBits {
01019                 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
01020                 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
01021                 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
01022                 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
01023                 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
01024                 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
01025                 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
01026                 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
01027                 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
01028                 VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01029         } VkBufferUsageFlagBits;
01030         typedef VkFlags VkBufferUsageFlags;
01031         typedef VkFlags VkBufferViewCreateFlags;
01032         typedef VkFlags VkImageViewCreateFlags;
01033         typedef VkFlags VkShaderModuleCreateFlags;
01034         typedef VkFlags VkPipelineCacheCreateFlags;
01035 
01036         typedef enum VkPipelineCreateFlagBits {
01037                 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
01038                 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
01039                 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
01040                 VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01041         } VkPipelineCreateFlagBits;
01042         typedef VkFlags VkPipelineCreateFlags;
01043         typedef VkFlags VkPipelineShaderStageCreateFlags;
01044 
01045         typedef enum VkShaderStageFlagBits {
01046                 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
01047                 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
01048                 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
01049                 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
01050                 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
01051                 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
01052                 VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
01053                 VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
01054                 VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01055         } VkShaderStageFlagBits;
01056         typedef VkFlags VkPipelineVertexInputStateCreateFlags;
01057         typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
01058         typedef VkFlags VkPipelineTessellationStateCreateFlags;
01059         typedef VkFlags VkPipelineViewportStateCreateFlags;
01060         typedef VkFlags VkPipelineRasterizationStateCreateFlags;
01061 
01062         typedef enum VkCullModeFlagBits {
01063                 VK_CULL_MODE_NONE = 0,
01064                 VK_CULL_MODE_FRONT_BIT = 0x00000001,
01065                 VK_CULL_MODE_BACK_BIT = 0x00000002,
01066                 VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
01067                 VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01068         } VkCullModeFlagBits;
01069         typedef VkFlags VkCullModeFlags;
01070         typedef VkFlags VkPipelineMultisampleStateCreateFlags;
01071         typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
01072         typedef VkFlags VkPipelineColorBlendStateCreateFlags;
01073 
01074         typedef enum VkColorComponentFlagBits {
01075                 VK_COLOR_COMPONENT_R_BIT = 0x00000001,
01076                 VK_COLOR_COMPONENT_G_BIT = 0x00000002,
01077                 VK_COLOR_COMPONENT_B_BIT = 0x00000004,
01078                 VK_COLOR_COMPONENT_A_BIT = 0x00000008,
01079                 VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01080         } VkColorComponentFlagBits;
01081         typedef VkFlags VkColorComponentFlags;
01082         typedef VkFlags VkPipelineDynamicStateCreateFlags;
01083         typedef VkFlags VkPipelineLayoutCreateFlags;
01084         typedef VkFlags VkShaderStageFlags;
01085         typedef VkFlags VkSamplerCreateFlags;
01086         typedef VkFlags VkDescriptorSetLayoutCreateFlags;
01087 
01088         typedef enum VkDescriptorPoolCreateFlagBits {
01089                 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
01090                 VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01091         } VkDescriptorPoolCreateFlagBits;
01092         typedef VkFlags VkDescriptorPoolCreateFlags;
01093         typedef VkFlags VkDescriptorPoolResetFlags;
01094         typedef VkFlags VkFramebufferCreateFlags;
01095         typedef VkFlags VkRenderPassCreateFlags;
01096 
01097         typedef enum VkAttachmentDescriptionFlagBits {
01098                 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
01099                 VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01100         } VkAttachmentDescriptionFlagBits;
01101         typedef VkFlags VkAttachmentDescriptionFlags;
01102         typedef VkFlags VkSubpassDescriptionFlags;
01103 
01104         typedef enum VkAccessFlagBits {
01105                 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
01106                 VK_ACCESS_INDEX_READ_BIT = 0x00000002,
01107                 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
01108                 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
01109                 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
01110                 VK_ACCESS_SHADER_READ_BIT = 0x00000020,
01111                 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
01112                 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
01113                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
01114                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
01115                 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
01116                 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
01117                 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
01118                 VK_ACCESS_HOST_READ_BIT = 0x00002000,
01119                 VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
01120                 VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
01121                 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
01122                 VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
01123                 VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
01124                 VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01125         } VkAccessFlagBits;
01126         typedef VkFlags VkAccessFlags;
01127 
01128         typedef enum VkDependencyFlagBits {
01129                 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
01130                 VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01131         } VkDependencyFlagBits;
01132         typedef VkFlags VkDependencyFlags;
01133 
01134         typedef enum VkCommandPoolCreateFlagBits {
01135                 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
01136                 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
01137                 VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01138         } VkCommandPoolCreateFlagBits;
01139         typedef VkFlags VkCommandPoolCreateFlags;
01140 
01141         typedef enum VkCommandPoolResetFlagBits {
01142                 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
01143                 VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01144         } VkCommandPoolResetFlagBits;
01145         typedef VkFlags VkCommandPoolResetFlags;
01146 
01147         typedef enum VkCommandBufferUsageFlagBits {
01148                 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
01149                 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
01150                 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
01151                 VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01152         } VkCommandBufferUsageFlagBits;
01153         typedef VkFlags VkCommandBufferUsageFlags;
01154 
01155         typedef enum VkQueryControlFlagBits {
01156                 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
01157                 VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01158         } VkQueryControlFlagBits;
01159         typedef VkFlags VkQueryControlFlags;
01160 
01161         typedef enum VkCommandBufferResetFlagBits {
01162                 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
01163                 VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01164         } VkCommandBufferResetFlagBits;
01165         typedef VkFlags VkCommandBufferResetFlags;
01166 
01167         typedef enum VkStencilFaceFlagBits {
01168                 VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
01169                 VK_STENCIL_FACE_BACK_BIT = 0x00000002,
01170                 VK_STENCIL_FRONT_AND_BACK = 0x00000003,
01171                 VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
01172         } VkStencilFaceFlagBits;
01173         typedef VkFlags VkStencilFaceFlags;
01174 
01175         typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
01176                 void*                                       pUserData,
01177                 size_t                                      size,
01178                 size_t                                      alignment,
01179                 VkSystemAllocationScope                     allocationScope);
01180 
01181         typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
01182                 void*                                       pUserData,
01183                 void*                                       pOriginal,
01184                 size_t                                      size,
01185                 size_t                                      alignment,
01186                 VkSystemAllocationScope                     allocationScope);
01187 
01188         typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
01189                 void*                                       pUserData,
01190                 void*                                       pMemory);
01191 
01192         typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
01193                 void*                                       pUserData,
01194                 size_t                                      size,
01195                 VkInternalAllocationType                    allocationType,
01196                 VkSystemAllocationScope                     allocationScope);
01197 
01198         typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
01199                 void*                                       pUserData,
01200                 size_t                                      size,
01201                 VkInternalAllocationType                    allocationType,
01202                 VkSystemAllocationScope                     allocationScope);
01203 
01204         typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
01205 
01206         typedef struct VkApplicationInfo {
01207                 VkStructureType    sType;
01208                 const void*        pNext;
01209                 const char*        pApplicationName;
01210                 uint32_t           applicationVersion;
01211                 const char*        pEngineName;
01212                 uint32_t           engineVersion;
01213                 uint32_t           apiVersion;
01214         } VkApplicationInfo;
01215 
01216         typedef struct VkInstanceCreateInfo {
01217                 VkStructureType             sType;
01218                 const void*                 pNext;
01219                 VkInstanceCreateFlags       flags;
01220                 const VkApplicationInfo*    pApplicationInfo;
01221                 uint32_t                    enabledLayerCount;
01222                 const char* const*          ppEnabledLayerNames;
01223                 uint32_t                    enabledExtensionCount;
01224                 const char* const*          ppEnabledExtensionNames;
01225         } VkInstanceCreateInfo;
01226 
01227         typedef struct VkAllocationCallbacks {
01228                 void*                                   pUserData;
01229                 PFN_vkAllocationFunction                pfnAllocation;
01230                 PFN_vkReallocationFunction              pfnReallocation;
01231                 PFN_vkFreeFunction                      pfnFree;
01232                 PFN_vkInternalAllocationNotification    pfnInternalAllocation;
01233                 PFN_vkInternalFreeNotification          pfnInternalFree;
01234         } VkAllocationCallbacks;
01235 
01236         typedef struct VkPhysicalDeviceFeatures {
01237                 VkBool32    robustBufferAccess;
01238                 VkBool32    fullDrawIndexUint32;
01239                 VkBool32    imageCubeArray;
01240                 VkBool32    independentBlend;
01241                 VkBool32    geometryShader;
01242                 VkBool32    tessellationShader;
01243                 VkBool32    sampleRateShading;
01244                 VkBool32    dualSrcBlend;
01245                 VkBool32    logicOp;
01246                 VkBool32    multiDrawIndirect;
01247                 VkBool32    drawIndirectFirstInstance;
01248                 VkBool32    depthClamp;
01249                 VkBool32    depthBiasClamp;
01250                 VkBool32    fillModeNonSolid;
01251                 VkBool32    depthBounds;
01252                 VkBool32    wideLines;
01253                 VkBool32    largePoints;
01254                 VkBool32    alphaToOne;
01255                 VkBool32    multiViewport;
01256                 VkBool32    samplerAnisotropy;
01257                 VkBool32    textureCompressionETC2;
01258                 VkBool32    textureCompressionASTC_LDR;
01259                 VkBool32    textureCompressionBC;
01260                 VkBool32    occlusionQueryPrecise;
01261                 VkBool32    pipelineStatisticsQuery;
01262                 VkBool32    vertexPipelineStoresAndAtomics;
01263                 VkBool32    fragmentStoresAndAtomics;
01264                 VkBool32    shaderTessellationAndGeometryPointSize;
01265                 VkBool32    shaderImageGatherExtended;
01266                 VkBool32    shaderStorageImageExtendedFormats;
01267                 VkBool32    shaderStorageImageMultisample;
01268                 VkBool32    shaderStorageImageReadWithoutFormat;
01269                 VkBool32    shaderStorageImageWriteWithoutFormat;
01270                 VkBool32    shaderUniformBufferArrayDynamicIndexing;
01271                 VkBool32    shaderSampledImageArrayDynamicIndexing;
01272                 VkBool32    shaderStorageBufferArrayDynamicIndexing;
01273                 VkBool32    shaderStorageImageArrayDynamicIndexing;
01274                 VkBool32    shaderClipDistance;
01275                 VkBool32    shaderCullDistance;
01276                 VkBool32    shaderFloat64;
01277                 VkBool32    shaderInt64;
01278                 VkBool32    shaderInt16;
01279                 VkBool32    shaderResourceResidency;
01280                 VkBool32    shaderResourceMinLod;
01281                 VkBool32    sparseBinding;
01282                 VkBool32    sparseResidencyBuffer;
01283                 VkBool32    sparseResidencyImage2D;
01284                 VkBool32    sparseResidencyImage3D;
01285                 VkBool32    sparseResidency2Samples;
01286                 VkBool32    sparseResidency4Samples;
01287                 VkBool32    sparseResidency8Samples;
01288                 VkBool32    sparseResidency16Samples;
01289                 VkBool32    sparseResidencyAliased;
01290                 VkBool32    variableMultisampleRate;
01291                 VkBool32    inheritedQueries;
01292         } VkPhysicalDeviceFeatures;
01293 
01294         typedef struct VkFormatProperties {
01295                 VkFormatFeatureFlags    linearTilingFeatures;
01296                 VkFormatFeatureFlags    optimalTilingFeatures;
01297                 VkFormatFeatureFlags    bufferFeatures;
01298         } VkFormatProperties;
01299 
01300         typedef struct VkExtent3D {
01301                 uint32_t    width;
01302                 uint32_t    height;
01303                 uint32_t    depth;
01304         } VkExtent3D;
01305 
01306         typedef struct VkImageFormatProperties {
01307                 VkExtent3D            maxExtent;
01308                 uint32_t              maxMipLevels;
01309                 uint32_t              maxArrayLayers;
01310                 VkSampleCountFlags    sampleCounts;
01311                 VkDeviceSize          maxResourceSize;
01312         } VkImageFormatProperties;
01313 
01314         typedef struct VkPhysicalDeviceLimits {
01315                 uint32_t              maxImageDimension1D;
01316                 uint32_t              maxImageDimension2D;
01317                 uint32_t              maxImageDimension3D;
01318                 uint32_t              maxImageDimensionCube;
01319                 uint32_t              maxImageArrayLayers;
01320                 uint32_t              maxTexelBufferElements;
01321                 uint32_t              maxUniformBufferRange;
01322                 uint32_t              maxStorageBufferRange;
01323                 uint32_t              maxPushConstantsSize;
01324                 uint32_t              maxMemoryAllocationCount;
01325                 uint32_t              maxSamplerAllocationCount;
01326                 VkDeviceSize          bufferImageGranularity;
01327                 VkDeviceSize          sparseAddressSpaceSize;
01328                 uint32_t              maxBoundDescriptorSets;
01329                 uint32_t              maxPerStageDescriptorSamplers;
01330                 uint32_t              maxPerStageDescriptorUniformBuffers;
01331                 uint32_t              maxPerStageDescriptorStorageBuffers;
01332                 uint32_t              maxPerStageDescriptorSampledImages;
01333                 uint32_t              maxPerStageDescriptorStorageImages;
01334                 uint32_t              maxPerStageDescriptorInputAttachments;
01335                 uint32_t              maxPerStageResources;
01336                 uint32_t              maxDescriptorSetSamplers;
01337                 uint32_t              maxDescriptorSetUniformBuffers;
01338                 uint32_t              maxDescriptorSetUniformBuffersDynamic;
01339                 uint32_t              maxDescriptorSetStorageBuffers;
01340                 uint32_t              maxDescriptorSetStorageBuffersDynamic;
01341                 uint32_t              maxDescriptorSetSampledImages;
01342                 uint32_t              maxDescriptorSetStorageImages;
01343                 uint32_t              maxDescriptorSetInputAttachments;
01344                 uint32_t              maxVertexInputAttributes;
01345                 uint32_t              maxVertexInputBindings;
01346                 uint32_t              maxVertexInputAttributeOffset;
01347                 uint32_t              maxVertexInputBindingStride;
01348                 uint32_t              maxVertexOutputComponents;
01349                 uint32_t              maxTessellationGenerationLevel;
01350                 uint32_t              maxTessellationPatchSize;
01351                 uint32_t              maxTessellationControlPerVertexInputComponents;
01352                 uint32_t              maxTessellationControlPerVertexOutputComponents;
01353                 uint32_t              maxTessellationControlPerPatchOutputComponents;
01354                 uint32_t              maxTessellationControlTotalOutputComponents;
01355                 uint32_t              maxTessellationEvaluationInputComponents;
01356                 uint32_t              maxTessellationEvaluationOutputComponents;
01357                 uint32_t              maxGeometryShaderInvocations;
01358                 uint32_t              maxGeometryInputComponents;
01359                 uint32_t              maxGeometryOutputComponents;
01360                 uint32_t              maxGeometryOutputVertices;
01361                 uint32_t              maxGeometryTotalOutputComponents;
01362                 uint32_t              maxFragmentInputComponents;
01363                 uint32_t              maxFragmentOutputAttachments;
01364                 uint32_t              maxFragmentDualSrcAttachments;
01365                 uint32_t              maxFragmentCombinedOutputResources;
01366                 uint32_t              maxComputeSharedMemorySize;
01367                 uint32_t              maxComputeWorkGroupCount[3];
01368                 uint32_t              maxComputeWorkGroupInvocations;
01369                 uint32_t              maxComputeWorkGroupSize[3];
01370                 uint32_t              subPixelPrecisionBits;
01371                 uint32_t              subTexelPrecisionBits;
01372                 uint32_t              mipmapPrecisionBits;
01373                 uint32_t              maxDrawIndexedIndexValue;
01374                 uint32_t              maxDrawIndirectCount;
01375                 float                 maxSamplerLodBias;
01376                 float                 maxSamplerAnisotropy;
01377                 uint32_t              maxViewports;
01378                 uint32_t              maxViewportDimensions[2];
01379                 float                 viewportBoundsRange[2];
01380                 uint32_t              viewportSubPixelBits;
01381                 size_t                minMemoryMapAlignment;
01382                 VkDeviceSize          minTexelBufferOffsetAlignment;
01383                 VkDeviceSize          minUniformBufferOffsetAlignment;
01384                 VkDeviceSize          minStorageBufferOffsetAlignment;
01385                 int32_t               minTexelOffset;
01386                 uint32_t              maxTexelOffset;
01387                 int32_t               minTexelGatherOffset;
01388                 uint32_t              maxTexelGatherOffset;
01389                 float                 minInterpolationOffset;
01390                 float                 maxInterpolationOffset;
01391                 uint32_t              subPixelInterpolationOffsetBits;
01392                 uint32_t              maxFramebufferWidth;
01393                 uint32_t              maxFramebufferHeight;
01394                 uint32_t              maxFramebufferLayers;
01395                 VkSampleCountFlags    framebufferColorSampleCounts;
01396                 VkSampleCountFlags    framebufferDepthSampleCounts;
01397                 VkSampleCountFlags    framebufferStencilSampleCounts;
01398                 VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
01399                 uint32_t              maxColorAttachments;
01400                 VkSampleCountFlags    sampledImageColorSampleCounts;
01401                 VkSampleCountFlags    sampledImageIntegerSampleCounts;
01402                 VkSampleCountFlags    sampledImageDepthSampleCounts;
01403                 VkSampleCountFlags    sampledImageStencilSampleCounts;
01404                 VkSampleCountFlags    storageImageSampleCounts;
01405                 uint32_t              maxSampleMaskWords;
01406                 VkBool32              timestampComputeAndGraphics;
01407                 float                 timestampPeriod;
01408                 uint32_t              maxClipDistances;
01409                 uint32_t              maxCullDistances;
01410                 uint32_t              maxCombinedClipAndCullDistances;
01411                 uint32_t              discreteQueuePriorities;
01412                 float                 pointSizeRange[2];
01413                 float                 lineWidthRange[2];
01414                 float                 pointSizeGranularity;
01415                 float                 lineWidthGranularity;
01416                 VkBool32              strictLines;
01417                 VkBool32              standardSampleLocations;
01418                 VkDeviceSize          optimalBufferCopyOffsetAlignment;
01419                 VkDeviceSize          optimalBufferCopyRowPitchAlignment;
01420                 VkDeviceSize          nonCoherentAtomSize;
01421         } VkPhysicalDeviceLimits;
01422 
01423         typedef struct VkPhysicalDeviceSparseProperties {
01424                 VkBool32    residencyStandard2DBlockShape;
01425                 VkBool32    residencyStandard2DMultisampleBlockShape;
01426                 VkBool32    residencyStandard3DBlockShape;
01427                 VkBool32    residencyAlignedMipSize;
01428                 VkBool32    residencyNonResidentStrict;
01429         } VkPhysicalDeviceSparseProperties;
01430 
01431         typedef struct VkPhysicalDeviceProperties {
01432                 uint32_t                            apiVersion;
01433                 uint32_t                            driverVersion;
01434                 uint32_t                            vendorID;
01435                 uint32_t                            deviceID;
01436                 VkPhysicalDeviceType                deviceType;
01437                 char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
01438                 uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
01439                 VkPhysicalDeviceLimits              limits;
01440                 VkPhysicalDeviceSparseProperties    sparseProperties;
01441         } VkPhysicalDeviceProperties;
01442 
01443         typedef struct VkQueueFamilyProperties {
01444                 VkQueueFlags    queueFlags;
01445                 uint32_t        queueCount;
01446                 uint32_t        timestampValidBits;
01447                 VkExtent3D      minImageTransferGranularity;
01448         } VkQueueFamilyProperties;
01449 
01450         typedef struct VkMemoryType {
01451                 VkMemoryPropertyFlags    propertyFlags;
01452                 uint32_t                 heapIndex;
01453         } VkMemoryType;
01454 
01455         typedef struct VkMemoryHeap {
01456                 VkDeviceSize         size;
01457                 VkMemoryHeapFlags    flags;
01458         } VkMemoryHeap;
01459 
01460         typedef struct VkPhysicalDeviceMemoryProperties {
01461                 uint32_t        memoryTypeCount;
01462                 VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
01463                 uint32_t        memoryHeapCount;
01464                 VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
01465         } VkPhysicalDeviceMemoryProperties;
01466 
01467         typedef struct VkDeviceQueueCreateInfo {
01468                 VkStructureType             sType;
01469                 const void*                 pNext;
01470                 VkDeviceQueueCreateFlags    flags;
01471                 uint32_t                    queueFamilyIndex;
01472                 uint32_t                    queueCount;
01473                 const float*                pQueuePriorities;
01474         } VkDeviceQueueCreateInfo;
01475 
01476         typedef struct VkDeviceCreateInfo {
01477                 VkStructureType                    sType;
01478                 const void*                        pNext;
01479                 VkDeviceCreateFlags                flags;
01480                 uint32_t                           queueCreateInfoCount;
01481                 const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
01482                 uint32_t                           enabledLayerCount;
01483                 const char* const*                 ppEnabledLayerNames;
01484                 uint32_t                           enabledExtensionCount;
01485                 const char* const*                 ppEnabledExtensionNames;
01486                 const VkPhysicalDeviceFeatures*    pEnabledFeatures;
01487         } VkDeviceCreateInfo;
01488 
01489         typedef struct VkExtensionProperties {
01490                 char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
01491                 uint32_t    specVersion;
01492         } VkExtensionProperties;
01493 
01494         typedef struct VkLayerProperties {
01495                 char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
01496                 uint32_t    specVersion;
01497                 uint32_t    implementationVersion;
01498                 char        description[VK_MAX_DESCRIPTION_SIZE];
01499         } VkLayerProperties;
01500 
01501         typedef struct VkSubmitInfo {
01502                 VkStructureType                sType;
01503                 const void*                    pNext;
01504                 uint32_t                       waitSemaphoreCount;
01505                 const VkSemaphore*             pWaitSemaphores;
01506                 const VkPipelineStageFlags*    pWaitDstStageMask;
01507                 uint32_t                       commandBufferCount;
01508                 const VkCommandBuffer*         pCommandBuffers;
01509                 uint32_t                       signalSemaphoreCount;
01510                 const VkSemaphore*             pSignalSemaphores;
01511         } VkSubmitInfo;
01512 
01513         typedef struct VkMemoryAllocateInfo {
01514                 VkStructureType    sType;
01515                 const void*        pNext;
01516                 VkDeviceSize       allocationSize;
01517                 uint32_t           memoryTypeIndex;
01518         } VkMemoryAllocateInfo;
01519 
01520         typedef struct VkMappedMemoryRange {
01521                 VkStructureType    sType;
01522                 const void*        pNext;
01523                 VkDeviceMemory     memory;
01524                 VkDeviceSize       offset;
01525                 VkDeviceSize       size;
01526         } VkMappedMemoryRange;
01527 
01528         typedef struct VkMemoryRequirements {
01529                 VkDeviceSize    size;
01530                 VkDeviceSize    alignment;
01531                 uint32_t        memoryTypeBits;
01532         } VkMemoryRequirements;
01533 
01534         typedef struct VkSparseImageFormatProperties {
01535                 VkImageAspectFlags          aspectMask;
01536                 VkExtent3D                  imageGranularity;
01537                 VkSparseImageFormatFlags    flags;
01538         } VkSparseImageFormatProperties;
01539 
01540         typedef struct VkSparseImageMemoryRequirements {
01541                 VkSparseImageFormatProperties    formatProperties;
01542                 uint32_t                         imageMipTailFirstLod;
01543                 VkDeviceSize                     imageMipTailSize;
01544                 VkDeviceSize                     imageMipTailOffset;
01545                 VkDeviceSize                     imageMipTailStride;
01546         } VkSparseImageMemoryRequirements;
01547 
01548         typedef struct VkSparseMemoryBind {
01549                 VkDeviceSize               resourceOffset;
01550                 VkDeviceSize               size;
01551                 VkDeviceMemory             memory;
01552                 VkDeviceSize               memoryOffset;
01553                 VkSparseMemoryBindFlags    flags;
01554         } VkSparseMemoryBind;
01555 
01556         typedef struct VkSparseBufferMemoryBindInfo {
01557                 VkBuffer                     buffer;
01558                 uint32_t                     bindCount;
01559                 const VkSparseMemoryBind*    pBinds;
01560         } VkSparseBufferMemoryBindInfo;
01561 
01562         typedef struct VkSparseImageOpaqueMemoryBindInfo {
01563                 VkImage                      image;
01564                 uint32_t                     bindCount;
01565                 const VkSparseMemoryBind*    pBinds;
01566         } VkSparseImageOpaqueMemoryBindInfo;
01567 
01568         typedef struct VkImageSubresource {
01569                 VkImageAspectFlags    aspectMask;
01570                 uint32_t              mipLevel;
01571                 uint32_t              arrayLayer;
01572         } VkImageSubresource;
01573 
01574         typedef struct VkOffset3D {
01575                 int32_t    x;
01576                 int32_t    y;
01577                 int32_t    z;
01578         } VkOffset3D;
01579 
01580         typedef struct VkSparseImageMemoryBind {
01581                 VkImageSubresource         subresource;
01582                 VkOffset3D                 offset;
01583                 VkExtent3D                 extent;
01584                 VkDeviceMemory             memory;
01585                 VkDeviceSize               memoryOffset;
01586                 VkSparseMemoryBindFlags    flags;
01587         } VkSparseImageMemoryBind;
01588 
01589         typedef struct VkSparseImageMemoryBindInfo {
01590                 VkImage                           image;
01591                 uint32_t                          bindCount;
01592                 const VkSparseImageMemoryBind*    pBinds;
01593         } VkSparseImageMemoryBindInfo;
01594 
01595         typedef struct VkBindSparseInfo {
01596                 VkStructureType                             sType;
01597                 const void*                                 pNext;
01598                 uint32_t                                    waitSemaphoreCount;
01599                 const VkSemaphore*                          pWaitSemaphores;
01600                 uint32_t                                    bufferBindCount;
01601                 const VkSparseBufferMemoryBindInfo*         pBufferBinds;
01602                 uint32_t                                    imageOpaqueBindCount;
01603                 const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
01604                 uint32_t                                    imageBindCount;
01605                 const VkSparseImageMemoryBindInfo*          pImageBinds;
01606                 uint32_t                                    signalSemaphoreCount;
01607                 const VkSemaphore*                          pSignalSemaphores;
01608         } VkBindSparseInfo;
01609 
01610         typedef struct VkFenceCreateInfo {
01611                 VkStructureType       sType;
01612                 const void*           pNext;
01613                 VkFenceCreateFlags    flags;
01614         } VkFenceCreateInfo;
01615 
01616         typedef struct VkSemaphoreCreateInfo {
01617                 VkStructureType           sType;
01618                 const void*               pNext;
01619                 VkSemaphoreCreateFlags    flags;
01620         } VkSemaphoreCreateInfo;
01621 
01622         typedef struct VkEventCreateInfo {
01623                 VkStructureType       sType;
01624                 const void*           pNext;
01625                 VkEventCreateFlags    flags;
01626         } VkEventCreateInfo;
01627 
01628         typedef struct VkQueryPoolCreateInfo {
01629                 VkStructureType                  sType;
01630                 const void*                      pNext;
01631                 VkQueryPoolCreateFlags           flags;
01632                 VkQueryType                      queryType;
01633                 uint32_t                         queryCount;
01634                 VkQueryPipelineStatisticFlags    pipelineStatistics;
01635         } VkQueryPoolCreateInfo;
01636 
01637         typedef struct VkBufferCreateInfo {
01638                 VkStructureType        sType;
01639                 const void*            pNext;
01640                 VkBufferCreateFlags    flags;
01641                 VkDeviceSize           size;
01642                 VkBufferUsageFlags     usage;
01643                 VkSharingMode          sharingMode;
01644                 uint32_t               queueFamilyIndexCount;
01645                 const uint32_t*        pQueueFamilyIndices;
01646         } VkBufferCreateInfo;
01647 
01648         typedef struct VkBufferViewCreateInfo {
01649                 VkStructureType            sType;
01650                 const void*                pNext;
01651                 VkBufferViewCreateFlags    flags;
01652                 VkBuffer                   buffer;
01653                 VkFormat                   format;
01654                 VkDeviceSize               offset;
01655                 VkDeviceSize               range;
01656         } VkBufferViewCreateInfo;
01657 
01658         typedef struct VkImageCreateInfo {
01659                 VkStructureType          sType;
01660                 const void*              pNext;
01661                 VkImageCreateFlags       flags;
01662                 VkImageType              imageType;
01663                 VkFormat                 format;
01664                 VkExtent3D               extent;
01665                 uint32_t                 mipLevels;
01666                 uint32_t                 arrayLayers;
01667                 VkSampleCountFlagBits    samples;
01668                 VkImageTiling            tiling;
01669                 VkImageUsageFlags        usage;
01670                 VkSharingMode            sharingMode;
01671                 uint32_t                 queueFamilyIndexCount;
01672                 const uint32_t*          pQueueFamilyIndices;
01673                 VkImageLayout            initialLayout;
01674         } VkImageCreateInfo;
01675 
01676         typedef struct VkSubresourceLayout {
01677                 VkDeviceSize    offset;
01678                 VkDeviceSize    size;
01679                 VkDeviceSize    rowPitch;
01680                 VkDeviceSize    arrayPitch;
01681                 VkDeviceSize    depthPitch;
01682         } VkSubresourceLayout;
01683 
01684         typedef struct VkComponentMapping {
01685                 VkComponentSwizzle    r;
01686                 VkComponentSwizzle    g;
01687                 VkComponentSwizzle    b;
01688                 VkComponentSwizzle    a;
01689         } VkComponentMapping;
01690 
01691         typedef struct VkImageSubresourceRange {
01692                 VkImageAspectFlags    aspectMask;
01693                 uint32_t              baseMipLevel;
01694                 uint32_t              levelCount;
01695                 uint32_t              baseArrayLayer;
01696                 uint32_t              layerCount;
01697         } VkImageSubresourceRange;
01698 
01699         typedef struct VkImageViewCreateInfo {
01700                 VkStructureType            sType;
01701                 const void*                pNext;
01702                 VkImageViewCreateFlags     flags;
01703                 VkImage                    image;
01704                 VkImageViewType            viewType;
01705                 VkFormat                   format;
01706                 VkComponentMapping         components;
01707                 VkImageSubresourceRange    subresourceRange;
01708         } VkImageViewCreateInfo;
01709 
01710         typedef struct VkShaderModuleCreateInfo {
01711                 VkStructureType              sType;
01712                 const void*                  pNext;
01713                 VkShaderModuleCreateFlags    flags;
01714                 size_t                       codeSize;
01715                 const uint32_t*              pCode;
01716         } VkShaderModuleCreateInfo;
01717 
01718         typedef struct VkPipelineCacheCreateInfo {
01719                 VkStructureType               sType;
01720                 const void*                   pNext;
01721                 VkPipelineCacheCreateFlags    flags;
01722                 size_t                        initialDataSize;
01723                 const void*                   pInitialData;
01724         } VkPipelineCacheCreateInfo;
01725 
01726         typedef struct VkSpecializationMapEntry {
01727                 uint32_t    constantID;
01728                 uint32_t    offset;
01729                 size_t      size;
01730         } VkSpecializationMapEntry;
01731 
01732         typedef struct VkSpecializationInfo {
01733                 uint32_t                           mapEntryCount;
01734                 const VkSpecializationMapEntry*    pMapEntries;
01735                 size_t                             dataSize;
01736                 const void*                        pData;
01737         } VkSpecializationInfo;
01738 
01739         typedef struct VkPipelineShaderStageCreateInfo {
01740                 VkStructureType                     sType;
01741                 const void*                         pNext;
01742                 VkPipelineShaderStageCreateFlags    flags;
01743                 VkShaderStageFlagBits               stage;
01744                 VkShaderModule                      module;
01745                 const char*                         pName;
01746                 const VkSpecializationInfo*         pSpecializationInfo;
01747         } VkPipelineShaderStageCreateInfo;
01748 
01749         typedef struct VkVertexInputBindingDescription {
01750                 uint32_t             binding;
01751                 uint32_t             stride;
01752                 VkVertexInputRate    inputRate;
01753         } VkVertexInputBindingDescription;
01754 
01755         typedef struct VkVertexInputAttributeDescription {
01756                 uint32_t    location;
01757                 uint32_t    binding;
01758                 VkFormat    format;
01759                 uint32_t    offset;
01760         } VkVertexInputAttributeDescription;
01761 
01762         typedef struct VkPipelineVertexInputStateCreateInfo {
01763                 VkStructureType                             sType;
01764                 const void*                                 pNext;
01765                 VkPipelineVertexInputStateCreateFlags       flags;
01766                 uint32_t                                    vertexBindingDescriptionCount;
01767                 const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
01768                 uint32_t                                    vertexAttributeDescriptionCount;
01769                 const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
01770         } VkPipelineVertexInputStateCreateInfo;
01771 
01772         typedef struct VkPipelineInputAssemblyStateCreateInfo {
01773                 VkStructureType                            sType;
01774                 const void*                                pNext;
01775                 VkPipelineInputAssemblyStateCreateFlags    flags;
01776                 VkPrimitiveTopology                        topology;
01777                 VkBool32                                   primitiveRestartEnable;
01778         } VkPipelineInputAssemblyStateCreateInfo;
01779 
01780         typedef struct VkPipelineTessellationStateCreateInfo {
01781                 VkStructureType                           sType;
01782                 const void*                               pNext;
01783                 VkPipelineTessellationStateCreateFlags    flags;
01784                 uint32_t                                  patchControlPoints;
01785         } VkPipelineTessellationStateCreateInfo;
01786 
01787         typedef struct VkViewport {
01788                 float    x;
01789                 float    y;
01790                 float    width;
01791                 float    height;
01792                 float    minDepth;
01793                 float    maxDepth;
01794         } VkViewport;
01795 
01796         typedef struct VkOffset2D {
01797                 int32_t    x;
01798                 int32_t    y;
01799         } VkOffset2D;
01800 
01801         typedef struct VkExtent2D {
01802                 uint32_t    width;
01803                 uint32_t    height;
01804         } VkExtent2D;
01805 
01806         typedef struct VkRect2D {
01807                 VkOffset2D    offset;
01808                 VkExtent2D    extent;
01809         } VkRect2D;
01810 
01811         typedef struct VkPipelineViewportStateCreateInfo {
01812                 VkStructureType                       sType;
01813                 const void*                           pNext;
01814                 VkPipelineViewportStateCreateFlags    flags;
01815                 uint32_t                              viewportCount;
01816                 const VkViewport*                     pViewports;
01817                 uint32_t                              scissorCount;
01818                 const VkRect2D*                       pScissors;
01819         } VkPipelineViewportStateCreateInfo;
01820 
01821         typedef struct VkPipelineRasterizationStateCreateInfo {
01822                 VkStructureType                            sType;
01823                 const void*                                pNext;
01824                 VkPipelineRasterizationStateCreateFlags    flags;
01825                 VkBool32                                   depthClampEnable;
01826                 VkBool32                                   rasterizerDiscardEnable;
01827                 VkPolygonMode                              polygonMode;
01828                 VkCullModeFlags                            cullMode;
01829                 VkFrontFace                                frontFace;
01830                 VkBool32                                   depthBiasEnable;
01831                 float                                      depthBiasConstantFactor;
01832                 float                                      depthBiasClamp;
01833                 float                                      depthBiasSlopeFactor;
01834                 float                                      lineWidth;
01835         } VkPipelineRasterizationStateCreateInfo;
01836 
01837         typedef struct VkPipelineMultisampleStateCreateInfo {
01838                 VkStructureType                          sType;
01839                 const void*                              pNext;
01840                 VkPipelineMultisampleStateCreateFlags    flags;
01841                 VkSampleCountFlagBits                    rasterizationSamples;
01842                 VkBool32                                 sampleShadingEnable;
01843                 float                                    minSampleShading;
01844                 const VkSampleMask*                      pSampleMask;
01845                 VkBool32                                 alphaToCoverageEnable;
01846                 VkBool32                                 alphaToOneEnable;
01847         } VkPipelineMultisampleStateCreateInfo;
01848 
01849         typedef struct VkStencilOpState {
01850                 VkStencilOp    failOp;
01851                 VkStencilOp    passOp;
01852                 VkStencilOp    depthFailOp;
01853                 VkCompareOp    compareOp;
01854                 uint32_t       compareMask;
01855                 uint32_t       writeMask;
01856                 uint32_t       reference;
01857         } VkStencilOpState;
01858 
01859         typedef struct VkPipelineDepthStencilStateCreateInfo {
01860                 VkStructureType                           sType;
01861                 const void*                               pNext;
01862                 VkPipelineDepthStencilStateCreateFlags    flags;
01863                 VkBool32                                  depthTestEnable;
01864                 VkBool32                                  depthWriteEnable;
01865                 VkCompareOp                               depthCompareOp;
01866                 VkBool32                                  depthBoundsTestEnable;
01867                 VkBool32                                  stencilTestEnable;
01868                 VkStencilOpState                          front;
01869                 VkStencilOpState                          back;
01870                 float                                     minDepthBounds;
01871                 float                                     maxDepthBounds;
01872         } VkPipelineDepthStencilStateCreateInfo;
01873 
01874         typedef struct VkPipelineColorBlendAttachmentState {
01875                 VkBool32                 blendEnable;
01876                 VkBlendFactor            srcColorBlendFactor;
01877                 VkBlendFactor            dstColorBlendFactor;
01878                 VkBlendOp                colorBlendOp;
01879                 VkBlendFactor            srcAlphaBlendFactor;
01880                 VkBlendFactor            dstAlphaBlendFactor;
01881                 VkBlendOp                alphaBlendOp;
01882                 VkColorComponentFlags    colorWriteMask;
01883         } VkPipelineColorBlendAttachmentState;
01884 
01885         typedef struct VkPipelineColorBlendStateCreateInfo {
01886                 VkStructureType                               sType;
01887                 const void*                                   pNext;
01888                 VkPipelineColorBlendStateCreateFlags          flags;
01889                 VkBool32                                      logicOpEnable;
01890                 VkLogicOp                                     logicOp;
01891                 uint32_t                                      attachmentCount;
01892                 const VkPipelineColorBlendAttachmentState*    pAttachments;
01893                 float                                         blendConstants[4];
01894         } VkPipelineColorBlendStateCreateInfo;
01895 
01896         typedef struct VkPipelineDynamicStateCreateInfo {
01897                 VkStructureType                      sType;
01898                 const void*                          pNext;
01899                 VkPipelineDynamicStateCreateFlags    flags;
01900                 uint32_t                             dynamicStateCount;
01901                 const VkDynamicState*                pDynamicStates;
01902         } VkPipelineDynamicStateCreateInfo;
01903 
01904         typedef struct VkGraphicsPipelineCreateInfo {
01905                 VkStructureType                                  sType;
01906                 const void*                                      pNext;
01907                 VkPipelineCreateFlags                            flags;
01908                 uint32_t                                         stageCount;
01909                 const VkPipelineShaderStageCreateInfo*           pStages;
01910                 const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
01911                 const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
01912                 const VkPipelineTessellationStateCreateInfo*     pTessellationState;
01913                 const VkPipelineViewportStateCreateInfo*         pViewportState;
01914                 const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
01915                 const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
01916                 const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
01917                 const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
01918                 const VkPipelineDynamicStateCreateInfo*          pDynamicState;
01919                 VkPipelineLayout                                 layout;
01920                 VkRenderPass                                     renderPass;
01921                 uint32_t                                         subpass;
01922                 VkPipeline                                       basePipelineHandle;
01923                 int32_t                                          basePipelineIndex;
01924         } VkGraphicsPipelineCreateInfo;
01925 
01926         typedef struct VkComputePipelineCreateInfo {
01927                 VkStructureType                    sType;
01928                 const void*                        pNext;
01929                 VkPipelineCreateFlags              flags;
01930                 VkPipelineShaderStageCreateInfo    stage;
01931                 VkPipelineLayout                   layout;
01932                 VkPipeline                         basePipelineHandle;
01933                 int32_t                            basePipelineIndex;
01934         } VkComputePipelineCreateInfo;
01935 
01936         typedef struct VkPushConstantRange {
01937                 VkShaderStageFlags    stageFlags;
01938                 uint32_t              offset;
01939                 uint32_t              size;
01940         } VkPushConstantRange;
01941 
01942         typedef struct VkPipelineLayoutCreateInfo {
01943                 VkStructureType                 sType;
01944                 const void*                     pNext;
01945                 VkPipelineLayoutCreateFlags     flags;
01946                 uint32_t                        setLayoutCount;
01947                 const VkDescriptorSetLayout*    pSetLayouts;
01948                 uint32_t                        pushConstantRangeCount;
01949                 const VkPushConstantRange*      pPushConstantRanges;
01950         } VkPipelineLayoutCreateInfo;
01951 
01952         typedef struct VkSamplerCreateInfo {
01953                 VkStructureType         sType;
01954                 const void*             pNext;
01955                 VkSamplerCreateFlags    flags;
01956                 VkFilter                magFilter;
01957                 VkFilter                minFilter;
01958                 VkSamplerMipmapMode     mipmapMode;
01959                 VkSamplerAddressMode    addressModeU;
01960                 VkSamplerAddressMode    addressModeV;
01961                 VkSamplerAddressMode    addressModeW;
01962                 float                   mipLodBias;
01963                 VkBool32                anisotropyEnable;
01964                 float                   maxAnisotropy;
01965                 VkBool32                compareEnable;
01966                 VkCompareOp             compareOp;
01967                 float                   minLod;
01968                 float                   maxLod;
01969                 VkBorderColor           borderColor;
01970                 VkBool32                unnormalizedCoordinates;
01971         } VkSamplerCreateInfo;
01972 
01973         typedef struct VkDescriptorSetLayoutBinding {
01974                 uint32_t              binding;
01975                 VkDescriptorType      descriptorType;
01976                 uint32_t              descriptorCount;
01977                 VkShaderStageFlags    stageFlags;
01978                 const VkSampler*      pImmutableSamplers;
01979         } VkDescriptorSetLayoutBinding;
01980 
01981         typedef struct VkDescriptorSetLayoutCreateInfo {
01982                 VkStructureType                        sType;
01983                 const void*                            pNext;
01984                 VkDescriptorSetLayoutCreateFlags       flags;
01985                 uint32_t                               bindingCount;
01986                 const VkDescriptorSetLayoutBinding*    pBindings;
01987         } VkDescriptorSetLayoutCreateInfo;
01988 
01989         typedef struct VkDescriptorPoolSize {
01990                 VkDescriptorType    type;
01991                 uint32_t            descriptorCount;
01992         } VkDescriptorPoolSize;
01993 
01994         typedef struct VkDescriptorPoolCreateInfo {
01995                 VkStructureType                sType;
01996                 const void*                    pNext;
01997                 VkDescriptorPoolCreateFlags    flags;
01998                 uint32_t                       maxSets;
01999                 uint32_t                       poolSizeCount;
02000                 const VkDescriptorPoolSize*    pPoolSizes;
02001         } VkDescriptorPoolCreateInfo;
02002 
02003         typedef struct VkDescriptorSetAllocateInfo {
02004                 VkStructureType                 sType;
02005                 const void*                     pNext;
02006                 VkDescriptorPool                descriptorPool;
02007                 uint32_t                        descriptorSetCount;
02008                 const VkDescriptorSetLayout*    pSetLayouts;
02009         } VkDescriptorSetAllocateInfo;
02010 
02011         typedef struct VkDescriptorImageInfo {
02012                 VkSampler        sampler;
02013                 VkImageView      imageView;
02014                 VkImageLayout    imageLayout;
02015         } VkDescriptorImageInfo;
02016 
02017         typedef struct VkDescriptorBufferInfo {
02018                 VkBuffer        buffer;
02019                 VkDeviceSize    offset;
02020                 VkDeviceSize    range;
02021         } VkDescriptorBufferInfo;
02022 
02023         typedef struct VkWriteDescriptorSet {
02024                 VkStructureType                  sType;
02025                 const void*                      pNext;
02026                 VkDescriptorSet                  dstSet;
02027                 uint32_t                         dstBinding;
02028                 uint32_t                         dstArrayElement;
02029                 uint32_t                         descriptorCount;
02030                 VkDescriptorType                 descriptorType;
02031                 const VkDescriptorImageInfo*     pImageInfo;
02032                 const VkDescriptorBufferInfo*    pBufferInfo;
02033                 const VkBufferView*              pTexelBufferView;
02034         } VkWriteDescriptorSet;
02035 
02036         typedef struct VkCopyDescriptorSet {
02037                 VkStructureType    sType;
02038                 const void*        pNext;
02039                 VkDescriptorSet    srcSet;
02040                 uint32_t           srcBinding;
02041                 uint32_t           srcArrayElement;
02042                 VkDescriptorSet    dstSet;
02043                 uint32_t           dstBinding;
02044                 uint32_t           dstArrayElement;
02045                 uint32_t           descriptorCount;
02046         } VkCopyDescriptorSet;
02047 
02048         typedef struct VkFramebufferCreateInfo {
02049                 VkStructureType             sType;
02050                 const void*                 pNext;
02051                 VkFramebufferCreateFlags    flags;
02052                 VkRenderPass                renderPass;
02053                 uint32_t                    attachmentCount;
02054                 const VkImageView*          pAttachments;
02055                 uint32_t                    width;
02056                 uint32_t                    height;
02057                 uint32_t                    layers;
02058         } VkFramebufferCreateInfo;
02059 
02060         typedef struct VkAttachmentDescription {
02061                 VkAttachmentDescriptionFlags    flags;
02062                 VkFormat                        format;
02063                 VkSampleCountFlagBits           samples;
02064                 VkAttachmentLoadOp              loadOp;
02065                 VkAttachmentStoreOp             storeOp;
02066                 VkAttachmentLoadOp              stencilLoadOp;
02067                 VkAttachmentStoreOp             stencilStoreOp;
02068                 VkImageLayout                   initialLayout;
02069                 VkImageLayout                   finalLayout;
02070         } VkAttachmentDescription;
02071 
02072         typedef struct VkAttachmentReference {
02073                 uint32_t         attachment;
02074                 VkImageLayout    layout;
02075         } VkAttachmentReference;
02076 
02077         typedef struct VkSubpassDescription {
02078                 VkSubpassDescriptionFlags       flags;
02079                 VkPipelineBindPoint             pipelineBindPoint;
02080                 uint32_t                        inputAttachmentCount;
02081                 const VkAttachmentReference*    pInputAttachments;
02082                 uint32_t                        colorAttachmentCount;
02083                 const VkAttachmentReference*    pColorAttachments;
02084                 const VkAttachmentReference*    pResolveAttachments;
02085                 const VkAttachmentReference*    pDepthStencilAttachment;
02086                 uint32_t                        preserveAttachmentCount;
02087                 const uint32_t*                 pPreserveAttachments;
02088         } VkSubpassDescription;
02089 
02090         typedef struct VkSubpassDependency {
02091                 uint32_t                srcSubpass;
02092                 uint32_t                dstSubpass;
02093                 VkPipelineStageFlags    srcStageMask;
02094                 VkPipelineStageFlags    dstStageMask;
02095                 VkAccessFlags           srcAccessMask;
02096                 VkAccessFlags           dstAccessMask;
02097                 VkDependencyFlags       dependencyFlags;
02098         } VkSubpassDependency;
02099 
02100         typedef struct VkRenderPassCreateInfo {
02101                 VkStructureType                   sType;
02102                 const void*                       pNext;
02103                 VkRenderPassCreateFlags           flags;
02104                 uint32_t                          attachmentCount;
02105                 const VkAttachmentDescription*    pAttachments;
02106                 uint32_t                          subpassCount;
02107                 const VkSubpassDescription*       pSubpasses;
02108                 uint32_t                          dependencyCount;
02109                 const VkSubpassDependency*        pDependencies;
02110         } VkRenderPassCreateInfo;
02111 
02112         typedef struct VkCommandPoolCreateInfo {
02113                 VkStructureType             sType;
02114                 const void*                 pNext;
02115                 VkCommandPoolCreateFlags    flags;
02116                 uint32_t                    queueFamilyIndex;
02117         } VkCommandPoolCreateInfo;
02118 
02119         typedef struct VkCommandBufferAllocateInfo {
02120                 VkStructureType         sType;
02121                 const void*             pNext;
02122                 VkCommandPool           commandPool;
02123                 VkCommandBufferLevel    level;
02124                 uint32_t                commandBufferCount;
02125         } VkCommandBufferAllocateInfo;
02126 
02127         typedef struct VkCommandBufferInheritanceInfo {
02128                 VkStructureType                  sType;
02129                 const void*                      pNext;
02130                 VkRenderPass                     renderPass;
02131                 uint32_t                         subpass;
02132                 VkFramebuffer                    framebuffer;
02133                 VkBool32                         occlusionQueryEnable;
02134                 VkQueryControlFlags              queryFlags;
02135                 VkQueryPipelineStatisticFlags    pipelineStatistics;
02136         } VkCommandBufferInheritanceInfo;
02137 
02138         typedef struct VkCommandBufferBeginInfo {
02139                 VkStructureType                          sType;
02140                 const void*                              pNext;
02141                 VkCommandBufferUsageFlags                flags;
02142                 const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
02143         } VkCommandBufferBeginInfo;
02144 
02145         typedef struct VkBufferCopy {
02146                 VkDeviceSize    srcOffset;
02147                 VkDeviceSize    dstOffset;
02148                 VkDeviceSize    size;
02149         } VkBufferCopy;
02150 
02151         typedef struct VkImageSubresourceLayers {
02152                 VkImageAspectFlags    aspectMask;
02153                 uint32_t              mipLevel;
02154                 uint32_t              baseArrayLayer;
02155                 uint32_t              layerCount;
02156         } VkImageSubresourceLayers;
02157 
02158         typedef struct VkImageCopy {
02159                 VkImageSubresourceLayers    srcSubresource;
02160                 VkOffset3D                  srcOffset;
02161                 VkImageSubresourceLayers    dstSubresource;
02162                 VkOffset3D                  dstOffset;
02163                 VkExtent3D                  extent;
02164         } VkImageCopy;
02165 
02166         typedef struct VkImageBlit {
02167                 VkImageSubresourceLayers    srcSubresource;
02168                 VkOffset3D                  srcOffsets[2];
02169                 VkImageSubresourceLayers    dstSubresource;
02170                 VkOffset3D                  dstOffsets[2];
02171         } VkImageBlit;
02172 
02173         typedef struct VkBufferImageCopy {
02174                 VkDeviceSize                bufferOffset;
02175                 uint32_t                    bufferRowLength;
02176                 uint32_t                    bufferImageHeight;
02177                 VkImageSubresourceLayers    imageSubresource;
02178                 VkOffset3D                  imageOffset;
02179                 VkExtent3D                  imageExtent;
02180         } VkBufferImageCopy;
02181 
02182         typedef union VkClearColorValue {
02183                 float       float32[4];
02184                 int32_t     int32[4];
02185                 uint32_t    uint32[4];
02186         } VkClearColorValue;
02187 
02188         typedef struct VkClearDepthStencilValue {
02189                 float       depth;
02190                 uint32_t    stencil;
02191         } VkClearDepthStencilValue;
02192 
02193         typedef union VkClearValue {
02194                 VkClearColorValue           color;
02195                 VkClearDepthStencilValue    depthStencil;
02196         } VkClearValue;
02197 
02198         typedef struct VkClearAttachment {
02199                 VkImageAspectFlags    aspectMask;
02200                 uint32_t              colorAttachment;
02201                 VkClearValue          clearValue;
02202         } VkClearAttachment;
02203 
02204         typedef struct VkClearRect {
02205                 VkRect2D    rect;
02206                 uint32_t    baseArrayLayer;
02207                 uint32_t    layerCount;
02208         } VkClearRect;
02209 
02210         typedef struct VkImageResolve {
02211                 VkImageSubresourceLayers    srcSubresource;
02212                 VkOffset3D                  srcOffset;
02213                 VkImageSubresourceLayers    dstSubresource;
02214                 VkOffset3D                  dstOffset;
02215                 VkExtent3D                  extent;
02216         } VkImageResolve;
02217 
02218         typedef struct VkMemoryBarrier {
02219                 VkStructureType    sType;
02220                 const void*        pNext;
02221                 VkAccessFlags      srcAccessMask;
02222                 VkAccessFlags      dstAccessMask;
02223         } VkMemoryBarrier;
02224 
02225         typedef struct VkBufferMemoryBarrier {
02226                 VkStructureType    sType;
02227                 const void*        pNext;
02228                 VkAccessFlags      srcAccessMask;
02229                 VkAccessFlags      dstAccessMask;
02230                 uint32_t           srcQueueFamilyIndex;
02231                 uint32_t           dstQueueFamilyIndex;
02232                 VkBuffer           buffer;
02233                 VkDeviceSize       offset;
02234                 VkDeviceSize       size;
02235         } VkBufferMemoryBarrier;
02236 
02237         typedef struct VkImageMemoryBarrier {
02238                 VkStructureType            sType;
02239                 const void*                pNext;
02240                 VkAccessFlags              srcAccessMask;
02241                 VkAccessFlags              dstAccessMask;
02242                 VkImageLayout              oldLayout;
02243                 VkImageLayout              newLayout;
02244                 uint32_t                   srcQueueFamilyIndex;
02245                 uint32_t                   dstQueueFamilyIndex;
02246                 VkImage                    image;
02247                 VkImageSubresourceRange    subresourceRange;
02248         } VkImageMemoryBarrier;
02249 
02250         typedef struct VkRenderPassBeginInfo {
02251                 VkStructureType        sType;
02252                 const void*            pNext;
02253                 VkRenderPass           renderPass;
02254                 VkFramebuffer          framebuffer;
02255                 VkRect2D               renderArea;
02256                 uint32_t               clearValueCount;
02257                 const VkClearValue*    pClearValues;
02258         } VkRenderPassBeginInfo;
02259 
02260         typedef struct VkDispatchIndirectCommand {
02261                 uint32_t    x;
02262                 uint32_t    y;
02263                 uint32_t    z;
02264         } VkDispatchIndirectCommand;
02265 
02266         typedef struct VkDrawIndexedIndirectCommand {
02267                 uint32_t    indexCount;
02268                 uint32_t    instanceCount;
02269                 uint32_t    firstIndex;
02270                 int32_t     vertexOffset;
02271                 uint32_t    firstInstance;
02272         } VkDrawIndexedIndirectCommand;
02273 
02274         typedef struct VkDrawIndirectCommand {
02275                 uint32_t    vertexCount;
02276                 uint32_t    instanceCount;
02277                 uint32_t    firstVertex;
02278                 uint32_t    firstInstance;
02279         } VkDrawIndirectCommand;
02280 
02281 
02282         typedef VkResult(VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
02283         typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
02284         typedef VkResult(VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
02285         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
02286         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
02287         typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
02288         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
02289         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
02290         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
02291         typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
02292         typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
02293         typedef VkResult(VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
02294         typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
02295         typedef VkResult(VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
02296         typedef VkResult(VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
02297         typedef VkResult(VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
02298         typedef VkResult(VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
02299         typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
02300         typedef VkResult(VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
02301         typedef VkResult(VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
02302         typedef VkResult(VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
02303         typedef VkResult(VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
02304         typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
02305         typedef VkResult(VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
02306         typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
02307         typedef VkResult(VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
02308         typedef VkResult(VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
02309         typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
02310         typedef VkResult(VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
02311         typedef VkResult(VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
02312         typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
02313         typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
02314         typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
02315         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
02316         typedef VkResult(VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
02317         typedef VkResult(VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
02318         typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
02319         typedef VkResult(VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
02320         typedef VkResult(VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
02321         typedef VkResult(VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
02322         typedef VkResult(VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
02323         typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
02324         typedef VkResult(VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
02325         typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
02326         typedef VkResult(VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
02327         typedef VkResult(VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
02328         typedef VkResult(VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
02329         typedef VkResult(VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
02330         typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
02331         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);
02332         typedef VkResult(VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
02333         typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
02334         typedef VkResult(VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
02335         typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
02336         typedef VkResult(VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
02337         typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
02338         typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
02339         typedef VkResult(VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
02340         typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
02341         typedef VkResult(VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
02342         typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
02343         typedef VkResult(VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
02344         typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
02345         typedef VkResult(VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
02346         typedef VkResult(VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
02347         typedef VkResult(VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
02348         typedef VkResult(VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
02349         typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
02350         typedef VkResult(VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
02351         typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
02352         typedef VkResult(VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
02353         typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
02354         typedef VkResult(VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
02355         typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
02356         typedef VkResult(VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
02357         typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
02358         typedef VkResult(VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
02359         typedef VkResult(VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
02360         typedef VkResult(VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
02361         typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
02362         typedef VkResult(VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
02363         typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
02364         typedef VkResult(VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
02365         typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
02366         typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
02367         typedef VkResult(VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
02368         typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
02369         typedef VkResult(VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
02370         typedef VkResult(VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
02371         typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
02372         typedef VkResult(VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
02373         typedef VkResult(VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
02374         typedef VkResult(VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
02375         typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
02376         typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
02377         typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
02378         typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
02379         typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
02380         typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
02381         typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
02382         typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
02383         typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
02384         typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
02385         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);
02386         typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
02387         typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
02388         typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
02389         typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
02390         typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
02391         typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
02392         typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
02393         typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
02394         typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
02395         typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
02396         typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
02397         typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
02398         typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
02399         typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
02400         typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
02401         typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
02402         typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
02403         typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
02404         typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
02405         typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
02406         typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
02407         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);
02408         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);
02409         typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
02410         typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
02411         typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
02412         typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
02413         typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
02414         typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
02415         typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
02416         typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
02417         typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
02418         typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
02419 
02420 #ifndef VK_NO_PROTOTYPES
02421         VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
02422                 const VkInstanceCreateInfo*                 pCreateInfo,
02423                 const VkAllocationCallbacks*                pAllocator,
02424                 VkInstance*                                 pInstance);
02425 
02426         VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
02427                 VkInstance                                  instance,
02428                 const VkAllocationCallbacks*                pAllocator);
02429 
02430         VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
02431                 VkInstance                                  instance,
02432                 uint32_t*                                   pPhysicalDeviceCount,
02433                 VkPhysicalDevice*                           pPhysicalDevices);
02434 
02435         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
02436                 VkPhysicalDevice                            physicalDevice,
02437                 VkPhysicalDeviceFeatures*                   pFeatures);
02438 
02439         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
02440                 VkPhysicalDevice                            physicalDevice,
02441                 VkFormat                                    format,
02442                 VkFormatProperties*                         pFormatProperties);
02443 
02444         VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
02445                 VkPhysicalDevice                            physicalDevice,
02446                 VkFormat                                    format,
02447                 VkImageType                                 type,
02448                 VkImageTiling                               tiling,
02449                 VkImageUsageFlags                           usage,
02450                 VkImageCreateFlags                          flags,
02451                 VkImageFormatProperties*                    pImageFormatProperties);
02452 
02453         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
02454                 VkPhysicalDevice                            physicalDevice,
02455                 VkPhysicalDeviceProperties*                 pProperties);
02456 
02457         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
02458                 VkPhysicalDevice                            physicalDevice,
02459                 uint32_t*                                   pQueueFamilyPropertyCount,
02460                 VkQueueFamilyProperties*                    pQueueFamilyProperties);
02461 
02462         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
02463                 VkPhysicalDevice                            physicalDevice,
02464                 VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
02465 
02466         VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
02467                 VkInstance                                  instance,
02468                 const char*                                 pName);
02469 
02470         VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
02471                 VkDevice                                    device,
02472                 const char*                                 pName);
02473 
02474         VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
02475                 VkPhysicalDevice                            physicalDevice,
02476                 const VkDeviceCreateInfo*                   pCreateInfo,
02477                 const VkAllocationCallbacks*                pAllocator,
02478                 VkDevice*                                   pDevice);
02479 
02480         VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
02481                 VkDevice                                    device,
02482                 const VkAllocationCallbacks*                pAllocator);
02483 
02484         VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
02485                 const char*                                 pLayerName,
02486                 uint32_t*                                   pPropertyCount,
02487                 VkExtensionProperties*                      pProperties);
02488 
02489         VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
02490                 VkPhysicalDevice                            physicalDevice,
02491                 const char*                                 pLayerName,
02492                 uint32_t*                                   pPropertyCount,
02493                 VkExtensionProperties*                      pProperties);
02494 
02495         VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
02496                 uint32_t*                                   pPropertyCount,
02497                 VkLayerProperties*                          pProperties);
02498 
02499         VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
02500                 VkPhysicalDevice                            physicalDevice,
02501                 uint32_t*                                   pPropertyCount,
02502                 VkLayerProperties*                          pProperties);
02503 
02504         VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
02505                 VkDevice                                    device,
02506                 uint32_t                                    queueFamilyIndex,
02507                 uint32_t                                    queueIndex,
02508                 VkQueue*                                    pQueue);
02509 
02510         VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
02511                 VkQueue                                     queue,
02512                 uint32_t                                    submitCount,
02513                 const VkSubmitInfo*                         pSubmits,
02514                 VkFence                                     fence);
02515 
02516         VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
02517                 VkQueue                                     queue);
02518 
02519         VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
02520                 VkDevice                                    device);
02521 
02522         VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
02523                 VkDevice                                    device,
02524                 const VkMemoryAllocateInfo*                 pAllocateInfo,
02525                 const VkAllocationCallbacks*                pAllocator,
02526                 VkDeviceMemory*                             pMemory);
02527 
02528         VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
02529                 VkDevice                                    device,
02530                 VkDeviceMemory                              memory,
02531                 const VkAllocationCallbacks*                pAllocator);
02532 
02533         VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
02534                 VkDevice                                    device,
02535                 VkDeviceMemory                              memory,
02536                 VkDeviceSize                                offset,
02537                 VkDeviceSize                                size,
02538                 VkMemoryMapFlags                            flags,
02539                 void**                                      ppData);
02540 
02541         VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
02542                 VkDevice                                    device,
02543                 VkDeviceMemory                              memory);
02544 
02545         VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
02546                 VkDevice                                    device,
02547                 uint32_t                                    memoryRangeCount,
02548                 const VkMappedMemoryRange*                  pMemoryRanges);
02549 
02550         VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
02551                 VkDevice                                    device,
02552                 uint32_t                                    memoryRangeCount,
02553                 const VkMappedMemoryRange*                  pMemoryRanges);
02554 
02555         VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
02556                 VkDevice                                    device,
02557                 VkDeviceMemory                              memory,
02558                 VkDeviceSize*                               pCommittedMemoryInBytes);
02559 
02560         VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
02561                 VkDevice                                    device,
02562                 VkBuffer                                    buffer,
02563                 VkDeviceMemory                              memory,
02564                 VkDeviceSize                                memoryOffset);
02565 
02566         VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
02567                 VkDevice                                    device,
02568                 VkImage                                     image,
02569                 VkDeviceMemory                              memory,
02570                 VkDeviceSize                                memoryOffset);
02571 
02572         VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
02573                 VkDevice                                    device,
02574                 VkBuffer                                    buffer,
02575                 VkMemoryRequirements*                       pMemoryRequirements);
02576 
02577         VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
02578                 VkDevice                                    device,
02579                 VkImage                                     image,
02580                 VkMemoryRequirements*                       pMemoryRequirements);
02581 
02582         VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
02583                 VkDevice                                    device,
02584                 VkImage                                     image,
02585                 uint32_t*                                   pSparseMemoryRequirementCount,
02586                 VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
02587 
02588         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
02589                 VkPhysicalDevice                            physicalDevice,
02590                 VkFormat                                    format,
02591                 VkImageType                                 type,
02592                 VkSampleCountFlagBits                       samples,
02593                 VkImageUsageFlags                           usage,
02594                 VkImageTiling                               tiling,
02595                 uint32_t*                                   pPropertyCount,
02596                 VkSparseImageFormatProperties*              pProperties);
02597 
02598         VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
02599                 VkQueue                                     queue,
02600                 uint32_t                                    bindInfoCount,
02601                 const VkBindSparseInfo*                     pBindInfo,
02602                 VkFence                                     fence);
02603 
02604         VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
02605                 VkDevice                                    device,
02606                 const VkFenceCreateInfo*                    pCreateInfo,
02607                 const VkAllocationCallbacks*                pAllocator,
02608                 VkFence*                                    pFence);
02609 
02610         VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
02611                 VkDevice                                    device,
02612                 VkFence                                     fence,
02613                 const VkAllocationCallbacks*                pAllocator);
02614 
02615         VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
02616                 VkDevice                                    device,
02617                 uint32_t                                    fenceCount,
02618                 const VkFence*                              pFences);
02619 
02620         VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
02621                 VkDevice                                    device,
02622                 VkFence                                     fence);
02623 
02624         VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
02625                 VkDevice                                    device,
02626                 uint32_t                                    fenceCount,
02627                 const VkFence*                              pFences,
02628                 VkBool32                                    waitAll,
02629                 uint64_t                                    timeout);
02630 
02631         VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
02632                 VkDevice                                    device,
02633                 const VkSemaphoreCreateInfo*                pCreateInfo,
02634                 const VkAllocationCallbacks*                pAllocator,
02635                 VkSemaphore*                                pSemaphore);
02636 
02637         VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
02638                 VkDevice                                    device,
02639                 VkSemaphore                                 semaphore,
02640                 const VkAllocationCallbacks*                pAllocator);
02641 
02642         VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
02643                 VkDevice                                    device,
02644                 const VkEventCreateInfo*                    pCreateInfo,
02645                 const VkAllocationCallbacks*                pAllocator,
02646                 VkEvent*                                    pEvent);
02647 
02648         VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
02649                 VkDevice                                    device,
02650                 VkEvent                                     event,
02651                 const VkAllocationCallbacks*                pAllocator);
02652 
02653         VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
02654                 VkDevice                                    device,
02655                 VkEvent                                     event);
02656 
02657         VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
02658                 VkDevice                                    device,
02659                 VkEvent                                     event);
02660 
02661         VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
02662                 VkDevice                                    device,
02663                 VkEvent                                     event);
02664 
02665         VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
02666                 VkDevice                                    device,
02667                 const VkQueryPoolCreateInfo*                pCreateInfo,
02668                 const VkAllocationCallbacks*                pAllocator,
02669                 VkQueryPool*                                pQueryPool);
02670 
02671         VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
02672                 VkDevice                                    device,
02673                 VkQueryPool                                 queryPool,
02674                 const VkAllocationCallbacks*                pAllocator);
02675 
02676         VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
02677                 VkDevice                                    device,
02678                 VkQueryPool                                 queryPool,
02679                 uint32_t                                    firstQuery,
02680                 uint32_t                                    queryCount,
02681                 size_t                                      dataSize,
02682                 void*                                       pData,
02683                 VkDeviceSize                                stride,
02684                 VkQueryResultFlags                          flags);
02685 
02686         VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
02687                 VkDevice                                    device,
02688                 const VkBufferCreateInfo*                   pCreateInfo,
02689                 const VkAllocationCallbacks*                pAllocator,
02690                 VkBuffer*                                   pBuffer);
02691 
02692         VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
02693                 VkDevice                                    device,
02694                 VkBuffer                                    buffer,
02695                 const VkAllocationCallbacks*                pAllocator);
02696 
02697         VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
02698                 VkDevice                                    device,
02699                 const VkBufferViewCreateInfo*               pCreateInfo,
02700                 const VkAllocationCallbacks*                pAllocator,
02701                 VkBufferView*                               pView);
02702 
02703         VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
02704                 VkDevice                                    device,
02705                 VkBufferView                                bufferView,
02706                 const VkAllocationCallbacks*                pAllocator);
02707 
02708         VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
02709                 VkDevice                                    device,
02710                 const VkImageCreateInfo*                    pCreateInfo,
02711                 const VkAllocationCallbacks*                pAllocator,
02712                 VkImage*                                    pImage);
02713 
02714         VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
02715                 VkDevice                                    device,
02716                 VkImage                                     image,
02717                 const VkAllocationCallbacks*                pAllocator);
02718 
02719         VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
02720                 VkDevice                                    device,
02721                 VkImage                                     image,
02722                 const VkImageSubresource*                   pSubresource,
02723                 VkSubresourceLayout*                        pLayout);
02724 
02725         VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
02726                 VkDevice                                    device,
02727                 const VkImageViewCreateInfo*                pCreateInfo,
02728                 const VkAllocationCallbacks*                pAllocator,
02729                 VkImageView*                                pView);
02730 
02731         VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
02732                 VkDevice                                    device,
02733                 VkImageView                                 imageView,
02734                 const VkAllocationCallbacks*                pAllocator);
02735 
02736         VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
02737                 VkDevice                                    device,
02738                 const VkShaderModuleCreateInfo*             pCreateInfo,
02739                 const VkAllocationCallbacks*                pAllocator,
02740                 VkShaderModule*                             pShaderModule);
02741 
02742         VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
02743                 VkDevice                                    device,
02744                 VkShaderModule                              shaderModule,
02745                 const VkAllocationCallbacks*                pAllocator);
02746 
02747         VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
02748                 VkDevice                                    device,
02749                 const VkPipelineCacheCreateInfo*            pCreateInfo,
02750                 const VkAllocationCallbacks*                pAllocator,
02751                 VkPipelineCache*                            pPipelineCache);
02752 
02753         VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
02754                 VkDevice                                    device,
02755                 VkPipelineCache                             pipelineCache,
02756                 const VkAllocationCallbacks*                pAllocator);
02757 
02758         VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
02759                 VkDevice                                    device,
02760                 VkPipelineCache                             pipelineCache,
02761                 size_t*                                     pDataSize,
02762                 void*                                       pData);
02763 
02764         VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
02765                 VkDevice                                    device,
02766                 VkPipelineCache                             dstCache,
02767                 uint32_t                                    srcCacheCount,
02768                 const VkPipelineCache*                      pSrcCaches);
02769 
02770         VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
02771                 VkDevice                                    device,
02772                 VkPipelineCache                             pipelineCache,
02773                 uint32_t                                    createInfoCount,
02774                 const VkGraphicsPipelineCreateInfo*         pCreateInfos,
02775                 const VkAllocationCallbacks*                pAllocator,
02776                 VkPipeline*                                 pPipelines);
02777 
02778         VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
02779                 VkDevice                                    device,
02780                 VkPipelineCache                             pipelineCache,
02781                 uint32_t                                    createInfoCount,
02782                 const VkComputePipelineCreateInfo*          pCreateInfos,
02783                 const VkAllocationCallbacks*                pAllocator,
02784                 VkPipeline*                                 pPipelines);
02785 
02786         VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
02787                 VkDevice                                    device,
02788                 VkPipeline                                  pipeline,
02789                 const VkAllocationCallbacks*                pAllocator);
02790 
02791         VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
02792                 VkDevice                                    device,
02793                 const VkPipelineLayoutCreateInfo*           pCreateInfo,
02794                 const VkAllocationCallbacks*                pAllocator,
02795                 VkPipelineLayout*                           pPipelineLayout);
02796 
02797         VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
02798                 VkDevice                                    device,
02799                 VkPipelineLayout                            pipelineLayout,
02800                 const VkAllocationCallbacks*                pAllocator);
02801 
02802         VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
02803                 VkDevice                                    device,
02804                 const VkSamplerCreateInfo*                  pCreateInfo,
02805                 const VkAllocationCallbacks*                pAllocator,
02806                 VkSampler*                                  pSampler);
02807 
02808         VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
02809                 VkDevice                                    device,
02810                 VkSampler                                   sampler,
02811                 const VkAllocationCallbacks*                pAllocator);
02812 
02813         VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
02814                 VkDevice                                    device,
02815                 const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
02816                 const VkAllocationCallbacks*                pAllocator,
02817                 VkDescriptorSetLayout*                      pSetLayout);
02818 
02819         VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
02820                 VkDevice                                    device,
02821                 VkDescriptorSetLayout                       descriptorSetLayout,
02822                 const VkAllocationCallbacks*                pAllocator);
02823 
02824         VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
02825                 VkDevice                                    device,
02826                 const VkDescriptorPoolCreateInfo*           pCreateInfo,
02827                 const VkAllocationCallbacks*                pAllocator,
02828                 VkDescriptorPool*                           pDescriptorPool);
02829 
02830         VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
02831                 VkDevice                                    device,
02832                 VkDescriptorPool                            descriptorPool,
02833                 const VkAllocationCallbacks*                pAllocator);
02834 
02835         VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
02836                 VkDevice                                    device,
02837                 VkDescriptorPool                            descriptorPool,
02838                 VkDescriptorPoolResetFlags                  flags);
02839 
02840         VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
02841                 VkDevice                                    device,
02842                 const VkDescriptorSetAllocateInfo*          pAllocateInfo,
02843                 VkDescriptorSet*                            pDescriptorSets);
02844 
02845         VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
02846                 VkDevice                                    device,
02847                 VkDescriptorPool                            descriptorPool,
02848                 uint32_t                                    descriptorSetCount,
02849                 const VkDescriptorSet*                      pDescriptorSets);
02850 
02851         VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
02852                 VkDevice                                    device,
02853                 uint32_t                                    descriptorWriteCount,
02854                 const VkWriteDescriptorSet*                 pDescriptorWrites,
02855                 uint32_t                                    descriptorCopyCount,
02856                 const VkCopyDescriptorSet*                  pDescriptorCopies);
02857 
02858         VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
02859                 VkDevice                                    device,
02860                 const VkFramebufferCreateInfo*              pCreateInfo,
02861                 const VkAllocationCallbacks*                pAllocator,
02862                 VkFramebuffer*                              pFramebuffer);
02863 
02864         VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
02865                 VkDevice                                    device,
02866                 VkFramebuffer                               framebuffer,
02867                 const VkAllocationCallbacks*                pAllocator);
02868 
02869         VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
02870                 VkDevice                                    device,
02871                 const VkRenderPassCreateInfo*               pCreateInfo,
02872                 const VkAllocationCallbacks*                pAllocator,
02873                 VkRenderPass*                               pRenderPass);
02874 
02875         VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
02876                 VkDevice                                    device,
02877                 VkRenderPass                                renderPass,
02878                 const VkAllocationCallbacks*                pAllocator);
02879 
02880         VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
02881                 VkDevice                                    device,
02882                 VkRenderPass                                renderPass,
02883                 VkExtent2D*                                 pGranularity);
02884 
02885         VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
02886                 VkDevice                                    device,
02887                 const VkCommandPoolCreateInfo*              pCreateInfo,
02888                 const VkAllocationCallbacks*                pAllocator,
02889                 VkCommandPool*                              pCommandPool);
02890 
02891         VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
02892                 VkDevice                                    device,
02893                 VkCommandPool                               commandPool,
02894                 const VkAllocationCallbacks*                pAllocator);
02895 
02896         VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
02897                 VkDevice                                    device,
02898                 VkCommandPool                               commandPool,
02899                 VkCommandPoolResetFlags                     flags);
02900 
02901         VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
02902                 VkDevice                                    device,
02903                 const VkCommandBufferAllocateInfo*          pAllocateInfo,
02904                 VkCommandBuffer*                            pCommandBuffers);
02905 
02906         VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
02907                 VkDevice                                    device,
02908                 VkCommandPool                               commandPool,
02909                 uint32_t                                    commandBufferCount,
02910                 const VkCommandBuffer*                      pCommandBuffers);
02911 
02912         VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
02913                 VkCommandBuffer                             commandBuffer,
02914                 const VkCommandBufferBeginInfo*             pBeginInfo);
02915 
02916         VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
02917                 VkCommandBuffer                             commandBuffer);
02918 
02919         VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
02920                 VkCommandBuffer                             commandBuffer,
02921                 VkCommandBufferResetFlags                   flags);
02922 
02923         VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
02924                 VkCommandBuffer                             commandBuffer,
02925                 VkPipelineBindPoint                         pipelineBindPoint,
02926                 VkPipeline                                  pipeline);
02927 
02928         VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
02929                 VkCommandBuffer                             commandBuffer,
02930                 uint32_t                                    firstViewport,
02931                 uint32_t                                    viewportCount,
02932                 const VkViewport*                           pViewports);
02933 
02934         VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
02935                 VkCommandBuffer                             commandBuffer,
02936                 uint32_t                                    firstScissor,
02937                 uint32_t                                    scissorCount,
02938                 const VkRect2D*                             pScissors);
02939 
02940         VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
02941                 VkCommandBuffer                             commandBuffer,
02942                 float                                       lineWidth);
02943 
02944         VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
02945                 VkCommandBuffer                             commandBuffer,
02946                 float                                       depthBiasConstantFactor,
02947                 float                                       depthBiasClamp,
02948                 float                                       depthBiasSlopeFactor);
02949 
02950         VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
02951                 VkCommandBuffer                             commandBuffer,
02952                 const float                                 blendConstants[4]);
02953 
02954         VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
02955                 VkCommandBuffer                             commandBuffer,
02956                 float                                       minDepthBounds,
02957                 float                                       maxDepthBounds);
02958 
02959         VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
02960                 VkCommandBuffer                             commandBuffer,
02961                 VkStencilFaceFlags                          faceMask,
02962                 uint32_t                                    compareMask);
02963 
02964         VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
02965                 VkCommandBuffer                             commandBuffer,
02966                 VkStencilFaceFlags                          faceMask,
02967                 uint32_t                                    writeMask);
02968 
02969         VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
02970                 VkCommandBuffer                             commandBuffer,
02971                 VkStencilFaceFlags                          faceMask,
02972                 uint32_t                                    reference);
02973 
02974         VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
02975                 VkCommandBuffer                             commandBuffer,
02976                 VkPipelineBindPoint                         pipelineBindPoint,
02977                 VkPipelineLayout                            layout,
02978                 uint32_t                                    firstSet,
02979                 uint32_t                                    descriptorSetCount,
02980                 const VkDescriptorSet*                      pDescriptorSets,
02981                 uint32_t                                    dynamicOffsetCount,
02982                 const uint32_t*                             pDynamicOffsets);
02983 
02984         VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
02985                 VkCommandBuffer                             commandBuffer,
02986                 VkBuffer                                    buffer,
02987                 VkDeviceSize                                offset,
02988                 VkIndexType                                 indexType);
02989 
02990         VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
02991                 VkCommandBuffer                             commandBuffer,
02992                 uint32_t                                    firstBinding,
02993                 uint32_t                                    bindingCount,
02994                 const VkBuffer*                             pBuffers,
02995                 const VkDeviceSize*                         pOffsets);
02996 
02997         VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
02998                 VkCommandBuffer                             commandBuffer,
02999                 uint32_t                                    vertexCount,
03000                 uint32_t                                    instanceCount,
03001                 uint32_t                                    firstVertex,
03002                 uint32_t                                    firstInstance);
03003 
03004         VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
03005                 VkCommandBuffer                             commandBuffer,
03006                 uint32_t                                    indexCount,
03007                 uint32_t                                    instanceCount,
03008                 uint32_t                                    firstIndex,
03009                 int32_t                                     vertexOffset,
03010                 uint32_t                                    firstInstance);
03011 
03012         VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
03013                 VkCommandBuffer                             commandBuffer,
03014                 VkBuffer                                    buffer,
03015                 VkDeviceSize                                offset,
03016                 uint32_t                                    drawCount,
03017                 uint32_t                                    stride);
03018 
03019         VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
03020                 VkCommandBuffer                             commandBuffer,
03021                 VkBuffer                                    buffer,
03022                 VkDeviceSize                                offset,
03023                 uint32_t                                    drawCount,
03024                 uint32_t                                    stride);
03025 
03026         VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
03027                 VkCommandBuffer                             commandBuffer,
03028                 uint32_t                                    x,
03029                 uint32_t                                    y,
03030                 uint32_t                                    z);
03031 
03032         VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
03033                 VkCommandBuffer                             commandBuffer,
03034                 VkBuffer                                    buffer,
03035                 VkDeviceSize                                offset);
03036 
03037         VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
03038                 VkCommandBuffer                             commandBuffer,
03039                 VkBuffer                                    srcBuffer,
03040                 VkBuffer                                    dstBuffer,
03041                 uint32_t                                    regionCount,
03042                 const VkBufferCopy*                         pRegions);
03043 
03044         VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
03045                 VkCommandBuffer                             commandBuffer,
03046                 VkImage                                     srcImage,
03047                 VkImageLayout                               srcImageLayout,
03048                 VkImage                                     dstImage,
03049                 VkImageLayout                               dstImageLayout,
03050                 uint32_t                                    regionCount,
03051                 const VkImageCopy*                          pRegions);
03052 
03053         VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
03054                 VkCommandBuffer                             commandBuffer,
03055                 VkImage                                     srcImage,
03056                 VkImageLayout                               srcImageLayout,
03057                 VkImage                                     dstImage,
03058                 VkImageLayout                               dstImageLayout,
03059                 uint32_t                                    regionCount,
03060                 const VkImageBlit*                          pRegions,
03061                 VkFilter                                    filter);
03062 
03063         VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
03064                 VkCommandBuffer                             commandBuffer,
03065                 VkBuffer                                    srcBuffer,
03066                 VkImage                                     dstImage,
03067                 VkImageLayout                               dstImageLayout,
03068                 uint32_t                                    regionCount,
03069                 const VkBufferImageCopy*                    pRegions);
03070 
03071         VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
03072                 VkCommandBuffer                             commandBuffer,
03073                 VkImage                                     srcImage,
03074                 VkImageLayout                               srcImageLayout,
03075                 VkBuffer                                    dstBuffer,
03076                 uint32_t                                    regionCount,
03077                 const VkBufferImageCopy*                    pRegions);
03078 
03079         VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
03080                 VkCommandBuffer                             commandBuffer,
03081                 VkBuffer                                    dstBuffer,
03082                 VkDeviceSize                                dstOffset,
03083                 VkDeviceSize                                dataSize,
03084                 const void*                                 pData);
03085 
03086         VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
03087                 VkCommandBuffer                             commandBuffer,
03088                 VkBuffer                                    dstBuffer,
03089                 VkDeviceSize                                dstOffset,
03090                 VkDeviceSize                                size,
03091                 uint32_t                                    data);
03092 
03093         VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
03094                 VkCommandBuffer                             commandBuffer,
03095                 VkImage                                     image,
03096                 VkImageLayout                               imageLayout,
03097                 const VkClearColorValue*                    pColor,
03098                 uint32_t                                    rangeCount,
03099                 const VkImageSubresourceRange*              pRanges);
03100 
03101         VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
03102                 VkCommandBuffer                             commandBuffer,
03103                 VkImage                                     image,
03104                 VkImageLayout                               imageLayout,
03105                 const VkClearDepthStencilValue*             pDepthStencil,
03106                 uint32_t                                    rangeCount,
03107                 const VkImageSubresourceRange*              pRanges);
03108 
03109         VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
03110                 VkCommandBuffer                             commandBuffer,
03111                 uint32_t                                    attachmentCount,
03112                 const VkClearAttachment*                    pAttachments,
03113                 uint32_t                                    rectCount,
03114                 const VkClearRect*                          pRects);
03115 
03116         VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
03117                 VkCommandBuffer                             commandBuffer,
03118                 VkImage                                     srcImage,
03119                 VkImageLayout                               srcImageLayout,
03120                 VkImage                                     dstImage,
03121                 VkImageLayout                               dstImageLayout,
03122                 uint32_t                                    regionCount,
03123                 const VkImageResolve*                       pRegions);
03124 
03125         VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
03126                 VkCommandBuffer                             commandBuffer,
03127                 VkEvent                                     event,
03128                 VkPipelineStageFlags                        stageMask);
03129 
03130         VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
03131                 VkCommandBuffer                             commandBuffer,
03132                 VkEvent                                     event,
03133                 VkPipelineStageFlags                        stageMask);
03134 
03135         VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
03136                 VkCommandBuffer                             commandBuffer,
03137                 uint32_t                                    eventCount,
03138                 const VkEvent*                              pEvents,
03139                 VkPipelineStageFlags                        srcStageMask,
03140                 VkPipelineStageFlags                        dstStageMask,
03141                 uint32_t                                    memoryBarrierCount,
03142                 const VkMemoryBarrier*                      pMemoryBarriers,
03143                 uint32_t                                    bufferMemoryBarrierCount,
03144                 const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
03145                 uint32_t                                    imageMemoryBarrierCount,
03146                 const VkImageMemoryBarrier*                 pImageMemoryBarriers);
03147 
03148         VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
03149                 VkCommandBuffer                             commandBuffer,
03150                 VkPipelineStageFlags                        srcStageMask,
03151                 VkPipelineStageFlags                        dstStageMask,
03152                 VkDependencyFlags                           dependencyFlags,
03153                 uint32_t                                    memoryBarrierCount,
03154                 const VkMemoryBarrier*                      pMemoryBarriers,
03155                 uint32_t                                    bufferMemoryBarrierCount,
03156                 const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
03157                 uint32_t                                    imageMemoryBarrierCount,
03158                 const VkImageMemoryBarrier*                 pImageMemoryBarriers);
03159 
03160         VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
03161                 VkCommandBuffer                             commandBuffer,
03162                 VkQueryPool                                 queryPool,
03163                 uint32_t                                    query,
03164                 VkQueryControlFlags                         flags);
03165 
03166         VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
03167                 VkCommandBuffer                             commandBuffer,
03168                 VkQueryPool                                 queryPool,
03169                 uint32_t                                    query);
03170 
03171         VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
03172                 VkCommandBuffer                             commandBuffer,
03173                 VkQueryPool                                 queryPool,
03174                 uint32_t                                    firstQuery,
03175                 uint32_t                                    queryCount);
03176 
03177         VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
03178                 VkCommandBuffer                             commandBuffer,
03179                 VkPipelineStageFlagBits                     pipelineStage,
03180                 VkQueryPool                                 queryPool,
03181                 uint32_t                                    query);
03182 
03183         VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
03184                 VkCommandBuffer                             commandBuffer,
03185                 VkQueryPool                                 queryPool,
03186                 uint32_t                                    firstQuery,
03187                 uint32_t                                    queryCount,
03188                 VkBuffer                                    dstBuffer,
03189                 VkDeviceSize                                dstOffset,
03190                 VkDeviceSize                                stride,
03191                 VkQueryResultFlags                          flags);
03192 
03193         VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
03194                 VkCommandBuffer                             commandBuffer,
03195                 VkPipelineLayout                            layout,
03196                 VkShaderStageFlags                          stageFlags,
03197                 uint32_t                                    offset,
03198                 uint32_t                                    size,
03199                 const void*                                 pValues);
03200 
03201         VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
03202                 VkCommandBuffer                             commandBuffer,
03203                 const VkRenderPassBeginInfo*                pRenderPassBegin,
03204                 VkSubpassContents                           contents);
03205 
03206         VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
03207                 VkCommandBuffer                             commandBuffer,
03208                 VkSubpassContents                           contents);
03209 
03210         VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
03211                 VkCommandBuffer                             commandBuffer);
03212 
03213         VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
03214                 VkCommandBuffer                             commandBuffer,
03215                 uint32_t                                    commandBufferCount,
03216                 const VkCommandBuffer*                      pCommandBuffers);
03217 #endif
03218 
03219 #define VK_KHR_surface 1
03220         VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
03221 
03222 #define VK_KHR_SURFACE_SPEC_VERSION       25
03223 #define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
03224 #define VK_COLORSPACE_SRGB_NONLINEAR_KHR  VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
03225 
03226 
03227                 typedef enum VkColorSpaceKHR {
03228                 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
03229                 VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104001,
03230                 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104002,
03231                 VK_COLOR_SPACE_SCRGB_LINEAR_EXT = 1000104003,
03232                 VK_COLOR_SPACE_SCRGB_NONLINEAR_EXT = 1000104004,
03233                 VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104005,
03234                 VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104006,
03235                 VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104007,
03236                 VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104008,
03237                 VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104009,
03238                 VK_COLOR_SPACE_BT2020_NONLINEAR_EXT = 1000104010,
03239                 VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
03240                 VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
03241                 VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
03242                 VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
03243                 VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1),
03244                 VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
03245         } VkColorSpaceKHR;
03246 
03247         typedef enum VkPresentModeKHR {
03248                 VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
03249                 VK_PRESENT_MODE_MAILBOX_KHR = 1,
03250                 VK_PRESENT_MODE_FIFO_KHR = 2,
03251                 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
03252                 VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR,
03253                 VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
03254                 VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
03255                 VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
03256         } VkPresentModeKHR;
03257 
03258 
03259         typedef enum VkSurfaceTransformFlagBitsKHR {
03260                 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
03261                 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
03262                 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
03263                 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
03264                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
03265                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
03266                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
03267                 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
03268                 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
03269                 VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
03270         } VkSurfaceTransformFlagBitsKHR;
03271         typedef VkFlags VkSurfaceTransformFlagsKHR;
03272 
03273         typedef enum VkCompositeAlphaFlagBitsKHR {
03274                 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
03275                 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
03276                 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
03277                 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
03278                 VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
03279         } VkCompositeAlphaFlagBitsKHR;
03280         typedef VkFlags VkCompositeAlphaFlagsKHR;
03281 
03282         typedef struct VkSurfaceCapabilitiesKHR {
03283                 uint32_t                         minImageCount;
03284                 uint32_t                         maxImageCount;
03285                 VkExtent2D                       currentExtent;
03286                 VkExtent2D                       minImageExtent;
03287                 VkExtent2D                       maxImageExtent;
03288                 uint32_t                         maxImageArrayLayers;
03289                 VkSurfaceTransformFlagsKHR       supportedTransforms;
03290                 VkSurfaceTransformFlagBitsKHR    currentTransform;
03291                 VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
03292                 VkImageUsageFlags                supportedUsageFlags;
03293         } VkSurfaceCapabilitiesKHR;
03294 
03295         typedef struct VkSurfaceFormatKHR {
03296                 VkFormat           format;
03297                 VkColorSpaceKHR    colorSpace;
03298         } VkSurfaceFormatKHR;
03299 
03300 
03301         typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
03302         typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
03303         typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
03304         typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
03305         typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
03306 
03307 #ifndef VK_NO_PROTOTYPES
03308         VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
03309                 VkInstance                                  instance,
03310                 VkSurfaceKHR                                surface,
03311                 const VkAllocationCallbacks*                pAllocator);
03312 
03313         VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
03314                 VkPhysicalDevice                            physicalDevice,
03315                 uint32_t                                    queueFamilyIndex,
03316                 VkSurfaceKHR                                surface,
03317                 VkBool32*                                   pSupported);
03318 
03319         VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
03320                 VkPhysicalDevice                            physicalDevice,
03321                 VkSurfaceKHR                                surface,
03322                 VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
03323 
03324         VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
03325                 VkPhysicalDevice                            physicalDevice,
03326                 VkSurfaceKHR                                surface,
03327                 uint32_t*                                   pSurfaceFormatCount,
03328                 VkSurfaceFormatKHR*                         pSurfaceFormats);
03329 
03330         VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
03331                 VkPhysicalDevice                            physicalDevice,
03332                 VkSurfaceKHR                                surface,
03333                 uint32_t*                                   pPresentModeCount,
03334                 VkPresentModeKHR*                           pPresentModes);
03335 #endif
03336 
03337 #define VK_KHR_swapchain 1
03338         VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
03339 
03340 #define VK_KHR_SWAPCHAIN_SPEC_VERSION     68
03341 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
03342 
03343                 typedef VkFlags VkSwapchainCreateFlagsKHR;
03344 
03345         typedef struct VkSwapchainCreateInfoKHR {
03346                 VkStructureType                  sType;
03347                 const void*                      pNext;
03348                 VkSwapchainCreateFlagsKHR        flags;
03349                 VkSurfaceKHR                     surface;
03350                 uint32_t                         minImageCount;
03351                 VkFormat                         imageFormat;
03352                 VkColorSpaceKHR                  imageColorSpace;
03353                 VkExtent2D                       imageExtent;
03354                 uint32_t                         imageArrayLayers;
03355                 VkImageUsageFlags                imageUsage;
03356                 VkSharingMode                    imageSharingMode;
03357                 uint32_t                         queueFamilyIndexCount;
03358                 const uint32_t*                  pQueueFamilyIndices;
03359                 VkSurfaceTransformFlagBitsKHR    preTransform;
03360                 VkCompositeAlphaFlagBitsKHR      compositeAlpha;
03361                 VkPresentModeKHR                 presentMode;
03362                 VkBool32                         clipped;
03363                 VkSwapchainKHR                   oldSwapchain;
03364         } VkSwapchainCreateInfoKHR;
03365 
03366         typedef struct VkPresentInfoKHR {
03367                 VkStructureType          sType;
03368                 const void*              pNext;
03369                 uint32_t                 waitSemaphoreCount;
03370                 const VkSemaphore*       pWaitSemaphores;
03371                 uint32_t                 swapchainCount;
03372                 const VkSwapchainKHR*    pSwapchains;
03373                 const uint32_t*          pImageIndices;
03374                 VkResult*                pResults;
03375         } VkPresentInfoKHR;
03376 
03377 
03378         typedef VkResult(VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
03379         typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
03380         typedef VkResult(VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
03381         typedef VkResult(VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
03382         typedef VkResult(VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
03383 
03384 #ifndef VK_NO_PROTOTYPES
03385         VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
03386                 VkDevice                                    device,
03387                 const VkSwapchainCreateInfoKHR*             pCreateInfo,
03388                 const VkAllocationCallbacks*                pAllocator,
03389                 VkSwapchainKHR*                             pSwapchain);
03390 
03391         VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
03392                 VkDevice                                    device,
03393                 VkSwapchainKHR                              swapchain,
03394                 const VkAllocationCallbacks*                pAllocator);
03395 
03396         VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
03397                 VkDevice                                    device,
03398                 VkSwapchainKHR                              swapchain,
03399                 uint32_t*                                   pSwapchainImageCount,
03400                 VkImage*                                    pSwapchainImages);
03401 
03402         VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
03403                 VkDevice                                    device,
03404                 VkSwapchainKHR                              swapchain,
03405                 uint64_t                                    timeout,
03406                 VkSemaphore                                 semaphore,
03407                 VkFence                                     fence,
03408                 uint32_t*                                   pImageIndex);
03409 
03410         VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
03411                 VkQueue                                     queue,
03412                 const VkPresentInfoKHR*                     pPresentInfo);
03413 #endif
03414 
03415 #define VK_KHR_display 1
03416         VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
03417                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
03418 
03419 #define VK_KHR_DISPLAY_SPEC_VERSION       21
03420 #define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
03421 
03422 
03423                 typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
03424                 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
03425                 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
03426                 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
03427                 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
03428                 VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
03429         } VkDisplayPlaneAlphaFlagBitsKHR;
03430         typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
03431         typedef VkFlags VkDisplayModeCreateFlagsKHR;
03432         typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
03433 
03434         typedef struct VkDisplayPropertiesKHR {
03435                 VkDisplayKHR                  display;
03436                 const char*                   displayName;
03437                 VkExtent2D                    physicalDimensions;
03438                 VkExtent2D                    physicalResolution;
03439                 VkSurfaceTransformFlagsKHR    supportedTransforms;
03440                 VkBool32                      planeReorderPossible;
03441                 VkBool32                      persistentContent;
03442         } VkDisplayPropertiesKHR;
03443 
03444         typedef struct VkDisplayModeParametersKHR {
03445                 VkExtent2D    visibleRegion;
03446                 uint32_t      refreshRate;
03447         } VkDisplayModeParametersKHR;
03448 
03449         typedef struct VkDisplayModePropertiesKHR {
03450                 VkDisplayModeKHR              displayMode;
03451                 VkDisplayModeParametersKHR    parameters;
03452         } VkDisplayModePropertiesKHR;
03453 
03454         typedef struct VkDisplayModeCreateInfoKHR {
03455                 VkStructureType                sType;
03456                 const void*                    pNext;
03457                 VkDisplayModeCreateFlagsKHR    flags;
03458                 VkDisplayModeParametersKHR     parameters;
03459         } VkDisplayModeCreateInfoKHR;
03460 
03461         typedef struct VkDisplayPlaneCapabilitiesKHR {
03462                 VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
03463                 VkOffset2D                     minSrcPosition;
03464                 VkOffset2D                     maxSrcPosition;
03465                 VkExtent2D                     minSrcExtent;
03466                 VkExtent2D                     maxSrcExtent;
03467                 VkOffset2D                     minDstPosition;
03468                 VkOffset2D                     maxDstPosition;
03469                 VkExtent2D                     minDstExtent;
03470                 VkExtent2D                     maxDstExtent;
03471         } VkDisplayPlaneCapabilitiesKHR;
03472 
03473         typedef struct VkDisplayPlanePropertiesKHR {
03474                 VkDisplayKHR    currentDisplay;
03475                 uint32_t        currentStackIndex;
03476         } VkDisplayPlanePropertiesKHR;
03477 
03478         typedef struct VkDisplaySurfaceCreateInfoKHR {
03479                 VkStructureType                   sType;
03480                 const void*                       pNext;
03481                 VkDisplaySurfaceCreateFlagsKHR    flags;
03482                 VkDisplayModeKHR                  displayMode;
03483                 uint32_t                          planeIndex;
03484                 uint32_t                          planeStackIndex;
03485                 VkSurfaceTransformFlagBitsKHR     transform;
03486                 float                             globalAlpha;
03487                 VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
03488                 VkExtent2D                        imageExtent;
03489         } VkDisplaySurfaceCreateInfoKHR;
03490 
03491 
03492         typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
03493         typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
03494         typedef VkResult(VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
03495         typedef VkResult(VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
03496         typedef VkResult(VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
03497         typedef VkResult(VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
03498         typedef VkResult(VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
03499 
03500 #ifndef VK_NO_PROTOTYPES
03501         VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
03502                 VkPhysicalDevice                            physicalDevice,
03503                 uint32_t*                                   pPropertyCount,
03504                 VkDisplayPropertiesKHR*                     pProperties);
03505 
03506         VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
03507                 VkPhysicalDevice                            physicalDevice,
03508                 uint32_t*                                   pPropertyCount,
03509                 VkDisplayPlanePropertiesKHR*                pProperties);
03510 
03511         VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
03512                 VkPhysicalDevice                            physicalDevice,
03513                 uint32_t                                    planeIndex,
03514                 uint32_t*                                   pDisplayCount,
03515                 VkDisplayKHR*                               pDisplays);
03516 
03517         VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
03518                 VkPhysicalDevice                            physicalDevice,
03519                 VkDisplayKHR                                display,
03520                 uint32_t*                                   pPropertyCount,
03521                 VkDisplayModePropertiesKHR*                 pProperties);
03522 
03523         VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
03524                 VkPhysicalDevice                            physicalDevice,
03525                 VkDisplayKHR                                display,
03526                 const VkDisplayModeCreateInfoKHR*           pCreateInfo,
03527                 const VkAllocationCallbacks*                pAllocator,
03528                 VkDisplayModeKHR*                           pMode);
03529 
03530         VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
03531                 VkPhysicalDevice                            physicalDevice,
03532                 VkDisplayModeKHR                            mode,
03533                 uint32_t                                    planeIndex,
03534                 VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
03535 
03536         VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
03537                 VkInstance                                  instance,
03538                 const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
03539                 const VkAllocationCallbacks*                pAllocator,
03540                 VkSurfaceKHR*                               pSurface);
03541 #endif
03542 
03543 #define VK_KHR_display_swapchain 1
03544 #define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
03545 #define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
03546 
03547         typedef struct VkDisplayPresentInfoKHR {
03548                 VkStructureType    sType;
03549                 const void*        pNext;
03550                 VkRect2D           srcRect;
03551                 VkRect2D           dstRect;
03552                 VkBool32           persistent;
03553         } VkDisplayPresentInfoKHR;
03554 
03555 
03556         typedef VkResult(VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
03557 
03558 #ifndef VK_NO_PROTOTYPES
03559         VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
03560                 VkDevice                                    device,
03561                 uint32_t                                    swapchainCount,
03562                 const VkSwapchainCreateInfoKHR*             pCreateInfos,
03563                 const VkAllocationCallbacks*                pAllocator,
03564                 VkSwapchainKHR*                             pSwapchains);
03565 #endif
03566 
03567 #ifdef VK_USE_PLATFORM_XLIB_KHR
03568 #define VK_KHR_xlib_surface 1
03569 #include <X11/Xlib.h>
03570 
03571 #define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
03572 #define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
03573 
03574         typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
03575 
03576         typedef struct VkXlibSurfaceCreateInfoKHR {
03577                 VkStructureType                sType;
03578                 const void*                    pNext;
03579                 VkXlibSurfaceCreateFlagsKHR    flags;
03580                 Display*                       dpy;
03581                 Window                         window;
03582         } VkXlibSurfaceCreateInfoKHR;
03583 
03584 
03585         typedef VkResult(VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
03586         typedef VkBool32(VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
03587 
03588 #ifndef VK_NO_PROTOTYPES
03589         VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
03590                 VkInstance                                  instance,
03591                 const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
03592                 const VkAllocationCallbacks*                pAllocator,
03593                 VkSurfaceKHR*                               pSurface);
03594 
03595         VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
03596                 VkPhysicalDevice                            physicalDevice,
03597                 uint32_t                                    queueFamilyIndex,
03598                 Display*                                    dpy,
03599                 VisualID                                    visualID);
03600 #endif
03601 #endif /* VK_USE_PLATFORM_XLIB_KHR */
03602 
03603 #ifdef VK_USE_PLATFORM_XCB_KHR
03604 #define VK_KHR_xcb_surface 1
03605 #include <xcb/xcb.h>
03606 
03607 #define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
03608 #define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
03609 
03610         typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
03611 
03612         typedef struct VkXcbSurfaceCreateInfoKHR {
03613                 VkStructureType               sType;
03614                 const void*                   pNext;
03615                 VkXcbSurfaceCreateFlagsKHR    flags;
03616                 xcb_connection_t*             connection;
03617                 xcb_window_t                  window;
03618         } VkXcbSurfaceCreateInfoKHR;
03619 
03620 
03621         typedef VkResult(VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
03622         typedef VkBool32(VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
03623 
03624 #ifndef VK_NO_PROTOTYPES
03625         VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
03626                 VkInstance                                  instance,
03627                 const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
03628                 const VkAllocationCallbacks*                pAllocator,
03629                 VkSurfaceKHR*                               pSurface);
03630 
03631         VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
03632                 VkPhysicalDevice                            physicalDevice,
03633                 uint32_t                                    queueFamilyIndex,
03634                 xcb_connection_t*                           connection,
03635                 xcb_visualid_t                              visual_id);
03636 #endif
03637 #endif /* VK_USE_PLATFORM_XCB_KHR */
03638 
03639 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
03640 #define VK_KHR_wayland_surface 1
03641 #include <wayland-client.h>
03642 
03643 #define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 5
03644 #define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
03645 
03646         typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
03647 
03648         typedef struct VkWaylandSurfaceCreateInfoKHR {
03649                 VkStructureType                   sType;
03650                 const void*                       pNext;
03651                 VkWaylandSurfaceCreateFlagsKHR    flags;
03652                 struct wl_display*                display;
03653                 struct wl_surface*                surface;
03654         } VkWaylandSurfaceCreateInfoKHR;
03655 
03656 
03657         typedef VkResult(VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
03658         typedef VkBool32(VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
03659 
03660 #ifndef VK_NO_PROTOTYPES
03661         VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
03662                 VkInstance                                  instance,
03663                 const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
03664                 const VkAllocationCallbacks*                pAllocator,
03665                 VkSurfaceKHR*                               pSurface);
03666 
03667         VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
03668                 VkPhysicalDevice                            physicalDevice,
03669                 uint32_t                                    queueFamilyIndex,
03670         struct wl_display*                          display);
03671 #endif
03672 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
03673 
03674 #ifdef VK_USE_PLATFORM_MIR_KHR
03675 #define VK_KHR_mir_surface 1
03676 #include <mir_toolkit/client_types.h>
03677 
03678 #define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
03679 #define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
03680 
03681         typedef VkFlags VkMirSurfaceCreateFlagsKHR;
03682 
03683         typedef struct VkMirSurfaceCreateInfoKHR {
03684                 VkStructureType               sType;
03685                 const void*                   pNext;
03686                 VkMirSurfaceCreateFlagsKHR    flags;
03687                 MirConnection*                connection;
03688                 MirSurface*                   mirSurface;
03689         } VkMirSurfaceCreateInfoKHR;
03690 
03691 
03692         typedef VkResult(VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
03693         typedef VkBool32(VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
03694 
03695 #ifndef VK_NO_PROTOTYPES
03696         VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
03697                 VkInstance                                  instance,
03698                 const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
03699                 const VkAllocationCallbacks*                pAllocator,
03700                 VkSurfaceKHR*                               pSurface);
03701 
03702         VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
03703                 VkPhysicalDevice                            physicalDevice,
03704                 uint32_t                                    queueFamilyIndex,
03705                 MirConnection*                              connection);
03706 #endif
03707 #endif /* VK_USE_PLATFORM_MIR_KHR */
03708 
03709 #ifdef VK_USE_PLATFORM_ANDROID_KHR
03710 #define VK_KHR_android_surface 1
03711 #include <android/native_window.h>
03712 
03713 #define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
03714 #define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
03715 
03716         typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
03717 
03718         typedef struct VkAndroidSurfaceCreateInfoKHR {
03719                 VkStructureType                   sType;
03720                 const void*                       pNext;
03721                 VkAndroidSurfaceCreateFlagsKHR    flags;
03722                 ANativeWindow*                    window;
03723         } VkAndroidSurfaceCreateInfoKHR;
03724 
03725 
03726         typedef VkResult(VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
03727 
03728 #ifndef VK_NO_PROTOTYPES
03729         VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
03730                 VkInstance                                  instance,
03731                 const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
03732                 const VkAllocationCallbacks*                pAllocator,
03733                 VkSurfaceKHR*                               pSurface);
03734 #endif
03735 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
03736 
03737 #ifdef VK_USE_PLATFORM_WIN32_KHR
03738 #define VK_KHR_win32_surface 1
03739 #include <windows.h>
03740 
03741 #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5
03742 #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
03743 
03744         typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
03745 
03746         typedef struct VkWin32SurfaceCreateInfoKHR {
03747                 VkStructureType                 sType;
03748                 const void*                     pNext;
03749                 VkWin32SurfaceCreateFlagsKHR    flags;
03750                 HINSTANCE                       hinstance;
03751                 HWND                            hwnd;
03752         } VkWin32SurfaceCreateInfoKHR;
03753 
03754 
03755         typedef VkResult(VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
03756         typedef VkBool32(VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
03757 
03758 #ifndef VK_NO_PROTOTYPES
03759         VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
03760                 VkInstance                                  instance,
03761                 const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
03762                 const VkAllocationCallbacks*                pAllocator,
03763                 VkSurfaceKHR*                               pSurface);
03764 
03765         VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
03766                 VkPhysicalDevice                            physicalDevice,
03767                 uint32_t                                    queueFamilyIndex);
03768 #endif
03769 #endif /* VK_USE_PLATFORM_WIN32_KHR */
03770 
03771 #define VK_KHR_sampler_mirror_clamp_to_edge 1
03772 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1
03773 #define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
03774 
03775 
03776 #define VK_KHR_get_physical_device_properties2 1
03777 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
03778 #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
03779 
03780         typedef struct VkPhysicalDeviceFeatures2KHR {
03781                 VkStructureType             sType;
03782                 void*                       pNext;
03783                 VkPhysicalDeviceFeatures    features;
03784         } VkPhysicalDeviceFeatures2KHR;
03785 
03786         typedef struct VkPhysicalDeviceProperties2KHR {
03787                 VkStructureType               sType;
03788                 void*                         pNext;
03789                 VkPhysicalDeviceProperties    properties;
03790         } VkPhysicalDeviceProperties2KHR;
03791 
03792         typedef struct VkFormatProperties2KHR {
03793                 VkStructureType       sType;
03794                 void*                 pNext;
03795                 VkFormatProperties    formatProperties;
03796         } VkFormatProperties2KHR;
03797 
03798         typedef struct VkImageFormatProperties2KHR {
03799                 VkStructureType            sType;
03800                 void*                      pNext;
03801                 VkImageFormatProperties    imageFormatProperties;
03802         } VkImageFormatProperties2KHR;
03803 
03804         typedef struct VkPhysicalDeviceImageFormatInfo2KHR {
03805                 VkStructureType       sType;
03806                 const void*           pNext;
03807                 VkFormat              format;
03808                 VkImageType           type;
03809                 VkImageTiling         tiling;
03810                 VkImageUsageFlags     usage;
03811                 VkImageCreateFlags    flags;
03812         } VkPhysicalDeviceImageFormatInfo2KHR;
03813 
03814         typedef struct VkQueueFamilyProperties2KHR {
03815                 VkStructureType            sType;
03816                 void*                      pNext;
03817                 VkQueueFamilyProperties    queueFamilyProperties;
03818         } VkQueueFamilyProperties2KHR;
03819 
03820         typedef struct VkPhysicalDeviceMemoryProperties2KHR {
03821                 VkStructureType                     sType;
03822                 void*                               pNext;
03823                 VkPhysicalDeviceMemoryProperties    memoryProperties;
03824         } VkPhysicalDeviceMemoryProperties2KHR;
03825 
03826         typedef struct VkSparseImageFormatProperties2KHR {
03827                 VkStructureType                  sType;
03828                 void*                            pNext;
03829                 VkSparseImageFormatProperties    properties;
03830         } VkSparseImageFormatProperties2KHR;
03831 
03832         typedef struct VkPhysicalDeviceSparseImageFormatInfo2KHR {
03833                 VkStructureType          sType;
03834                 const void*              pNext;
03835                 VkFormat                 format;
03836                 VkImageType              type;
03837                 VkSampleCountFlagBits    samples;
03838                 VkImageUsageFlags        usage;
03839                 VkImageTiling            tiling;
03840         } VkPhysicalDeviceSparseImageFormatInfo2KHR;
03841 
03842 
03843         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures);
03844         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties);
03845         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties);
03846         typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties);
03847         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
03848         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
03849         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties);
03850 
03851 #ifndef VK_NO_PROTOTYPES
03852         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
03853                 VkPhysicalDevice                            physicalDevice,
03854                 VkPhysicalDeviceFeatures2KHR*               pFeatures);
03855 
03856         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
03857                 VkPhysicalDevice                            physicalDevice,
03858                 VkPhysicalDeviceProperties2KHR*             pProperties);
03859 
03860         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
03861                 VkPhysicalDevice                            physicalDevice,
03862                 VkFormat                                    format,
03863                 VkFormatProperties2KHR*                     pFormatProperties);
03864 
03865         VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
03866                 VkPhysicalDevice                            physicalDevice,
03867                 const VkPhysicalDeviceImageFormatInfo2KHR*  pImageFormatInfo,
03868                 VkImageFormatProperties2KHR*                pImageFormatProperties);
03869 
03870         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
03871                 VkPhysicalDevice                            physicalDevice,
03872                 uint32_t*                                   pQueueFamilyPropertyCount,
03873                 VkQueueFamilyProperties2KHR*                pQueueFamilyProperties);
03874 
03875         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
03876                 VkPhysicalDevice                            physicalDevice,
03877                 VkPhysicalDeviceMemoryProperties2KHR*       pMemoryProperties);
03878 
03879         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
03880                 VkPhysicalDevice                            physicalDevice,
03881                 const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
03882                 uint32_t*                                   pPropertyCount,
03883                 VkSparseImageFormatProperties2KHR*          pProperties);
03884 #endif
03885 
03886 #define VK_KHR_shader_draw_parameters 1
03887 #define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
03888 #define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
03889 
03890 
03891 #define VK_KHR_maintenance1 1
03892 #define VK_KHR_MAINTENANCE1_SPEC_VERSION  1
03893 #define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
03894 
03895         typedef VkFlags VkCommandPoolTrimFlagsKHR;
03896 
03897         typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags);
03898 
03899 #ifndef VK_NO_PROTOTYPES
03900         VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
03901                 VkDevice                                    device,
03902                 VkCommandPool                               commandPool,
03903                 VkCommandPoolTrimFlagsKHR                   flags);
03904 #endif
03905 
03906 #define VK_EXT_debug_report 1
03907         VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
03908 
03909 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION  4
03910 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
03911 #define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
03912 
03913 
03914                 typedef enum VkDebugReportObjectTypeEXT {
03915                 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
03916                 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
03917                 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
03918                 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
03919                 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
03920                 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
03921                 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
03922                 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
03923                 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
03924                 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
03925                 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
03926                 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
03927                 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
03928                 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
03929                 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
03930                 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
03931                 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
03932                 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
03933                 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
03934                 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
03935                 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
03936                 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
03937                 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
03938                 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
03939                 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
03940                 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
03941                 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
03942                 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
03943                 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28,
03944                 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
03945                 VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
03946                 VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31,
03947                 VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,
03948                 VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
03949                 VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT,
03950                 VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1),
03951                 VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
03952         } VkDebugReportObjectTypeEXT;
03953 
03954         typedef enum VkDebugReportErrorEXT {
03955                 VK_DEBUG_REPORT_ERROR_NONE_EXT = 0,
03956                 VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1,
03957                 VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_ERROR_NONE_EXT,
03958                 VK_DEBUG_REPORT_ERROR_END_RANGE_EXT = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT,
03959                 VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT - VK_DEBUG_REPORT_ERROR_NONE_EXT + 1),
03960                 VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = 0x7FFFFFFF
03961         } VkDebugReportErrorEXT;
03962 
03963 
03964         typedef enum VkDebugReportFlagBitsEXT {
03965                 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
03966                 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
03967                 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
03968                 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
03969                 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
03970                 VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
03971         } VkDebugReportFlagBitsEXT;
03972         typedef VkFlags VkDebugReportFlagsEXT;
03973 
03974         typedef VkBool32(VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
03975                 VkDebugReportFlagsEXT                       flags,
03976                 VkDebugReportObjectTypeEXT                  objectType,
03977                 uint64_t                                    object,
03978                 size_t                                      location,
03979                 int32_t                                     messageCode,
03980                 const char*                                 pLayerPrefix,
03981                 const char*                                 pMessage,
03982                 void*                                       pUserData);
03983 
03984 
03985         typedef struct VkDebugReportCallbackCreateInfoEXT {
03986                 VkStructureType                 sType;
03987                 const void*                     pNext;
03988                 VkDebugReportFlagsEXT           flags;
03989                 PFN_vkDebugReportCallbackEXT    pfnCallback;
03990                 void*                           pUserData;
03991         } VkDebugReportCallbackCreateInfoEXT;
03992 
03993 
03994         typedef VkResult(VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
03995         typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
03996         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);
03997 
03998 #ifndef VK_NO_PROTOTYPES
03999         VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
04000                 VkInstance                                  instance,
04001                 const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
04002                 const VkAllocationCallbacks*                pAllocator,
04003                 VkDebugReportCallbackEXT*                   pCallback);
04004 
04005         VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
04006                 VkInstance                                  instance,
04007                 VkDebugReportCallbackEXT                    callback,
04008                 const VkAllocationCallbacks*                pAllocator);
04009 
04010         VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
04011                 VkInstance                                  instance,
04012                 VkDebugReportFlagsEXT                       flags,
04013                 VkDebugReportObjectTypeEXT                  objectType,
04014                 uint64_t                                    object,
04015                 size_t                                      location,
04016                 int32_t                                     messageCode,
04017                 const char*                                 pLayerPrefix,
04018                 const char*                                 pMessage);
04019 #endif
04020 
04021 #define VK_NV_glsl_shader 1
04022 #define VK_NV_GLSL_SHADER_SPEC_VERSION    1
04023 #define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
04024 
04025 
04026 #define VK_IMG_filter_cubic 1
04027 #define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
04028 #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
04029 
04030 
04031 #define VK_AMD_rasterization_order 1
04032 #define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
04033 #define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
04034 
04035 
04036         typedef enum VkRasterizationOrderAMD {
04037                 VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
04038                 VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
04039                 VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD,
04040                 VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD,
04041                 VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1),
04042                 VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
04043         } VkRasterizationOrderAMD;
04044 
04045         typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
04046                 VkStructureType            sType;
04047                 const void*                pNext;
04048                 VkRasterizationOrderAMD    rasterizationOrder;
04049         } VkPipelineRasterizationStateRasterizationOrderAMD;
04050 
04051 
04052 
04053 #define VK_AMD_shader_trinary_minmax 1
04054 #define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
04055 #define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
04056 
04057 
04058 #define VK_AMD_shader_explicit_vertex_parameter 1
04059 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
04060 #define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
04061 
04062 
04063 #define VK_EXT_debug_marker 1
04064 #define VK_EXT_DEBUG_MARKER_SPEC_VERSION  3
04065 #define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
04066 
04067         typedef struct VkDebugMarkerObjectNameInfoEXT {
04068                 VkStructureType               sType;
04069                 const void*                   pNext;
04070                 VkDebugReportObjectTypeEXT    objectType;
04071                 uint64_t                      object;
04072                 const char*                   pObjectName;
04073         } VkDebugMarkerObjectNameInfoEXT;
04074 
04075         typedef struct VkDebugMarkerObjectTagInfoEXT {
04076                 VkStructureType               sType;
04077                 const void*                   pNext;
04078                 VkDebugReportObjectTypeEXT    objectType;
04079                 uint64_t                      object;
04080                 uint64_t                      tagName;
04081                 size_t                        tagSize;
04082                 const void*                   pTag;
04083         } VkDebugMarkerObjectTagInfoEXT;
04084 
04085         typedef struct VkDebugMarkerMarkerInfoEXT {
04086                 VkStructureType    sType;
04087                 const void*        pNext;
04088                 const char*        pMarkerName;
04089                 float              color[4];
04090         } VkDebugMarkerMarkerInfoEXT;
04091 
04092 
04093         typedef VkResult(VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo);
04094         typedef VkResult(VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo);
04095         typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
04096         typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
04097         typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
04098 
04099 #ifndef VK_NO_PROTOTYPES
04100         VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
04101                 VkDevice                                    device,
04102                 VkDebugMarkerObjectTagInfoEXT*              pTagInfo);
04103 
04104         VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
04105                 VkDevice                                    device,
04106                 VkDebugMarkerObjectNameInfoEXT*             pNameInfo);
04107 
04108         VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
04109                 VkCommandBuffer                             commandBuffer,
04110                 VkDebugMarkerMarkerInfoEXT*                 pMarkerInfo);
04111 
04112         VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
04113                 VkCommandBuffer                             commandBuffer);
04114 
04115         VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
04116                 VkCommandBuffer                             commandBuffer,
04117                 VkDebugMarkerMarkerInfoEXT*                 pMarkerInfo);
04118 #endif
04119 
04120 #define VK_AMD_gcn_shader 1
04121 #define VK_AMD_GCN_SHADER_SPEC_VERSION    1
04122 #define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
04123 
04124 
04125 #define VK_NV_dedicated_allocation 1
04126 #define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
04127 #define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
04128 
04129         typedef struct VkDedicatedAllocationImageCreateInfoNV {
04130                 VkStructureType    sType;
04131                 const void*        pNext;
04132                 VkBool32           dedicatedAllocation;
04133         } VkDedicatedAllocationImageCreateInfoNV;
04134 
04135         typedef struct VkDedicatedAllocationBufferCreateInfoNV {
04136                 VkStructureType    sType;
04137                 const void*        pNext;
04138                 VkBool32           dedicatedAllocation;
04139         } VkDedicatedAllocationBufferCreateInfoNV;
04140 
04141         typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
04142                 VkStructureType    sType;
04143                 const void*        pNext;
04144                 VkImage            image;
04145                 VkBuffer           buffer;
04146         } VkDedicatedAllocationMemoryAllocateInfoNV;
04147 
04148 
04149 
04150 #define VK_AMD_draw_indirect_count 1
04151 #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
04152 #define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
04153 
04154         typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
04155         typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
04156 
04157 #ifndef VK_NO_PROTOTYPES
04158         VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
04159                 VkCommandBuffer                             commandBuffer,
04160                 VkBuffer                                    buffer,
04161                 VkDeviceSize                                offset,
04162                 VkBuffer                                    countBuffer,
04163                 VkDeviceSize                                countBufferOffset,
04164                 uint32_t                                    maxDrawCount,
04165                 uint32_t                                    stride);
04166 
04167         VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
04168                 VkCommandBuffer                             commandBuffer,
04169                 VkBuffer                                    buffer,
04170                 VkDeviceSize                                offset,
04171                 VkBuffer                                    countBuffer,
04172                 VkDeviceSize                                countBufferOffset,
04173                 uint32_t                                    maxDrawCount,
04174                 uint32_t                                    stride);
04175 #endif
04176 
04177 #define VK_AMD_negative_viewport_height 1
04178 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
04179 #define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
04180 
04181 
04182 #define VK_AMD_gpu_shader_half_float 1
04183 #define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1
04184 #define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
04185 
04186 
04187 #define VK_AMD_shader_ballot 1
04188 #define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
04189 #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
04190 
04191 
04192 #define VK_IMG_format_pvrtc 1
04193 #define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
04194 #define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
04195 
04196 
04197 #define VK_NV_external_memory_capabilities 1
04198 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
04199 #define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
04200 
04201 
04202         typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
04203                 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
04204                 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
04205                 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
04206                 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
04207                 VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
04208         } VkExternalMemoryHandleTypeFlagBitsNV;
04209         typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
04210 
04211         typedef enum VkExternalMemoryFeatureFlagBitsNV {
04212                 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
04213                 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
04214                 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
04215                 VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
04216         } VkExternalMemoryFeatureFlagBitsNV;
04217         typedef VkFlags VkExternalMemoryFeatureFlagsNV;
04218 
04219         typedef struct VkExternalImageFormatPropertiesNV {
04220                 VkImageFormatProperties              imageFormatProperties;
04221                 VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
04222                 VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
04223                 VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
04224         } VkExternalImageFormatPropertiesNV;
04225 
04226 
04227         typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
04228 
04229 #ifndef VK_NO_PROTOTYPES
04230         VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
04231                 VkPhysicalDevice                            physicalDevice,
04232                 VkFormat                                    format,
04233                 VkImageType                                 type,
04234                 VkImageTiling                               tiling,
04235                 VkImageUsageFlags                           usage,
04236                 VkImageCreateFlags                          flags,
04237                 VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
04238                 VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
04239 #endif
04240 
04241 #define VK_NV_external_memory 1
04242 #define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
04243 #define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
04244 
04245         typedef struct VkExternalMemoryImageCreateInfoNV {
04246                 VkStructureType                      sType;
04247                 const void*                          pNext;
04248                 VkExternalMemoryHandleTypeFlagsNV    handleTypes;
04249         } VkExternalMemoryImageCreateInfoNV;
04250 
04251         typedef struct VkExportMemoryAllocateInfoNV {
04252                 VkStructureType                      sType;
04253                 const void*                          pNext;
04254                 VkExternalMemoryHandleTypeFlagsNV    handleTypes;
04255         } VkExportMemoryAllocateInfoNV;
04256 
04257 
04258 
04259 #ifdef VK_USE_PLATFORM_WIN32_KHR
04260 #define VK_NV_external_memory_win32 1
04261 #define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
04262 #define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
04263 
04264         typedef struct VkImportMemoryWin32HandleInfoNV {
04265                 VkStructureType                      sType;
04266                 const void*                          pNext;
04267                 VkExternalMemoryHandleTypeFlagsNV    handleType;
04268                 HANDLE                               handle;
04269         } VkImportMemoryWin32HandleInfoNV;
04270 
04271         typedef struct VkExportMemoryWin32HandleInfoNV {
04272                 VkStructureType               sType;
04273                 const void*                   pNext;
04274                 const SECURITY_ATTRIBUTES*    pAttributes;
04275                 DWORD                         dwAccess;
04276         } VkExportMemoryWin32HandleInfoNV;
04277 
04278 
04279         typedef VkResult(VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
04280 
04281 #ifndef VK_NO_PROTOTYPES
04282         VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
04283                 VkDevice                                    device,
04284                 VkDeviceMemory                              memory,
04285                 VkExternalMemoryHandleTypeFlagsNV           handleType,
04286                 HANDLE*                                     pHandle);
04287 #endif
04288 #endif /* VK_USE_PLATFORM_WIN32_KHR */
04289 
04290 #ifdef VK_USE_PLATFORM_WIN32_KHR
04291 #define VK_NV_win32_keyed_mutex 1
04292 #define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
04293 #define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
04294 
04295         typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
04296                 VkStructureType          sType;
04297                 const void*              pNext;
04298                 uint32_t                 acquireCount;
04299                 const VkDeviceMemory*    pAcquireSyncs;
04300                 const uint64_t*          pAcquireKeys;
04301                 const uint32_t*          pAcquireTimeoutMilliseconds;
04302                 uint32_t                 releaseCount;
04303                 const VkDeviceMemory*    pReleaseSyncs;
04304                 const uint64_t*          pReleaseKeys;
04305         } VkWin32KeyedMutexAcquireReleaseInfoNV;
04306 
04307 
04308 #endif /* VK_USE_PLATFORM_WIN32_KHR */
04309 
04310 #define VK_EXT_validation_flags 1
04311 #define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
04312 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
04313 
04314 
04315         typedef enum VkValidationCheckEXT {
04316                 VK_VALIDATION_CHECK_ALL_EXT = 0,
04317                 VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
04318                 VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
04319                 VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_ALL_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1),
04320                 VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
04321         } VkValidationCheckEXT;
04322 
04323         typedef struct VkValidationFlagsEXT {
04324                 VkStructureType          sType;
04325                 const void*              pNext;
04326                 uint32_t                 disabledValidationCheckCount;
04327                 VkValidationCheckEXT*    pDisabledValidationChecks;
04328         } VkValidationFlagsEXT;
04329 
04330 
04331 
04332 #ifdef VK_USE_PLATFORM_VI_NN
04333 #define VK_NN_vi_surface 1
04334 #define VK_NN_VI_SURFACE_SPEC_VERSION     1
04335 #define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
04336 
04337         typedef VkFlags VkViSurfaceCreateFlagsNN;
04338 
04339         typedef struct VkViSurfaceCreateInfoNN {
04340                 VkStructureType             sType;
04341                 const void*                 pNext;
04342                 VkViSurfaceCreateFlagsNN    flags;
04343                 void*                       window;
04344         } VkViSurfaceCreateInfoNN;
04345 
04346 
04347         typedef VkResult(VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
04348 
04349 #ifndef VK_NO_PROTOTYPES
04350         VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
04351                 VkInstance                                  instance,
04352                 const VkViSurfaceCreateInfoNN*              pCreateInfo,
04353                 const VkAllocationCallbacks*                pAllocator,
04354                 VkSurfaceKHR*                               pSurface);
04355 #endif
04356 #endif /* VK_USE_PLATFORM_VI_NN */
04357 
04358 #define VK_EXT_shader_subgroup_ballot 1
04359 #define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
04360 #define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
04361 
04362 
04363 #define VK_EXT_shader_subgroup_vote 1
04364 #define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
04365 #define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
04366 
04367 
04368 #define VK_NVX_device_generated_commands 1
04369         VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
04370                 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
04371 
04372 #define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 1
04373 #define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"
04374 
04375 
04376                 typedef enum VkIndirectCommandsTokenTypeNVX {
04377                 VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX = 0,
04378                 VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX = 1,
04379                 VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX = 2,
04380                 VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX = 3,
04381                 VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX = 4,
04382                 VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX = 5,
04383                 VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX = 6,
04384                 VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX = 7,
04385                 VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX,
04386                 VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX,
04387                 VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX + 1),
04388                 VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
04389         } VkIndirectCommandsTokenTypeNVX;
04390 
04391         typedef enum VkObjectEntryTypeNVX {
04392                 VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = 0,
04393                 VK_OBJECT_ENTRY_PIPELINE_NVX = 1,
04394                 VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = 2,
04395                 VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = 3,
04396                 VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = 4,
04397                 VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX,
04398                 VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX,
04399                 VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX + 1),
04400                 VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
04401         } VkObjectEntryTypeNVX;
04402 
04403 
04404         typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
04405                 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
04406                 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
04407                 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
04408                 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
04409                 VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
04410         } VkIndirectCommandsLayoutUsageFlagBitsNVX;
04411         typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
04412 
04413         typedef enum VkObjectEntryUsageFlagBitsNVX {
04414                 VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
04415                 VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
04416                 VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
04417         } VkObjectEntryUsageFlagBitsNVX;
04418         typedef VkFlags VkObjectEntryUsageFlagsNVX;
04419 
04420         typedef struct VkDeviceGeneratedCommandsFeaturesNVX {
04421                 VkStructureType    sType;
04422                 const void*        pNext;
04423                 VkBool32           computeBindingPointSupport;
04424         } VkDeviceGeneratedCommandsFeaturesNVX;
04425 
04426         typedef struct VkDeviceGeneratedCommandsLimitsNVX {
04427                 VkStructureType    sType;
04428                 const void*        pNext;
04429                 uint32_t           maxIndirectCommandsLayoutTokenCount;
04430                 uint32_t           maxObjectEntryCounts;
04431                 uint32_t           minSequenceCountBufferOffsetAlignment;
04432                 uint32_t           minSequenceIndexBufferOffsetAlignment;
04433                 uint32_t           minCommandsTokenBufferOffsetAlignment;
04434         } VkDeviceGeneratedCommandsLimitsNVX;
04435 
04436         typedef struct VkIndirectCommandsTokenNVX {
04437                 VkIndirectCommandsTokenTypeNVX    tokenType;
04438                 VkBuffer                          buffer;
04439                 VkDeviceSize                      offset;
04440         } VkIndirectCommandsTokenNVX;
04441 
04442         typedef struct VkIndirectCommandsLayoutTokenNVX {
04443                 VkIndirectCommandsTokenTypeNVX    tokenType;
04444                 uint32_t                          bindingUnit;
04445                 uint32_t                          dynamicCount;
04446                 uint32_t                          divisor;
04447         } VkIndirectCommandsLayoutTokenNVX;
04448 
04449         typedef struct VkIndirectCommandsLayoutCreateInfoNVX {
04450                 VkStructureType                            sType;
04451                 const void*                                pNext;
04452                 VkPipelineBindPoint                        pipelineBindPoint;
04453                 VkIndirectCommandsLayoutUsageFlagsNVX      flags;
04454                 uint32_t                                   tokenCount;
04455                 const VkIndirectCommandsLayoutTokenNVX*    pTokens;
04456         } VkIndirectCommandsLayoutCreateInfoNVX;
04457 
04458         typedef struct VkCmdProcessCommandsInfoNVX {
04459                 VkStructureType                      sType;
04460                 const void*                          pNext;
04461                 VkObjectTableNVX                     objectTable;
04462                 VkIndirectCommandsLayoutNVX          indirectCommandsLayout;
04463                 uint32_t                             indirectCommandsTokenCount;
04464                 const VkIndirectCommandsTokenNVX*    pIndirectCommandsTokens;
04465                 uint32_t                             maxSequencesCount;
04466                 VkCommandBuffer                      targetCommandBuffer;
04467                 VkBuffer                             sequencesCountBuffer;
04468                 VkDeviceSize                         sequencesCountOffset;
04469                 VkBuffer                             sequencesIndexBuffer;
04470                 VkDeviceSize                         sequencesIndexOffset;
04471         } VkCmdProcessCommandsInfoNVX;
04472 
04473         typedef struct VkCmdReserveSpaceForCommandsInfoNVX {
04474                 VkStructureType                sType;
04475                 const void*                    pNext;
04476                 VkObjectTableNVX               objectTable;
04477                 VkIndirectCommandsLayoutNVX    indirectCommandsLayout;
04478                 uint32_t                       maxSequencesCount;
04479         } VkCmdReserveSpaceForCommandsInfoNVX;
04480 
04481         typedef struct VkObjectTableCreateInfoNVX {
04482                 VkStructureType                      sType;
04483                 const void*                          pNext;
04484                 uint32_t                             objectCount;
04485                 const VkObjectEntryTypeNVX*          pObjectEntryTypes;
04486                 const uint32_t*                      pObjectEntryCounts;
04487                 const VkObjectEntryUsageFlagsNVX*    pObjectEntryUsageFlags;
04488                 uint32_t                             maxUniformBuffersPerDescriptor;
04489                 uint32_t                             maxStorageBuffersPerDescriptor;
04490                 uint32_t                             maxStorageImagesPerDescriptor;
04491                 uint32_t                             maxSampledImagesPerDescriptor;
04492                 uint32_t                             maxPipelineLayouts;
04493         } VkObjectTableCreateInfoNVX;
04494 
04495         typedef struct VkObjectTableEntryNVX {
04496                 VkObjectEntryTypeNVX          type;
04497                 VkObjectEntryUsageFlagsNVX    flags;
04498         } VkObjectTableEntryNVX;
04499 
04500         typedef struct VkObjectTablePipelineEntryNVX {
04501                 VkObjectEntryTypeNVX          type;
04502                 VkObjectEntryUsageFlagsNVX    flags;
04503                 VkPipeline                    pipeline;
04504         } VkObjectTablePipelineEntryNVX;
04505 
04506         typedef struct VkObjectTableDescriptorSetEntryNVX {
04507                 VkObjectEntryTypeNVX          type;
04508                 VkObjectEntryUsageFlagsNVX    flags;
04509                 VkPipelineLayout              pipelineLayout;
04510                 VkDescriptorSet               descriptorSet;
04511         } VkObjectTableDescriptorSetEntryNVX;
04512 
04513         typedef struct VkObjectTableVertexBufferEntryNVX {
04514                 VkObjectEntryTypeNVX          type;
04515                 VkObjectEntryUsageFlagsNVX    flags;
04516                 VkBuffer                      buffer;
04517         } VkObjectTableVertexBufferEntryNVX;
04518 
04519         typedef struct VkObjectTableIndexBufferEntryNVX {
04520                 VkObjectEntryTypeNVX          type;
04521                 VkObjectEntryUsageFlagsNVX    flags;
04522                 VkBuffer                      buffer;
04523                 VkIndexType                   indexType;
04524         } VkObjectTableIndexBufferEntryNVX;
04525 
04526         typedef struct VkObjectTablePushConstantEntryNVX {
04527                 VkObjectEntryTypeNVX          type;
04528                 VkObjectEntryUsageFlagsNVX    flags;
04529                 VkPipelineLayout              pipelineLayout;
04530                 VkShaderStageFlags            stageFlags;
04531         } VkObjectTablePushConstantEntryNVX;
04532 
04533 
04534         typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
04535         typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
04536         typedef VkResult(VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
04537         typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
04538         typedef VkResult(VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable);
04539         typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator);
04540         typedef VkResult(VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const*    ppObjectTableEntries, const uint32_t* pObjectIndices);
04541         typedef VkResult(VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices);
04542         typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits);
04543 
04544 #ifndef VK_NO_PROTOTYPES
04545         VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
04546                 VkCommandBuffer                             commandBuffer,
04547                 const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);
04548 
04549         VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
04550                 VkCommandBuffer                             commandBuffer,
04551                 const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);
04552 
04553         VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
04554                 VkDevice                                    device,
04555                 const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
04556                 const VkAllocationCallbacks*                pAllocator,
04557                 VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);
04558 
04559         VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
04560                 VkDevice                                    device,
04561                 VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
04562                 const VkAllocationCallbacks*                pAllocator);
04563 
04564         VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
04565                 VkDevice                                    device,
04566                 const VkObjectTableCreateInfoNVX*           pCreateInfo,
04567                 const VkAllocationCallbacks*                pAllocator,
04568                 VkObjectTableNVX*                           pObjectTable);
04569 
04570         VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(
04571                 VkDevice                                    device,
04572                 VkObjectTableNVX                            objectTable,
04573                 const VkAllocationCallbacks*                pAllocator);
04574 
04575         VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
04576                 VkDevice                                    device,
04577                 VkObjectTableNVX                            objectTable,
04578                 uint32_t                                    objectCount,
04579                 const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
04580                 const uint32_t*                             pObjectIndices);
04581 
04582         VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
04583                 VkDevice                                    device,
04584                 VkObjectTableNVX                            objectTable,
04585                 uint32_t                                    objectCount,
04586                 const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
04587                 const uint32_t*                             pObjectIndices);
04588 
04589         VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
04590                 VkPhysicalDevice                            physicalDevice,
04591                 VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
04592                 VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
04593 #endif
04594 
04595 #define VK_EXT_direct_mode_display 1
04596 #define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
04597 #define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
04598 
04599         typedef VkResult(VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
04600 
04601 #ifndef VK_NO_PROTOTYPES
04602         VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
04603                 VkPhysicalDevice                            physicalDevice,
04604                 VkDisplayKHR                                display);
04605 #endif
04606 
04607 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
04608 #define VK_EXT_acquire_xlib_display 1
04609 #include <X11/extensions/Xrandr.h>
04610 
04611 #define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
04612 #define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
04613 
04614         typedef VkResult(VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
04615         typedef VkResult(VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
04616 
04617 #ifndef VK_NO_PROTOTYPES
04618         VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
04619                 VkPhysicalDevice                            physicalDevice,
04620                 Display*                                    dpy,
04621                 VkDisplayKHR                                display);
04622 
04623         VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
04624                 VkPhysicalDevice                            physicalDevice,
04625                 Display*                                    dpy,
04626                 RROutput                                    rrOutput,
04627                 VkDisplayKHR*                               pDisplay);
04628 #endif
04629 #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
04630 
04631 #define VK_EXT_display_surface_counter 1
04632 #define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
04633 #define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
04634 
04635 
04636         typedef enum VkSurfaceCounterFlagBitsEXT {
04637                 VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001,
04638                 VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
04639         } VkSurfaceCounterFlagBitsEXT;
04640         typedef VkFlags VkSurfaceCounterFlagsEXT;
04641 
04642         typedef struct VkSurfaceCapabilities2EXT {
04643                 VkStructureType                  sType;
04644                 void*                            pNext;
04645                 uint32_t                         minImageCount;
04646                 uint32_t                         maxImageCount;
04647                 VkExtent2D                       currentExtent;
04648                 VkExtent2D                       minImageExtent;
04649                 VkExtent2D                       maxImageExtent;
04650                 uint32_t                         maxImageArrayLayers;
04651                 VkSurfaceTransformFlagsKHR       supportedTransforms;
04652                 VkSurfaceTransformFlagBitsKHR    currentTransform;
04653                 VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
04654                 VkImageUsageFlags                supportedUsageFlags;
04655                 VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
04656         } VkSurfaceCapabilities2EXT;
04657 
04658 
04659         typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
04660 
04661 #ifndef VK_NO_PROTOTYPES
04662         VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
04663                 VkPhysicalDevice                            physicalDevice,
04664                 VkSurfaceKHR                                surface,
04665                 VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
04666 #endif
04667 
04668 #define VK_EXT_display_control 1
04669 #define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
04670 #define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
04671 
04672 
04673         typedef enum VkDisplayPowerStateEXT {
04674                 VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
04675                 VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
04676                 VK_DISPLAY_POWER_STATE_ON_EXT = 2,
04677                 VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT,
04678                 VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT,
04679                 VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1),
04680                 VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
04681         } VkDisplayPowerStateEXT;
04682 
04683         typedef enum VkDeviceEventTypeEXT {
04684                 VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
04685                 VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
04686                 VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
04687                 VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1),
04688                 VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
04689         } VkDeviceEventTypeEXT;
04690 
04691         typedef enum VkDisplayEventTypeEXT {
04692                 VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
04693                 VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
04694                 VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
04695                 VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1),
04696                 VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
04697         } VkDisplayEventTypeEXT;
04698 
04699         typedef struct VkDisplayPowerInfoEXT {
04700                 VkStructureType           sType;
04701                 const void*               pNext;
04702                 VkDisplayPowerStateEXT    powerState;
04703         } VkDisplayPowerInfoEXT;
04704 
04705         typedef struct VkDeviceEventInfoEXT {
04706                 VkStructureType         sType;
04707                 const void*             pNext;
04708                 VkDeviceEventTypeEXT    deviceEvent;
04709         } VkDeviceEventInfoEXT;
04710 
04711         typedef struct VkDisplayEventInfoEXT {
04712                 VkStructureType          sType;
04713                 const void*              pNext;
04714                 VkDisplayEventTypeEXT    displayEvent;
04715         } VkDisplayEventInfoEXT;
04716 
04717         typedef struct VkSwapchainCounterCreateInfoEXT {
04718                 VkStructureType             sType;
04719                 const void*                 pNext;
04720                 VkSurfaceCounterFlagsEXT    surfaceCounters;
04721         } VkSwapchainCounterCreateInfoEXT;
04722 
04723 
04724         typedef VkResult(VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
04725         typedef VkResult(VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
04726         typedef VkResult(VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
04727         typedef VkResult(VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
04728 
04729 #ifndef VK_NO_PROTOTYPES
04730         VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
04731                 VkDevice                                    device,
04732                 VkDisplayKHR                                display,
04733                 const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
04734 
04735         VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
04736                 VkDevice                                    device,
04737                 const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
04738                 const VkAllocationCallbacks*                pAllocator,
04739                 VkFence*                                    pFence);
04740 
04741         VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
04742                 VkDevice                                    device,
04743                 VkDisplayKHR                                display,
04744                 const VkDisplayEventInfoEXT*                pDisplayEventInfo,
04745                 const VkAllocationCallbacks*                pAllocator,
04746                 VkFence*                                    pFence);
04747 
04748         VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
04749                 VkDevice                                    device,
04750                 VkSwapchainKHR                              swapchain,
04751                 VkSurfaceCounterFlagBitsEXT                 counter,
04752                 uint64_t*                                   pCounterValue);
04753 #endif
04754 
04755 #define VK_EXT_swapchain_colorspace 1
04756 #define VK_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 1
04757 #define VK_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
04758 
04759 
04760 #ifdef __cplusplus
04761 }
04762 #endif
04763 
04764 #endif