include/vulkan/vulkan.h

   1 //
   2 // File: vulkan.h
   3 //
   4 /*
   5 ** Copyright (c) 2014-2015 The Khronos Group Inc.
   6 **
   7 ** Permission is hereby granted, free of charge, to any person obtaining a
   8 ** copy of this software and/or associated documentation files (the
   9 ** "Materials"), to deal in the Materials without restriction, including
  10 ** without limitation the rights to use, copy, modify, merge, publish,
  11 ** distribute, sublicense, and/or sell copies of the Materials, and to
  12 ** permit persons to whom the Materials are furnished to do so, subject to
  13 ** the following conditions:
  14 **
  15 ** The above copyright notice and this permission notice shall be included
  16 ** in all copies or substantial portions of the Materials.
  17 **
  18 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  22 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
  25 */
  26
  27 #ifndef __VULKAN_H__
  28 #define __VULKAN_H__
  29
  30 #define VK_MAKE_VERSION(major, minor, patch) \
  31     ((major << 22) | (minor << 12) | patch)
  32
  33 #include "vk_platform.h"
  34
  35 // Vulkan API version supported by this file
  36 #define VK_API_VERSION VK_MAKE_VERSION(0, 91, 0)
  37
  38 #ifdef __cplusplus
  39 extern "C"
  40 {
  41 #endif // __cplusplus
  42
  43 /*
  44 ***************************************************************************************************
  45 *   Core Vulkan API
  46 ***************************************************************************************************
  47 */
  48
  49 #if defined (__cplusplus) && (VK_UINTPTRLEAST64_MAX == UINTPTR_MAX)
  50     #define VK_TYPE_SAFE_COMPATIBLE_HANDLES 1
  51 #endif
  52
  53 #if defined(VK_TYPE_SAFE_COMPATIBLE_HANDLES) && !defined(VK_DISABLE_TYPE_SAFE_HANDLES)
  54     #define VK_DEFINE_PTR_HANDLE(_obj) struct _obj##_T { char _dummy; }; typedef _obj##_T* _obj;
  55     #define VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj;
  56
  57     #define VK_DEFINE_BASE_HANDLE(_obj) VK_DEFINE_PTR_HANDLE(_obj)
  58     #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base)
  59     #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) VK_DEFINE_PTR_SUBCLASS_HANDLE(_obj, _base)
  60 #else
  61     #define VK_DEFINE_BASE_HANDLE(_obj) typedef VkUintPtrLeast64 _obj;
  62     #define VK_DEFINE_DISP_SUBCLASS_HANDLE(_obj, _base) typedef uintptr_t _obj;
  63     #define VK_DEFINE_NONDISP_SUBCLASS_HANDLE(_obj, _base) typedef VkUintPtrLeast64 _obj;
  64 #endif
  65
  66 VK_DEFINE_BASE_HANDLE(VkObject)
  67
  68 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkInstance, VkObject)
  69 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkPhysicalDevice, VkObject)
  70 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkDevice, VkObject)
  71 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkQueue, VkObject)
  72 VK_DEFINE_DISP_SUBCLASS_HANDLE(VkCmdBuffer, VkObject)
  73
  74 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkNonDispatchable, VkObject)
  75 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDeviceMemory, VkNonDispatchable)
  76 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBuffer, VkNonDispatchable)
  77 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkBufferView, VkNonDispatchable)
  78 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImage, VkNonDispatchable)
  79 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkImageView, VkNonDispatchable)
  80 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkColorAttachmentView, VkNonDispatchable)
  81 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDepthStencilView, VkNonDispatchable)
  82 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkShader, VkNonDispatchable)
  83 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipeline, VkNonDispatchable)
  84 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkPipelineLayout, VkNonDispatchable)
  85 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSampler, VkNonDispatchable)
  86 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSet, VkNonDispatchable)
  87 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorSetLayout, VkNonDispatchable)
  88 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDescriptorPool, VkNonDispatchable)
  89 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicStateObject, VkNonDispatchable)
  90 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicVpState, VkDynamicStateObject)
  91 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicRsState, VkDynamicStateObject)
  92 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicCbState, VkDynamicStateObject)
  93 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkDynamicDsState, VkDynamicStateObject)
  94 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFence, VkNonDispatchable)
  95 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkSemaphore, VkNonDispatchable)
  96 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkEvent, VkNonDispatchable)
  97 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkQueryPool, VkNonDispatchable)
  98 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkFramebuffer, VkNonDispatchable)
  99 VK_DEFINE_NONDISP_SUBCLASS_HANDLE(VkRenderPass, VkNonDispatchable)
 100
 101 #define VK_MAX_PHYSICAL_DEVICE_NAME 256
 102 #define VK_MAX_EXTENSION_NAME       256
 103
 104 #define VK_LOD_CLAMP_NONE       MAX_FLOAT
 105
 106 #define VK_WHOLE_SIZE           UINT64_MAX
 107
 108 #define VK_TRUE  1
 109 #define VK_FALSE 0
 110
 111 #define VK_NULL_HANDLE 0
 112
 113 // This macro defines INT_MAX in enumerations to force compilers to use 32 bits
 114 // to represent them. This may or may not be necessary on some compilers. The
 115 // option to compile it out may allow compilers that warn about missing enumerants
 116 // in switch statements to be silenced.
 117 // Using this macro is not needed for flag bit enums because those aren't used
 118 // as storage type anywhere.
 119 #define VK_MAX_ENUM(Prefix) VK_##Prefix##_MAX_ENUM = 0x7FFFFFFF
 120
 121 // This macro defines the BEGIN_RANGE, END_RANGE, NUM, and MAX_ENUM constants for
 122 // the enumerations.
 123 #define VK_ENUM_RANGE(Prefix, First, Last) \
 124     VK_##Prefix##_BEGIN_RANGE                               = VK_##Prefix##_##First, \
 125     VK_##Prefix##_END_RANGE                                 = VK_##Prefix##_##Last, \
 126     VK_NUM_##Prefix                                         = (VK_##Prefix##_END_RANGE - VK_##Prefix##_BEGIN_RANGE + 1), \
 127     VK_MAX_ENUM(Prefix)
 128
 129 // This is a helper macro to define the value of flag bit enum values.
 130 #define VK_BIT(bit)     (1 << (bit))
 131
 132 // ------------------------------------------------------------------------------------------------
 133 // Enumerations
 134
 135 typedef enum VkMemoryPriority_
 136 {
 137     VK_MEMORY_PRIORITY_UNUSED                               = 0x00000000,
 138     VK_MEMORY_PRIORITY_VERY_LOW                             = 0x00000001,
 139     VK_MEMORY_PRIORITY_LOW                                  = 0x00000002,
 140     VK_MEMORY_PRIORITY_NORMAL                               = 0x00000003,
 141     VK_MEMORY_PRIORITY_HIGH                                 = 0x00000004,
 142     VK_MEMORY_PRIORITY_VERY_HIGH                            = 0x00000005,
 143
 144     VK_ENUM_RANGE(MEMORY_PRIORITY, UNUSED, VERY_HIGH)
 145 } VkMemoryPriority;
 146
 147 typedef enum VkImageLayout_
 148 {
 149     VK_IMAGE_LAYOUT_UNDEFINED                               = 0x00000000,   // Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
 150     VK_IMAGE_LAYOUT_GENERAL                                 = 0x00000001,   // General layout when image can be used for any kind of access
 151     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL                = 0x00000002,   // Optimal layout when image is only used for color attachment read/write
 152     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL        = 0x00000003,   // Optimal layout when image is only used for depth/stencil attachment read/write
 153     VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL         = 0x00000004,   // Optimal layout when image is used for read only depth/stencil attachment and shader access
 154     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL                = 0x00000005,   // Optimal layout when image is used for read only shader access
 155     VK_IMAGE_LAYOUT_CLEAR_OPTIMAL                           = 0x00000006,   // Optimal layout when image is used only for clear operations
 156     VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL                 = 0x00000007,   // Optimal layout when image is used only as source of transfer operations
 157     VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL            = 0x00000008,   // Optimal layout when image is used only as destination of transfer operations
 158
 159     VK_ENUM_RANGE(IMAGE_LAYOUT, UNDEFINED, TRANSFER_DESTINATION_OPTIMAL)
 160 } VkImageLayout;
 161
 162 typedef enum VkPipeEvent_
 163 {
 164     VK_PIPE_EVENT_TOP_OF_PIPE                               = 0x00000001,   // Set event before the device starts processing subsequent command
 165     VK_PIPE_EVENT_VERTEX_PROCESSING_COMPLETE                = 0x00000002,   // Set event when all pending vertex processing is complete
 166     VK_PIPE_EVENT_LOCAL_FRAGMENT_PROCESSING_COMPLETE        = 0x00000003,   // Set event when all pending fragment shader executions are complete, within each fragment location
 167     VK_PIPE_EVENT_FRAGMENT_PROCESSING_COMPLETE              = 0x00000004,   // Set event when all pending fragment shader executions are complete
 168     VK_PIPE_EVENT_GRAPHICS_PIPELINE_COMPLETE                = 0x00000005,   // Set event when all pending graphics operations are complete
 169     VK_PIPE_EVENT_COMPUTE_PIPELINE_COMPLETE                 = 0x00000006,   // Set event when all pending compute operations are complete
 170     VK_PIPE_EVENT_TRANSFER_COMPLETE                         = 0x00000007,   // Set event when all pending transfer operations are complete
 171     VK_PIPE_EVENT_COMMANDS_COMPLETE                         = 0x00000008,   // Set event when all pending work is complete
 172
 173     VK_ENUM_RANGE(PIPE_EVENT, TOP_OF_PIPE, COMMANDS_COMPLETE)
 174 } VkPipeEvent;
 175
 176 typedef enum VkWaitEvent_
 177 {
 178     VK_WAIT_EVENT_TOP_OF_PIPE                               = 0x00000001,   // Wait event before the device starts processing subsequent commands
 179     VK_WAIT_EVENT_BEFORE_RASTERIZATION                      = 0x00000002,   // Wait event before rasterizing subsequent primitives
 180
 181     VK_ENUM_RANGE(WAIT_EVENT, TOP_OF_PIPE, BEFORE_RASTERIZATION)
 182 } VkWaitEvent;
 183
 184 typedef enum VkAttachmentLoadOp_
 185 {
 186     VK_ATTACHMENT_LOAD_OP_LOAD                              = 0x00000000,
 187     VK_ATTACHMENT_LOAD_OP_CLEAR                             = 0x00000001,
 188     VK_ATTACHMENT_LOAD_OP_DONT_CARE                         = 0x00000002,
 189
 190     VK_ENUM_RANGE(ATTACHMENT_LOAD_OP, LOAD, DONT_CARE)
 191 } VkAttachmentLoadOp;
 192
 193 typedef enum VkAttachmentStoreOp_
 194 {
 195     VK_ATTACHMENT_STORE_OP_STORE                            = 0x00000000,
 196     VK_ATTACHMENT_STORE_OP_RESOLVE_MSAA                     = 0x00000001,
 197     VK_ATTACHMENT_STORE_OP_DONT_CARE                        = 0x00000002,
 198
 199     VK_ENUM_RANGE(ATTACHMENT_STORE_OP, STORE, DONT_CARE)
 200 } VkAttachmentStoreOp;
 201
 202 typedef enum VkImageType_
 203 {
 204     VK_IMAGE_TYPE_1D                                        = 0x00000000,
 205     VK_IMAGE_TYPE_2D                                        = 0x00000001,
 206     VK_IMAGE_TYPE_3D                                        = 0x00000002,
 207
 208     VK_ENUM_RANGE(IMAGE_TYPE, 1D, 3D)
 209 } VkImageType;
 210
 211 typedef enum VkImageTiling_
 212 {
 213     VK_IMAGE_TILING_LINEAR                                  = 0x00000000,
 214     VK_IMAGE_TILING_OPTIMAL                                 = 0x00000001,
 215
 216     VK_ENUM_RANGE(IMAGE_TILING, LINEAR, OPTIMAL)
 217 } VkImageTiling;
 218
 219 typedef enum VkImageViewType_
 220 {
 221     VK_IMAGE_VIEW_TYPE_1D                                   = 0x00000000,
 222     VK_IMAGE_VIEW_TYPE_2D                                   = 0x00000001,
 223     VK_IMAGE_VIEW_TYPE_3D                                   = 0x00000002,
 224     VK_IMAGE_VIEW_TYPE_CUBE                                 = 0x00000003,
 225
 226     VK_ENUM_RANGE(IMAGE_VIEW_TYPE, 1D, CUBE)
 227 } VkImageViewType;
 228
 229 typedef enum VkImageAspect_
 230 {
 231     VK_IMAGE_ASPECT_COLOR                                   = 0x00000000,
 232     VK_IMAGE_ASPECT_DEPTH                                   = 0x00000001,
 233     VK_IMAGE_ASPECT_STENCIL                                 = 0x00000002,
 234
 235     VK_ENUM_RANGE(IMAGE_ASPECT, COLOR, STENCIL)
 236 } VkImageAspect;
 237
 238 typedef enum VkBufferViewType_
 239 {
 240     VK_BUFFER_VIEW_TYPE_RAW                                 = 0x00000000,   // Raw buffer without special structure (UBO, SSBO)
 241     VK_BUFFER_VIEW_TYPE_FORMATTED                           = 0x00000001,   // Buffer with format (TBO, IBO)
 242
 243     VK_ENUM_RANGE(BUFFER_VIEW_TYPE, RAW, FORMATTED)
 244 } VkBufferViewType;
 245
 246 typedef enum VkChannelSwizzle_
 247 {
 248     VK_CHANNEL_SWIZZLE_ZERO                                 = 0x00000000,
 249     VK_CHANNEL_SWIZZLE_ONE                                  = 0x00000001,
 250     VK_CHANNEL_SWIZZLE_R                                    = 0x00000002,
 251     VK_CHANNEL_SWIZZLE_G                                    = 0x00000003,
 252     VK_CHANNEL_SWIZZLE_B                                    = 0x00000004,
 253     VK_CHANNEL_SWIZZLE_A                                    = 0x00000005,
 254
 255     VK_ENUM_RANGE(CHANNEL_SWIZZLE, ZERO, A)
 256 } VkChannelSwizzle;
 257
 258 typedef enum VkDescriptorType_
 259 {
 260     VK_DESCRIPTOR_TYPE_SAMPLER                              = 0x00000000,
 261     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER               = 0x00000001,
 262     VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE                        = 0x00000002,
 263     VK_DESCRIPTOR_TYPE_STORAGE_IMAGE                        = 0x00000003,
 264     VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER                 = 0x00000004,
 265     VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER                 = 0x00000005,
 266     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER                       = 0x00000006,
 267     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER                       = 0x00000007,
 268     VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC               = 0x00000008,
 269     VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC               = 0x00000009,
 270
 271     VK_ENUM_RANGE(DESCRIPTOR_TYPE, SAMPLER, STORAGE_BUFFER_DYNAMIC)
 272 } VkDescriptorType;
 273
 274 typedef enum VkDescriptorPoolUsage_
 275 {
 276     VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT                       = 0x00000000,
 277     VK_DESCRIPTOR_POOL_USAGE_DYNAMIC                        = 0x00000001,
 278
 279     VK_ENUM_RANGE(DESCRIPTOR_POOL_USAGE, ONE_SHOT, DYNAMIC)
 280 } VkDescriptorPoolUsage;
 281
 282 typedef enum VkDescriptorUpdateMode_
 283 {
 284     VK_DESCRIPTOR_UPDATE_MODE_COPY                          = 0x00000000,
 285     VK_DESCRIPTOR_UPDATE_MODE_FASTEST                       = 0x00000001,
 286
 287     VK_ENUM_RANGE(DESCRIPTOR_UPDATE_MODE, COPY, FASTEST)
 288 } VkDescriptorUpdateMode;
 289
 290 typedef enum VkDescriptorSetUsage_
 291 {
 292     VK_DESCRIPTOR_SET_USAGE_ONE_SHOT                        = 0x00000000,
 293     VK_DESCRIPTOR_SET_USAGE_STATIC                          = 0x00000001,
 294
 295     VK_ENUM_RANGE(DESCRIPTOR_SET_USAGE, ONE_SHOT, STATIC)
 296 } VkDescriptorSetUsage;
 297
 298 typedef enum VkQueryType_
 299 {
 300     VK_QUERY_TYPE_OCCLUSION                                 = 0x00000000,
 301     VK_QUERY_TYPE_PIPELINE_STATISTICS                       = 0x00000001, // Optional
 302
 303     VK_ENUM_RANGE(QUERY_TYPE, OCCLUSION, PIPELINE_STATISTICS)
 304 } VkQueryType;
 305
 306 typedef enum VkTimestampType_
 307 {
 308     VK_TIMESTAMP_TYPE_TOP                                   = 0x00000000,
 309     VK_TIMESTAMP_TYPE_BOTTOM                                = 0x00000001,
 310
 311     VK_ENUM_RANGE(TIMESTAMP_TYPE, TOP, BOTTOM)
 312 } VkTimestampType;
 313
 314 typedef enum VkBorderColor_
 315 {
 316     VK_BORDER_COLOR_OPAQUE_WHITE                            = 0x00000000,
 317     VK_BORDER_COLOR_TRANSPARENT_BLACK                       = 0x00000001,
 318     VK_BORDER_COLOR_OPAQUE_BLACK                            = 0x00000002,
 319
 320     VK_ENUM_RANGE(BORDER_COLOR, OPAQUE_WHITE, OPAQUE_BLACK)
 321 } VkBorderColor;
 322
 323 typedef enum VkPipelineBindPoint_
 324 {
 325     VK_PIPELINE_BIND_POINT_COMPUTE                          = 0x00000000,
 326     VK_PIPELINE_BIND_POINT_GRAPHICS                         = 0x00000001,
 327
 328     VK_ENUM_RANGE(PIPELINE_BIND_POINT, COMPUTE, GRAPHICS)
 329 } VkPipelineBindPoint;
 330
 331 typedef enum VkStateBindPoint_
 332 {
 333     VK_STATE_BIND_POINT_VIEWPORT                            = 0x00000000,
 334     VK_STATE_BIND_POINT_RASTER                              = 0x00000001,
 335     VK_STATE_BIND_POINT_COLOR_BLEND                         = 0x00000002,
 336     VK_STATE_BIND_POINT_DEPTH_STENCIL                       = 0x00000003,
 337
 338     VK_ENUM_RANGE(STATE_BIND_POINT, VIEWPORT, DEPTH_STENCIL)
 339 } VkStateBindPoint;
 340
 341 typedef enum VkPrimitiveTopology_
 342 {
 343     VK_PRIMITIVE_TOPOLOGY_POINT_LIST                        = 0x00000000,
 344     VK_PRIMITIVE_TOPOLOGY_LINE_LIST                         = 0x00000001,
 345     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP                        = 0x00000002,
 346     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST                     = 0x00000003,
 347     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP                    = 0x00000004,
 348     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN                      = 0x00000005,
 349     VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ                     = 0x00000006,
 350     VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ                    = 0x00000007,
 351     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ                 = 0x00000008,
 352     VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ                = 0x00000009,
 353     VK_PRIMITIVE_TOPOLOGY_PATCH                             = 0x0000000a,
 354
 355     VK_ENUM_RANGE(PRIMITIVE_TOPOLOGY, POINT_LIST, PATCH)
 356 } VkPrimitiveTopology;
 357
 358 typedef enum VkIndexType_
 359 {
 360     VK_INDEX_TYPE_UINT8                                     = 0x00000000,
 361     VK_INDEX_TYPE_UINT16                                    = 0x00000001,
 362     VK_INDEX_TYPE_UINT32                                    = 0x00000002,
 363
 364     VK_ENUM_RANGE(INDEX_TYPE, UINT8, UINT32)
 365 } VkIndexType;
 366
 367 typedef enum VkTexFilter_
 368 {
 369     VK_TEX_FILTER_NEAREST                                   = 0x00000000,
 370     VK_TEX_FILTER_LINEAR                                    = 0x00000001,
 371
 372     VK_ENUM_RANGE(TEX_FILTER, NEAREST, LINEAR)
 373 } VkTexFilter;
 374
 375 typedef enum VkTexMipmapMode_
 376 {
 377     VK_TEX_MIPMAP_MODE_BASE                                 = 0x00000000,   // Always choose base level
 378     VK_TEX_MIPMAP_MODE_NEAREST                              = 0x00000001,   // Choose nearest mip level
 379     VK_TEX_MIPMAP_MODE_LINEAR                               = 0x00000002,   // Linear filter between mip levels
 380
 381     VK_ENUM_RANGE(TEX_MIPMAP_MODE, BASE, LINEAR)
 382 } VkTexMipmapMode;
 383
 384 typedef enum VkTexAddress_
 385 {
 386     VK_TEX_ADDRESS_WRAP                                     = 0x00000000,
 387     VK_TEX_ADDRESS_MIRROR                                   = 0x00000001,
 388     VK_TEX_ADDRESS_CLAMP                                    = 0x00000002,
 389     VK_TEX_ADDRESS_MIRROR_ONCE                              = 0x00000003,
 390     VK_TEX_ADDRESS_CLAMP_BORDER                             = 0x00000004,
 391
 392     VK_ENUM_RANGE(TEX_ADDRESS, WRAP, CLAMP_BORDER)
 393 } VkTexAddress;
 394
 395 typedef enum VkCompareOp_
 396 {
 397     VK_COMPARE_OP_NEVER                                     = 0x00000000,
 398     VK_COMPARE_OP_LESS                                      = 0x00000001,
 399     VK_COMPARE_OP_EQUAL                                     = 0x00000002,
 400     VK_COMPARE_OP_LESS_EQUAL                                = 0x00000003,
 401     VK_COMPARE_OP_GREATER                                   = 0x00000004,
 402     VK_COMPARE_OP_NOT_EQUAL                                 = 0x00000005,
 403     VK_COMPARE_OP_GREATER_EQUAL                             = 0x00000006,
 404     VK_COMPARE_OP_ALWAYS                                    = 0x00000007,
 405
 406     VK_ENUM_RANGE(COMPARE_OP, NEVER, ALWAYS)
 407 } VkCompareOp;
 408
 409 typedef enum VkFillMode_
 410 {
 411     VK_FILL_MODE_POINTS                                     = 0x00000000,
 412     VK_FILL_MODE_WIREFRAME                                  = 0x00000001,
 413     VK_FILL_MODE_SOLID                                      = 0x00000002,
 414
 415     VK_ENUM_RANGE(FILL_MODE, POINTS, SOLID)
 416 } VkFillMode;
 417
 418 typedef enum VkCullMode_
 419 {
 420     VK_CULL_MODE_NONE                                       = 0x00000000,
 421     VK_CULL_MODE_FRONT                                      = 0x00000001,
 422     VK_CULL_MODE_BACK                                       = 0x00000002,
 423     VK_CULL_MODE_FRONT_AND_BACK                             = 0x00000003,
 424
 425     VK_ENUM_RANGE(CULL_MODE, NONE, FRONT_AND_BACK)
 426 } VkCullMode;
 427
 428 typedef enum VkFrontFace_
 429 {
 430     VK_FRONT_FACE_CCW                                       = 0x00000000,
 431     VK_FRONT_FACE_CW                                        = 0x00000001,
 432
 433     VK_ENUM_RANGE(FRONT_FACE, CCW, CW)
 434 } VkFrontFace;
 435
 436 typedef enum VkProvokingVertex_
 437 {
 438     VK_PROVOKING_VERTEX_FIRST                               = 0x00000000,
 439     VK_PROVOKING_VERTEX_LAST                                = 0x00000001,
 440
 441     VK_ENUM_RANGE(PROVOKING_VERTEX, FIRST, LAST)
 442 } VkProvokingVertex;
 443
 444 typedef enum VkCoordinateOrigin_
 445 {
 446     VK_COORDINATE_ORIGIN_UPPER_LEFT                         = 0x00000000,
 447     VK_COORDINATE_ORIGIN_LOWER_LEFT                         = 0x00000001,
 448
 449     VK_ENUM_RANGE(COORDINATE_ORIGIN, UPPER_LEFT, LOWER_LEFT)
 450 } VkCoordinateOrigin;
 451
 452 typedef enum VkDepthMode_
 453 {
 454     VK_DEPTH_MODE_ZERO_TO_ONE                               = 0x00000000,
 455     VK_DEPTH_MODE_NEGATIVE_ONE_TO_ONE                       = 0x00000001,
 456
 457     VK_ENUM_RANGE(DEPTH_MODE, ZERO_TO_ONE, NEGATIVE_ONE_TO_ONE)
 458 } VkDepthMode;
 459
 460 typedef enum VkBlend_
 461 {
 462     VK_BLEND_ZERO                                           = 0x00000000,
 463     VK_BLEND_ONE                                            = 0x00000001,
 464     VK_BLEND_SRC_COLOR                                      = 0x00000002,
 465     VK_BLEND_ONE_MINUS_SRC_COLOR                            = 0x00000003,
 466     VK_BLEND_DEST_COLOR                                     = 0x00000004,
 467     VK_BLEND_ONE_MINUS_DEST_COLOR                           = 0x00000005,
 468     VK_BLEND_SRC_ALPHA                                      = 0x00000006,
 469     VK_BLEND_ONE_MINUS_SRC_ALPHA                            = 0x00000007,
 470     VK_BLEND_DEST_ALPHA                                     = 0x00000008,
 471     VK_BLEND_ONE_MINUS_DEST_ALPHA                           = 0x00000009,
 472     VK_BLEND_CONSTANT_COLOR                                 = 0x0000000a,
 473     VK_BLEND_ONE_MINUS_CONSTANT_COLOR                       = 0x0000000b,
 474     VK_BLEND_CONSTANT_ALPHA                                 = 0x0000000c,
 475     VK_BLEND_ONE_MINUS_CONSTANT_ALPHA                       = 0x0000000d,
 476     VK_BLEND_SRC_ALPHA_SATURATE                             = 0x0000000e,
 477     VK_BLEND_SRC1_COLOR                                     = 0x0000000f,
 478     VK_BLEND_ONE_MINUS_SRC1_COLOR                           = 0x00000010,
 479     VK_BLEND_SRC1_ALPHA                                     = 0x00000011,
 480     VK_BLEND_ONE_MINUS_SRC1_ALPHA                           = 0x00000012,
 481
 482     VK_ENUM_RANGE(BLEND, ZERO, ONE_MINUS_SRC1_ALPHA)
 483 } VkBlend;
 484
 485 typedef enum VkBlendOp_
 486 {
 487     VK_BLEND_OP_ADD                                         = 0x00000000,
 488     VK_BLEND_OP_SUBTRACT                                    = 0x00000001,
 489     VK_BLEND_OP_REVERSE_SUBTRACT                            = 0x00000002,
 490     VK_BLEND_OP_MIN                                         = 0x00000003,
 491     VK_BLEND_OP_MAX                                         = 0x00000004,
 492
 493     VK_ENUM_RANGE(BLEND_OP, ADD, MAX)
 494 } VkBlendOp;
 495
 496 typedef enum VkStencilOp_
 497 {
 498     VK_STENCIL_OP_KEEP                                      = 0x00000000,
 499     VK_STENCIL_OP_ZERO                                      = 0x00000001,
 500     VK_STENCIL_OP_REPLACE                                   = 0x00000002,
 501     VK_STENCIL_OP_INC_CLAMP                                 = 0x00000003,
 502     VK_STENCIL_OP_DEC_CLAMP                                 = 0x00000004,
 503     VK_STENCIL_OP_INVERT                                    = 0x00000005,
 504     VK_STENCIL_OP_INC_WRAP                                  = 0x00000006,
 505     VK_STENCIL_OP_DEC_WRAP                                  = 0x00000007,
 506
 507     VK_ENUM_RANGE(STENCIL_OP, KEEP, DEC_WRAP)
 508 } VkStencilOp;
 509
 510 typedef enum VkLogicOp_
 511 {
 512     VK_LOGIC_OP_COPY                                        = 0x00000000,
 513     VK_LOGIC_OP_CLEAR                                       = 0x00000001,
 514     VK_LOGIC_OP_AND                                         = 0x00000002,
 515     VK_LOGIC_OP_AND_REVERSE                                 = 0x00000003,
 516     VK_LOGIC_OP_AND_INVERTED                                = 0x00000004,
 517     VK_LOGIC_OP_NOOP                                        = 0x00000005,
 518     VK_LOGIC_OP_XOR                                         = 0x00000006,
 519     VK_LOGIC_OP_OR                                          = 0x00000007,
 520     VK_LOGIC_OP_NOR                                         = 0x00000008,
 521     VK_LOGIC_OP_EQUIV                                       = 0x00000009,
 522     VK_LOGIC_OP_INVERT                                      = 0x0000000a,
 523     VK_LOGIC_OP_OR_REVERSE                                  = 0x0000000b,
 524     VK_LOGIC_OP_COPY_INVERTED                               = 0x0000000c,
 525     VK_LOGIC_OP_OR_INVERTED                                 = 0x0000000d,
 526     VK_LOGIC_OP_NAND                                        = 0x0000000e,
 527     VK_LOGIC_OP_SET                                         = 0x0000000f,
 528
 529     VK_ENUM_RANGE(LOGIC_OP, COPY, SET)
 530 } VkLogicOp;
 531
 532 typedef enum VkSystemAllocType_
 533 {
 534     VK_SYSTEM_ALLOC_TYPE_API_OBJECT                         = 0x00000000,
 535     VK_SYSTEM_ALLOC_TYPE_INTERNAL                           = 0x00000001,
 536     VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP                      = 0x00000002,
 537     VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER                    = 0x00000003,
 538     VK_SYSTEM_ALLOC_TYPE_DEBUG                              = 0x00000004,
 539
 540     VK_ENUM_RANGE(SYSTEM_ALLOC_TYPE, API_OBJECT, DEBUG)
 541 } VkSystemAllocType;
 542
 543 typedef enum VkPhysicalDeviceType_
 544 {
 545     VK_PHYSICAL_DEVICE_TYPE_OTHER                           = 0x00000000,
 546     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU                  = 0x00000001,
 547     VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU                    = 0x00000002,
 548     VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU                     = 0x00000003,
 549     VK_PHYSICAL_DEVICE_TYPE_CPU                             = 0x00000004,
 550
 551     VK_ENUM_RANGE(PHYSICAL_DEVICE_TYPE, OTHER, CPU)
 552 } VkPhysicalDeviceType;
 553
 554 typedef enum VkPhysicalDeviceInfoType_
 555 {
 556     // Info type for vkGetPhysicalDeviceInfo()
 557     VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES                 = 0x00000000,
 558     VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE                = 0x00000001,
 559     VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES           = 0x00000002,
 560     VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES          = 0x00000003,
 561
 562     VK_ENUM_RANGE(PHYSICAL_DEVICE_INFO_TYPE, PROPERTIES, MEMORY_PROPERTIES)
 563 } VkPhysicalDeviceInfoType;
 564
 565 typedef enum VkExtensionInfoType_
 566 {
 567     // Info type for vkGetGlobalExtensionInfo() and vkGetPhysicalDeviceExtensionInfo()
 568     VK_EXTENSION_INFO_TYPE_COUNT                            = 0x00000000,
 569     VK_EXTENSION_INFO_TYPE_PROPERTIES                       = 0x00000001,
 570
 571     VK_ENUM_RANGE(EXTENSION_INFO_TYPE, COUNT, PROPERTIES)
 572 } VkExtensionInfoType;
 573
 574 typedef enum VkFormatInfoType_
 575 {
 576     // Info type for vkGetFormatInfo()
 577     VK_FORMAT_INFO_TYPE_PROPERTIES                          = 0x00000000,
 578
 579     VK_ENUM_RANGE(FORMAT_INFO_TYPE, PROPERTIES, PROPERTIES)
 580 } VkFormatInfoType;
 581
 582 typedef enum VkSubresourceInfoType_
 583 {
 584     // Info type for vkGetImageSubresourceInfo()
 585     VK_SUBRESOURCE_INFO_TYPE_LAYOUT                         = 0x00000000,
 586
 587     VK_ENUM_RANGE(SUBRESOURCE_INFO_TYPE, LAYOUT, LAYOUT)
 588 } VkSubresourceInfoType;
 589
 590 typedef enum VkObjectInfoType_
 591 {
 592     // Info type for vkGetObjectInfo()
 593     VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT             = 0x00000000,
 594     VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS                 = 0x00000001,
 595
 596     VK_ENUM_RANGE(OBJECT_INFO_TYPE, MEMORY_ALLOCATION_COUNT, MEMORY_REQUIREMENTS)
 597 } VkObjectInfoType;
 598
 599 typedef enum VkVertexInputStepRate_
 600 {
 601     VK_VERTEX_INPUT_STEP_RATE_VERTEX                        = 0x0,
 602     VK_VERTEX_INPUT_STEP_RATE_INSTANCE                      = 0x1,
 603     VK_VERTEX_INPUT_STEP_RATE_DRAW                          = 0x2,  //Optional
 604
 605     VK_ENUM_RANGE(VERTEX_INPUT_STEP_RATE, VERTEX, DRAW)
 606 } VkVertexInputStepRate;
 607
 608 // Vulkan format definitions
 609 typedef enum VkFormat_
 610 {
 611     VK_FORMAT_UNDEFINED                                     = 0x00000000,
 612     VK_FORMAT_R4G4_UNORM                                    = 0x00000001,
 613     VK_FORMAT_R4G4_USCALED                                  = 0x00000002,
 614     VK_FORMAT_R4G4B4A4_UNORM                                = 0x00000003,
 615     VK_FORMAT_R4G4B4A4_USCALED                              = 0x00000004,
 616     VK_FORMAT_R5G6B5_UNORM                                  = 0x00000005,
 617     VK_FORMAT_R5G6B5_USCALED                                = 0x00000006,
 618     VK_FORMAT_R5G5B5A1_UNORM                                = 0x00000007,
 619     VK_FORMAT_R5G5B5A1_USCALED                              = 0x00000008,
 620     VK_FORMAT_R8_UNORM                                      = 0x00000009,
 621     VK_FORMAT_R8_SNORM                                      = 0x0000000A,
 622     VK_FORMAT_R8_USCALED                                    = 0x0000000B,
 623     VK_FORMAT_R8_SSCALED                                    = 0x0000000C,
 624     VK_FORMAT_R8_UINT                                       = 0x0000000D,
 625     VK_FORMAT_R8_SINT                                       = 0x0000000E,
 626     VK_FORMAT_R8_SRGB                                       = 0x0000000F,
 627     VK_FORMAT_R8G8_UNORM                                    = 0x00000010,
 628     VK_FORMAT_R8G8_SNORM                                    = 0x00000011,
 629     VK_FORMAT_R8G8_USCALED                                  = 0x00000012,
 630     VK_FORMAT_R8G8_SSCALED                                  = 0x00000013,
 631     VK_FORMAT_R8G8_UINT                                     = 0x00000014,
 632     VK_FORMAT_R8G8_SINT                                     = 0x00000015,
 633     VK_FORMAT_R8G8_SRGB                                     = 0x00000016,
 634     VK_FORMAT_R8G8B8_UNORM                                  = 0x00000017,
 635     VK_FORMAT_R8G8B8_SNORM                                  = 0x00000018,
 636     VK_FORMAT_R8G8B8_USCALED                                = 0x00000019,
 637     VK_FORMAT_R8G8B8_SSCALED                                = 0x0000001A,
 638     VK_FORMAT_R8G8B8_UINT                                   = 0x0000001B,
 639     VK_FORMAT_R8G8B8_SINT                                   = 0x0000001C,
 640     VK_FORMAT_R8G8B8_SRGB                                   = 0x0000001D,
 641     VK_FORMAT_R8G8B8A8_UNORM                                = 0x0000001E,
 642     VK_FORMAT_R8G8B8A8_SNORM                                = 0x0000001F,
 643     VK_FORMAT_R8G8B8A8_USCALED                              = 0x00000020,
 644     VK_FORMAT_R8G8B8A8_SSCALED                              = 0x00000021,
 645     VK_FORMAT_R8G8B8A8_UINT                                 = 0x00000022,
 646     VK_FORMAT_R8G8B8A8_SINT                                 = 0x00000023,
 647     VK_FORMAT_R8G8B8A8_SRGB                                 = 0x00000024,
 648     VK_FORMAT_R10G10B10A2_UNORM                             = 0x00000025,
 649     VK_FORMAT_R10G10B10A2_SNORM                             = 0x00000026,
 650     VK_FORMAT_R10G10B10A2_USCALED                           = 0x00000027,
 651     VK_FORMAT_R10G10B10A2_SSCALED                           = 0x00000028,
 652     VK_FORMAT_R10G10B10A2_UINT                              = 0x00000029,
 653     VK_FORMAT_R10G10B10A2_SINT                              = 0x0000002A,
 654     VK_FORMAT_R16_UNORM                                     = 0x0000002B,
 655     VK_FORMAT_R16_SNORM                                     = 0x0000002C,
 656     VK_FORMAT_R16_USCALED                                   = 0x0000002D,
 657     VK_FORMAT_R16_SSCALED                                   = 0x0000002E,
 658     VK_FORMAT_R16_UINT                                      = 0x0000002F,
 659     VK_FORMAT_R16_SINT                                      = 0x00000030,
 660     VK_FORMAT_R16_SFLOAT                                    = 0x00000031,
 661     VK_FORMAT_R16G16_UNORM                                  = 0x00000032,
 662     VK_FORMAT_R16G16_SNORM                                  = 0x00000033,
 663     VK_FORMAT_R16G16_USCALED                                = 0x00000034,
 664     VK_FORMAT_R16G16_SSCALED                                = 0x00000035,
 665     VK_FORMAT_R16G16_UINT                                   = 0x00000036,
 666     VK_FORMAT_R16G16_SINT                                   = 0x00000037,
 667     VK_FORMAT_R16G16_SFLOAT                                 = 0x00000038,
 668     VK_FORMAT_R16G16B16_UNORM                               = 0x00000039,
 669     VK_FORMAT_R16G16B16_SNORM                               = 0x0000003A,
 670     VK_FORMAT_R16G16B16_USCALED                             = 0x0000003B,
 671     VK_FORMAT_R16G16B16_SSCALED                             = 0x0000003C,
 672     VK_FORMAT_R16G16B16_UINT                                = 0x0000003D,
 673     VK_FORMAT_R16G16B16_SINT                                = 0x0000003E,
 674     VK_FORMAT_R16G16B16_SFLOAT                              = 0x0000003F,
 675     VK_FORMAT_R16G16B16A16_UNORM                            = 0x00000040,
 676     VK_FORMAT_R16G16B16A16_SNORM                            = 0x00000041,
 677     VK_FORMAT_R16G16B16A16_USCALED                          = 0x00000042,
 678     VK_FORMAT_R16G16B16A16_SSCALED                          = 0x00000043,
 679     VK_FORMAT_R16G16B16A16_UINT                             = 0x00000044,
 680     VK_FORMAT_R16G16B16A16_SINT                             = 0x00000045,
 681     VK_FORMAT_R16G16B16A16_SFLOAT                           = 0x00000046,
 682     VK_FORMAT_R32_UINT                                      = 0x00000047,
 683     VK_FORMAT_R32_SINT                                      = 0x00000048,
 684     VK_FORMAT_R32_SFLOAT                                    = 0x00000049,
 685     VK_FORMAT_R32G32_UINT                                   = 0x0000004A,
 686     VK_FORMAT_R32G32_SINT                                   = 0x0000004B,
 687     VK_FORMAT_R32G32_SFLOAT                                 = 0x0000004C,
 688     VK_FORMAT_R32G32B32_UINT                                = 0x0000004D,
 689     VK_FORMAT_R32G32B32_SINT                                = 0x0000004E,
 690     VK_FORMAT_R32G32B32_SFLOAT                              = 0x0000004F,
 691     VK_FORMAT_R32G32B32A32_UINT                             = 0x00000050,
 692     VK_FORMAT_R32G32B32A32_SINT                             = 0x00000051,
 693     VK_FORMAT_R32G32B32A32_SFLOAT                           = 0x00000052,
 694     VK_FORMAT_R64_SFLOAT                                    = 0x00000053,
 695     VK_FORMAT_R64G64_SFLOAT                                 = 0x00000054,
 696     VK_FORMAT_R64G64B64_SFLOAT                              = 0x00000055,
 697     VK_FORMAT_R64G64B64A64_SFLOAT                           = 0x00000056,
 698     VK_FORMAT_R11G11B10_UFLOAT                              = 0x00000057,
 699     VK_FORMAT_R9G9B9E5_UFLOAT                               = 0x00000058,
 700     VK_FORMAT_D16_UNORM                                     = 0x00000059,
 701     VK_FORMAT_D24_UNORM                                     = 0x0000005A,
 702     VK_FORMAT_D32_SFLOAT                                    = 0x0000005B,
 703     VK_FORMAT_S8_UINT                                       = 0x0000005C,
 704     VK_FORMAT_D16_UNORM_S8_UINT                             = 0x0000005D,
 705     VK_FORMAT_D24_UNORM_S8_UINT                             = 0x0000005E,
 706     VK_FORMAT_D32_SFLOAT_S8_UINT                            = 0x0000005F,
 707     VK_FORMAT_BC1_RGB_UNORM                                 = 0x00000060,
 708     VK_FORMAT_BC1_RGB_SRGB                                  = 0x00000061,
 709     VK_FORMAT_BC1_RGBA_UNORM                                = 0x00000062,
 710     VK_FORMAT_BC1_RGBA_SRGB                                 = 0x00000063,
 711     VK_FORMAT_BC2_UNORM                                     = 0x00000064,
 712     VK_FORMAT_BC2_SRGB                                      = 0x00000065,
 713     VK_FORMAT_BC3_UNORM                                     = 0x00000066,
 714     VK_FORMAT_BC3_SRGB                                      = 0x00000067,
 715     VK_FORMAT_BC4_UNORM                                     = 0x00000068,
 716     VK_FORMAT_BC4_SNORM                                     = 0x00000069,
 717     VK_FORMAT_BC5_UNORM                                     = 0x0000006A,
 718     VK_FORMAT_BC5_SNORM                                     = 0x0000006B,
 719     VK_FORMAT_BC6H_UFLOAT                                   = 0x0000006C,
 720     VK_FORMAT_BC6H_SFLOAT                                   = 0x0000006D,
 721     VK_FORMAT_BC7_UNORM                                     = 0x0000006E,
 722     VK_FORMAT_BC7_SRGB                                      = 0x0000006F,
 723     VK_FORMAT_ETC2_R8G8B8_UNORM                             = 0x00000070,
 724     VK_FORMAT_ETC2_R8G8B8_SRGB                              = 0x00000071,
 725     VK_FORMAT_ETC2_R8G8B8A1_UNORM                           = 0x00000072,
 726     VK_FORMAT_ETC2_R8G8B8A1_SRGB                            = 0x00000073,
 727     VK_FORMAT_ETC2_R8G8B8A8_UNORM                           = 0x00000074,
 728     VK_FORMAT_ETC2_R8G8B8A8_SRGB                            = 0x00000075,
 729     VK_FORMAT_EAC_R11_UNORM                                 = 0x00000076,
 730     VK_FORMAT_EAC_R11_SNORM                                 = 0x00000077,
 731     VK_FORMAT_EAC_R11G11_UNORM                              = 0x00000078,
 732     VK_FORMAT_EAC_R11G11_SNORM                              = 0x00000079,
 733     VK_FORMAT_ASTC_4x4_UNORM                                = 0x0000007A,
 734     VK_FORMAT_ASTC_4x4_SRGB                                 = 0x0000007B,
 735     VK_FORMAT_ASTC_5x4_UNORM                                = 0x0000007C,
 736     VK_FORMAT_ASTC_5x4_SRGB                                 = 0x0000007D,
 737     VK_FORMAT_ASTC_5x5_UNORM                                = 0x0000007E,
 738     VK_FORMAT_ASTC_5x5_SRGB                                 = 0x0000007F,
 739     VK_FORMAT_ASTC_6x5_UNORM                                = 0x00000080,
 740     VK_FORMAT_ASTC_6x5_SRGB                                 = 0x00000081,
 741     VK_FORMAT_ASTC_6x6_UNORM                                = 0x00000082,
 742     VK_FORMAT_ASTC_6x6_SRGB                                 = 0x00000083,
 743     VK_FORMAT_ASTC_8x5_UNORM                                = 0x00000084,
 744     VK_FORMAT_ASTC_8x5_SRGB                                 = 0x00000085,
 745     VK_FORMAT_ASTC_8x6_UNORM                                = 0x00000086,
 746     VK_FORMAT_ASTC_8x6_SRGB                                 = 0x00000087,
 747     VK_FORMAT_ASTC_8x8_UNORM                                = 0x00000088,
 748     VK_FORMAT_ASTC_8x8_SRGB                                 = 0x00000089,
 749     VK_FORMAT_ASTC_10x5_UNORM                               = 0x0000008A,
 750     VK_FORMAT_ASTC_10x5_SRGB                                = 0x0000008B,
 751     VK_FORMAT_ASTC_10x6_UNORM                               = 0x0000008C,
 752     VK_FORMAT_ASTC_10x6_SRGB                                = 0x0000008D,
 753     VK_FORMAT_ASTC_10x8_UNORM                               = 0x0000008E,
 754     VK_FORMAT_ASTC_10x8_SRGB                                = 0x0000008F,
 755     VK_FORMAT_ASTC_10x10_UNORM                              = 0x00000090,
 756     VK_FORMAT_ASTC_10x10_SRGB                               = 0x00000091,
 757     VK_FORMAT_ASTC_12x10_UNORM                              = 0x00000092,
 758     VK_FORMAT_ASTC_12x10_SRGB                               = 0x00000093,
 759     VK_FORMAT_ASTC_12x12_UNORM                              = 0x00000094,
 760     VK_FORMAT_ASTC_12x12_SRGB                               = 0x00000095,
 761     VK_FORMAT_B4G4R4A4_UNORM                                = 0x00000096,
 762     VK_FORMAT_B5G5R5A1_UNORM                                = 0x00000097,
 763     VK_FORMAT_B5G6R5_UNORM                                  = 0x00000098,
 764     VK_FORMAT_B5G6R5_USCALED                                = 0x00000099,
 765     VK_FORMAT_B8G8R8_UNORM                                  = 0x0000009A,
 766     VK_FORMAT_B8G8R8_SNORM                                  = 0x0000009B,
 767     VK_FORMAT_B8G8R8_USCALED                                = 0x0000009C,
 768     VK_FORMAT_B8G8R8_SSCALED                                = 0x0000009D,
 769     VK_FORMAT_B8G8R8_UINT                                   = 0x0000009E,
 770     VK_FORMAT_B8G8R8_SINT                                   = 0x0000009F,
 771     VK_FORMAT_B8G8R8_SRGB                                   = 0x000000A0,
 772     VK_FORMAT_B8G8R8A8_UNORM                                = 0x000000A1,
 773     VK_FORMAT_B8G8R8A8_SNORM                                = 0x000000A2,
 774     VK_FORMAT_B8G8R8A8_USCALED                              = 0x000000A3,
 775     VK_FORMAT_B8G8R8A8_SSCALED                              = 0x000000A4,
 776     VK_FORMAT_B8G8R8A8_UINT                                 = 0x000000A5,
 777     VK_FORMAT_B8G8R8A8_SINT                                 = 0x000000A6,
 778     VK_FORMAT_B8G8R8A8_SRGB                                 = 0x000000A7,
 779     VK_FORMAT_B10G10R10A2_UNORM                             = 0x000000A8,
 780     VK_FORMAT_B10G10R10A2_SNORM                             = 0x000000A9,
 781     VK_FORMAT_B10G10R10A2_USCALED                           = 0x000000AA,
 782     VK_FORMAT_B10G10R10A2_SSCALED                           = 0x000000AB,
 783     VK_FORMAT_B10G10R10A2_UINT                              = 0x000000AC,
 784     VK_FORMAT_B10G10R10A2_SINT                              = 0x000000AD,
 785
 786     VK_ENUM_RANGE(FORMAT, UNDEFINED, B10G10R10A2_SINT)
 787 } VkFormat;
 788
 789 // Shader stage enumerant
 790 typedef enum VkShaderStage_
 791 {
 792     VK_SHADER_STAGE_VERTEX                                  = 0,
 793     VK_SHADER_STAGE_TESS_CONTROL                            = 1,
 794     VK_SHADER_STAGE_TESS_EVALUATION                         = 2,
 795     VK_SHADER_STAGE_GEOMETRY                                = 3,
 796     VK_SHADER_STAGE_FRAGMENT                                = 4,
 797     VK_SHADER_STAGE_COMPUTE                                 = 5,
 798
 799     VK_ENUM_RANGE(SHADER_STAGE, VERTEX, COMPUTE)
 800 } VkShaderStage;
 801
 802 // Structure type enumerant
 803 typedef enum VkStructureType_
 804 {
 805     VK_STRUCTURE_TYPE_APPLICATION_INFO                      = 0,
 806     VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO                    = 1,
 807     VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO                     = 2,
 808     VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO                      = 3,
 809     VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO                 = 4,
 810     VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO               = 5,
 811     VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO                = 6,
 812     VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO                = 7,
 813     VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO     = 8,
 814     VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO        = 9,
 815     VK_STRUCTURE_TYPE_SHADER_CREATE_INFO                    = 10,
 816     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO          = 11,
 817     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO                   = 12,
 818     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO     = 13,
 819     VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO          = 14,
 820     VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO          = 15,
 821     VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO          = 16,
 822     VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO          = 17,
 823     VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO                = 18,
 824     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO                     = 19,
 825     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO                     = 20,
 826     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO                 = 21,
 827     VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO                   = 22,
 828     VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO                = 23,
 829     VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO     = 24,
 830     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO         = 25,
 831     VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO     = 26,
 832     VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO         = 27,
 833     VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO       = 28,
 834     VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO         = 29,
 835     VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO         = 30,
 836     VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO         = 31,
 837     VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO         = 32,
 838     VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO         = 33,
 839     VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO                     = 34,
 840     VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO                    = 35,
 841     VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO               = 36,
 842     VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO               = 37,
 843     VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO                 = 38,
 844     VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO        = 39,
 845     VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO               = 40,
 846     VK_STRUCTURE_TYPE_LAYER_CREATE_INFO                     = 41,
 847     VK_STRUCTURE_TYPE_MEMORY_BARRIER                        = 42,
 848     VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER                 = 43,
 849     VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER                  = 44,
 850     VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO           = 45,
 851     VK_STRUCTURE_TYPE_UPDATE_SAMPLERS                       = 46,
 852     VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES               = 47,
 853     VK_STRUCTURE_TYPE_UPDATE_IMAGES                         = 48,
 854     VK_STRUCTURE_TYPE_UPDATE_BUFFERS                        = 49,
 855     VK_STRUCTURE_TYPE_UPDATE_AS_COPY                        = 50,
 856     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO                  = 51,
 857     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO           = 52,
 858
 859     VK_ENUM_RANGE(STRUCTURE_TYPE, APPLICATION_INFO, PIPELINE_LAYOUT_CREATE_INFO)
 860 } VkStructureType;
 861
 862 // Object type enumerant
 863 typedef enum VkObjectType_
 864 {
 865     VK_OBJECT_TYPE_INSTANCE                                 = 0,
 866     VK_OBJECT_TYPE_PHYSICAL_DEVICE                          = 1,
 867     VK_OBJECT_TYPE_DEVICE                                   = 2,
 868     VK_OBJECT_TYPE_QUEUE                                    = 3,
 869     VK_OBJECT_TYPE_COMMAND_BUFFER                           = 4,
 870     VK_OBJECT_TYPE_DEVICE_MEMORY                            = 5,
 871     VK_OBJECT_TYPE_BUFFER                                   = 6,
 872     VK_OBJECT_TYPE_BUFFER_VIEW                              = 7,
 873     VK_OBJECT_TYPE_IMAGE                                    = 8,
 874     VK_OBJECT_TYPE_IMAGE_VIEW                               = 9,
 875     VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW                    = 10,
 876     VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW                       = 11,
 877     VK_OBJECT_TYPE_SHADER                                   = 12,
 878     VK_OBJECT_TYPE_PIPELINE                                 = 13,
 879     VK_OBJECT_TYPE_PIPELINE_LAYOUT                          = 14,
 880     VK_OBJECT_TYPE_SAMPLER                                  = 15,
 881     VK_OBJECT_TYPE_DESCRIPTOR_SET                           = 16,
 882     VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT                    = 17,
 883     VK_OBJECT_TYPE_DESCRIPTOR_POOL                          = 18,
 884     VK_OBJECT_TYPE_DYNAMIC_VP_STATE                         = 19,
 885     VK_OBJECT_TYPE_DYNAMIC_RS_STATE                         = 20,
 886     VK_OBJECT_TYPE_DYNAMIC_CB_STATE                         = 21,
 887     VK_OBJECT_TYPE_DYNAMIC_DS_STATE                         = 22,
 888     VK_OBJECT_TYPE_FENCE                                    = 23,
 889     VK_OBJECT_TYPE_SEMAPHORE                                = 24,
 890     VK_OBJECT_TYPE_EVENT                                    = 25,
 891     VK_OBJECT_TYPE_QUERY_POOL                               = 26,
 892     VK_OBJECT_TYPE_FRAMEBUFFER                              = 27,
 893     VK_OBJECT_TYPE_RENDER_PASS                              = 28,
 894
 895     // Valid ranges for core Vulkan:
 896     VK_OBJECT_TYPE_BEGIN_RANGE                              = VK_OBJECT_TYPE_INSTANCE,
 897     VK_OBJECT_TYPE_END_RANGE                                = VK_OBJECT_TYPE_RENDER_PASS,
 898     VK_NUM_OBJECT_TYPE                                      = (VK_OBJECT_TYPE_END_RANGE - VK_OBJECT_TYPE_BEGIN_RANGE + 1),
 899     VK_MAX_ENUM(VkObjectType)
 900 } VkObjectType;
 901
 902 // ------------------------------------------------------------------------------------------------
 903 // Error and return codes
 904
 905 typedef enum VkResult_
 906 {
 907     // Return codes for successful operation execution (> = 0)
 908     VK_SUCCESS                                              = 0x0000000,
 909     VK_UNSUPPORTED                                          = 0x0000001,
 910     VK_NOT_READY                                            = 0x0000002,
 911     VK_TIMEOUT                                              = 0x0000003,
 912     VK_EVENT_SET                                            = 0x0000004,
 913     VK_EVENT_RESET                                          = 0x0000005,
 914
 915     // Error codes (negative values)
 916     VK_ERROR_UNKNOWN                                        = -(0x00000001),
 917     VK_ERROR_UNAVAILABLE                                    = -(0x00000002),
 918     VK_ERROR_INITIALIZATION_FAILED                          = -(0x00000003),
 919     VK_ERROR_OUT_OF_HOST_MEMORY                             = -(0x00000004),
 920     VK_ERROR_OUT_OF_DEVICE_MEMORY                           = -(0x00000005),
 921     VK_ERROR_DEVICE_ALREADY_CREATED                         = -(0x00000006),
 922     VK_ERROR_DEVICE_LOST                                    = -(0x00000007),
 923     VK_ERROR_INVALID_POINTER                                = -(0x00000008),
 924     VK_ERROR_INVALID_VALUE                                  = -(0x00000009),
 925     VK_ERROR_INVALID_HANDLE                                 = -(0x0000000A),
 926     VK_ERROR_INVALID_ORDINAL                                = -(0x0000000B),
 927     VK_ERROR_INVALID_MEMORY_SIZE                            = -(0x0000000C),
 928     VK_ERROR_INVALID_EXTENSION                              = -(0x0000000D),
 929     VK_ERROR_INVALID_FLAGS                                  = -(0x0000000E),
 930     VK_ERROR_INVALID_ALIGNMENT                              = -(0x0000000F),
 931     VK_ERROR_INVALID_FORMAT                                 = -(0x00000010),
 932     VK_ERROR_INVALID_IMAGE                                  = -(0x00000011),
 933     VK_ERROR_INVALID_DESCRIPTOR_SET_DATA                    = -(0x00000012),
 934     VK_ERROR_INVALID_QUEUE_TYPE                             = -(0x00000013),
 935     VK_ERROR_INVALID_OBJECT_TYPE                            = -(0x00000014),
 936     VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION                  = -(0x00000015),
 937     VK_ERROR_BAD_SHADER_CODE                                = -(0x00000016),
 938     VK_ERROR_BAD_PIPELINE_DATA                              = -(0x00000017),
 939     VK_ERROR_TOO_MANY_MEMORY_REFERENCES                     = -(0x00000018),
 940     VK_ERROR_NOT_MAPPABLE                                   = -(0x00000019),
 941     VK_ERROR_MEMORY_MAP_FAILED                              = -(0x0000001A),
 942     VK_ERROR_MEMORY_UNMAP_FAILED                            = -(0x0000001B),
 943     VK_ERROR_INCOMPATIBLE_DEVICE                            = -(0x0000001C),
 944     VK_ERROR_INCOMPATIBLE_DRIVER                            = -(0x0000001D),
 945     VK_ERROR_INCOMPLETE_COMMAND_BUFFER                      = -(0x0000001E),
 946     VK_ERROR_BUILDING_COMMAND_BUFFER                        = -(0x0000001F),
 947     VK_ERROR_MEMORY_NOT_BOUND                               = -(0x00000020),
 948     VK_ERROR_INCOMPATIBLE_QUEUE                             = -(0x00000021),
 949     VK_ERROR_NOT_SHAREABLE                                  = -(0x00000022),
 950
 951     VK_MAX_ENUM(RESULT)
 952 } VkResult;
 953
 954 // ------------------------------------------------------------------------------------------------
 955 // Flags
 956
 957 // Device creation flags
 958 typedef VkFlags VkDeviceCreateFlags;
 959 typedef enum VkDeviceCreateFlagBits_
 960 {
 961     VK_DEVICE_CREATE_VALIDATION_BIT                         = VK_BIT(0),
 962     VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT              = VK_BIT(1),
 963 } VkDeviceCreateFlagBits;
 964
 965 // Queue capabilities
 966 typedef VkFlags VkQueueFlags;
 967 typedef enum VkQueueFlagBits_
 968 {
 969     VK_QUEUE_GRAPHICS_BIT                                   = VK_BIT(0),    // Queue supports graphics operations
 970     VK_QUEUE_COMPUTE_BIT                                    = VK_BIT(1),    // Queue supports compute operations
 971     VK_QUEUE_DMA_BIT                                        = VK_BIT(2),    // Queue supports DMA operations
 972     VK_QUEUE_MEMMGR_BIT                                     = VK_BIT(3),    // Queue supports memory management operations
 973     VK_QUEUE_EXTENDED_BIT                                   = VK_BIT(30),   // Extended queue
 974 } VkQueueFlagBits;
 975
 976 // Memory properties passed into vkAllocMemory().
 977 typedef VkFlags VkMemoryPropertyFlags;
 978 typedef enum VkMemoryPropertyFlagBits_
 979 {
 980     VK_MEMORY_PROPERTY_DEVICE_ONLY                          = 0,            // If otherwise stated, then allocate memory on device
 981     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT                     = VK_BIT(0),    // Memory should be mappable by host
 982     VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT             = VK_BIT(1),    // Memory should be coherent between host and device accesses
 983     VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT                    = VK_BIT(2),    // Memory should not be cached by the host
 984     VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT              = VK_BIT(3),    // Memory should support host write combining
 985     VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL                    = VK_BIT(4),    // If set, prefer host access
 986     VK_MEMORY_PROPERTY_SHAREABLE_BIT                        = VK_BIT(5),
 987 } VkMemoryPropertyFlagBits;
 988
 989 // Memory output flags passed to resource transition commands
 990 typedef VkFlags VkMemoryOutputFlags;
 991 typedef enum VkMemoryOutputFlagBits_
 992 {
 993     VK_MEMORY_OUTPUT_CPU_WRITE_BIT                          = VK_BIT(0),    // Controls output coherency of CPU writes
 994     VK_MEMORY_OUTPUT_SHADER_WRITE_BIT                       = VK_BIT(1),    // Controls output coherency of generic shader writes
 995     VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT                   = VK_BIT(2),    // Controls output coherency of color attachment writes
 996     VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT           = VK_BIT(3),    // Controls output coherency of depth/stencil attachment writes
 997     VK_MEMORY_OUTPUT_TRANSFER_BIT                           = VK_BIT(4),    // Controls output coherency of transfer operations
 998 } VkMemoryOutputFlagBits;
 999
1000 // Memory input flags passed to resource transition commands
1001 typedef VkFlags VkMemoryInputFlags;
1002 typedef enum VkMemoryInputFlagBits_
1003 {
1004     VK_MEMORY_INPUT_CPU_READ_BIT                            = VK_BIT(0),    // Controls input coherency of CPU reads
1005     VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT                    = VK_BIT(1),    // Controls input coherency of indirect command reads
1006     VK_MEMORY_INPUT_INDEX_FETCH_BIT                         = VK_BIT(2),    // Controls input coherency of index fetches
1007     VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT              = VK_BIT(3),    // Controls input coherency of vertex attribute fetches
1008     VK_MEMORY_INPUT_UNIFORM_READ_BIT                        = VK_BIT(4),    // Controls input coherency of uniform buffer reads
1009     VK_MEMORY_INPUT_SHADER_READ_BIT                         = VK_BIT(5),    // Controls input coherency of generic shader reads
1010     VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT                    = VK_BIT(6),    // Controls input coherency of color attachment reads
1011     VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT            = VK_BIT(7),    // Controls input coherency of depth/stencil attachment reads
1012     VK_MEMORY_INPUT_TRANSFER_BIT                            = VK_BIT(8),    // Controls input coherency of transfer operations
1013 } VkMemoryInputFlagBits;
1014
1015 // Buffer usage flags
1016 typedef VkFlags VkBufferUsageFlags;
1017 typedef enum VkBufferUsageFlagBits_
1018 {
1019     VK_BUFFER_USAGE_GENERAL                                 = 0,            // No special usage
1020     VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT                     = VK_BIT(0),    // Can be used as a source of transfer operations
1021     VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT                = VK_BIT(1),    // Can be used as a destination of transfer operations
1022     VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT                = VK_BIT(2),    // Can be used as TBO
1023     VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT                = VK_BIT(3),    // Can be used as IBO
1024     VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT                      = VK_BIT(4),    // Can be used as UBO
1025     VK_BUFFER_USAGE_STORAGE_BUFFER_BIT                      = VK_BIT(5),    // Can be used as SSBO
1026     VK_BUFFER_USAGE_INDEX_BUFFER_BIT                        = VK_BIT(6),    // Can be used as source of fixed function index fetch (index buffer)
1027     VK_BUFFER_USAGE_VERTEX_BUFFER_BIT                       = VK_BIT(7),    // Can be used as source of fixed function vertex fetch (VBO)
1028     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT                     = VK_BIT(8),    // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
1029 } VkBufferUsageFlagBits;
1030
1031 // Buffer creation flags
1032 typedef VkFlags VkBufferCreateFlags;
1033 typedef enum VkBufferCreateFlagBits_
1034 {
1035     VK_BUFFER_CREATE_SHAREABLE_BIT                          = VK_BIT(0),    // Buffer should be shareable
1036     VK_BUFFER_CREATE_SPARSE_BIT                             = VK_BIT(1),    // Buffer should support sparse backing
1037 } VkBufferCreateFlagBits;
1038
1039 // Shader stage flags
1040 typedef VkFlags VkShaderStageFlags;
1041 typedef enum VkShaderStageFlagBits_
1042 {
1043     VK_SHADER_STAGE_VERTEX_BIT                              = VK_BIT(0),
1044     VK_SHADER_STAGE_TESS_CONTROL_BIT                        = VK_BIT(1),
1045     VK_SHADER_STAGE_TESS_EVALUATION_BIT                     = VK_BIT(2),
1046     VK_SHADER_STAGE_GEOMETRY_BIT                            = VK_BIT(3),
1047     VK_SHADER_STAGE_FRAGMENT_BIT                            = VK_BIT(4),
1048     VK_SHADER_STAGE_COMPUTE_BIT                             = VK_BIT(5),
1049
1050     VK_SHADER_STAGE_ALL                                     = 0x7FFFFFFF,
1051 } VkShaderStageFlagBits;
1052
1053 // Image usage flags
1054 typedef VkFlags VkImageUsageFlags;
1055 typedef enum VkImageUsageFlagBits_
1056 {
1057     VK_IMAGE_USAGE_GENERAL                                  = 0,            // No special usage
1058     VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT                      = VK_BIT(0),    // Can be used as a source of transfer operations
1059     VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT                 = VK_BIT(1),    // Can be used as a destination of transfer operations
1060     VK_IMAGE_USAGE_SAMPLED_BIT                              = VK_BIT(2),    // Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
1061     VK_IMAGE_USAGE_STORAGE_BIT                              = VK_BIT(3),    // Can be used as storage image (STORAGE_IMAGE descriptor type)
1062     VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                     = VK_BIT(4),    // Can be used as framebuffer color attachment
1063     VK_IMAGE_USAGE_DEPTH_STENCIL_BIT                        = VK_BIT(5),    // Can be used as framebuffer depth/stencil attachment
1064     VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT                 = VK_BIT(6),    // Image data not needed outside of rendering
1065 } VkImageUsageFlagBits;
1066
1067 // Image creation flags
1068 typedef VkFlags VkImageCreateFlags;
1069 typedef enum VkImageCreateFlagBits_
1070 {
1071     VK_IMAGE_CREATE_INVARIANT_DATA_BIT                      = VK_BIT(0),
1072     VK_IMAGE_CREATE_CLONEABLE_BIT                           = VK_BIT(1),
1073     VK_IMAGE_CREATE_SHAREABLE_BIT                           = VK_BIT(2),    // Image should be shareable
1074     VK_IMAGE_CREATE_SPARSE_BIT                              = VK_BIT(3),    // Image should support sparse backing
1075     VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT                      = VK_BIT(4),    // Allows image views to have different format than the base image
1076     VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT                     = VK_BIT(5),    // Allows creating image views with cube type from the created image
1077 } VkImageCreateFlagBits;
1078
1079 // Depth-stencil view creation flags
1080 typedef VkFlags VkDepthStencilViewCreateFlags;
1081 typedef enum VkDepthStencilViewCreateFlagBits_
1082 {
1083     VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT        = VK_BIT(0),
1084     VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT      = VK_BIT(1),
1085 } VkDepthStencilViewCreateFlagBits;
1086
1087 // Pipeline creation flags
1088 typedef VkFlags VkPipelineCreateFlags;
1089 typedef enum VkPipelineCreateFlagBits_
1090 {
1091     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT             = VK_BIT(0),
1092     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT                = VK_BIT(1),
1093 } VkPipelineCreateFlagBits;
1094
1095 // Channel flags
1096 typedef VkFlags VkChannelFlags;
1097 typedef enum VkChannelFlagBits_
1098 {
1099     VK_CHANNEL_R_BIT                                        = VK_BIT(0),
1100     VK_CHANNEL_G_BIT                                        = VK_BIT(1),
1101     VK_CHANNEL_B_BIT                                        = VK_BIT(2),
1102     VK_CHANNEL_A_BIT                                        = VK_BIT(3),
1103 } VkChannelFlagBits;
1104
1105 // Fence creation flags
1106 typedef VkFlags VkFenceCreateFlags;
1107 typedef enum VkFenceCreateFlagBits_
1108 {
1109     VK_FENCE_CREATE_SIGNALED_BIT                            = VK_BIT(0),
1110 } VkFenceCreateFlagBits;
1111
1112 // Semaphore creation flags
1113 typedef VkFlags VkSemaphoreCreateFlags;
1114 typedef enum VkSemaphoreCreateFlagBits_
1115 {
1116     VK_SEMAPHORE_CREATE_SHAREABLE_BIT                       = VK_BIT(0),
1117 } VkSemaphoreCreateFlagBits;
1118
1119 // Format capability flags
1120 typedef VkFlags VkFormatFeatureFlags;
1121 typedef enum VkFormatFeatureFlagBits_
1122 {
1123     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT                     = VK_BIT(0),    // Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
1124     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT                     = VK_BIT(1),    // Format can be used for storage images (STORAGE_IMAGE descriptor type)
1125     VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT              = VK_BIT(2),    // Format supports atomic operations in case it's used for storage images
1126     VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT              = VK_BIT(3),    // Format can be used for uniform texel buffers (TBOs)
1127     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT              = VK_BIT(4),    // Format can be used for storage texel buffers (IBOs)
1128     VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT       = VK_BIT(5),    // Format supports atomic operations in case it's used for storage texel buffers
1129     VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT                     = VK_BIT(6),    // Format can be used for vertex buffers (VBOs)
1130     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT                  = VK_BIT(7),    // Format can be used for color attachment images
1131     VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT            = VK_BIT(8),    // Format supports blending in case it's used for color attachment images
1132     VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT          = VK_BIT(9),    // Format can be used for depth/stencil attachment images
1133     VK_FORMAT_FEATURE_CONVERSION_BIT                        = VK_BIT(10),   // Format can be used as the source or destination of format converting blits
1134 } VkFormatFeatureFlagBits;
1135
1136 // Query control flags
1137 typedef VkFlags VkQueryControlFlags;
1138 typedef enum VkQueryControlFlagBits_
1139 {
1140     VK_QUERY_CONTROL_CONSERVATIVE_BIT                       = VK_BIT(0),    // Allow conservative results to be collected by the query
1141 } VkQueryControlFlagBits;
1142
1143 // Query result flags
1144 typedef VkFlags VkQueryResultFlags;
1145 typedef enum VkQueryResultFlagBits_
1146 {
1147     VK_QUERY_RESULT_32_BIT                                  = 0,           // Results of the queries are written to the destination buffer as 32-bit values
1148     VK_QUERY_RESULT_64_BIT                                  = VK_BIT(0),   // Results of the queries are written to the destination buffer as 64-bit values
1149     VK_QUERY_RESULT_NO_WAIT_BIT                             = 0,           // Results of the queries aren't waited on before proceeding with the result copy
1150     VK_QUERY_RESULT_WAIT_BIT                                = VK_BIT(1),   // Results of the queries are waited on before proceeding with the result copy
1151     VK_QUERY_RESULT_WITH_AVAILABILITY_BIT                   = VK_BIT(2),   // Besides the results of the query, the availability of the results is also written
1152     VK_QUERY_RESULT_PARTIAL_BIT                             = VK_BIT(3),   // Copy the partial results of the query even if the final results aren't available
1153 } VkQueryResultFlagBits;
1154
1155 // Physical device compatibility flags
1156 typedef VkFlags VkPhysicalDeviceCompatibilityFlags;
1157 typedef enum VkPhysicalDeviceCompatibilityFlagBits_
1158 {
1159     VK_PHYSICAL_DEVICE_COMPATIBILITY_FEATURES_BIT           = VK_BIT(0),
1160     VK_PHYSICAL_DEVICE_COMPATIBILITY_IQ_MATCH_BIT           = VK_BIT(1),
1161     VK_PHYSICAL_DEVICE_COMPATIBILITY_PEER_TRANSFER_BIT      = VK_BIT(2),
1162     VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_MEMORY_BIT      = VK_BIT(3),
1163     VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_SYNC_BIT        = VK_BIT(4),
1164     VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE0_DISPLAY_BIT = VK_BIT(5),
1165     VK_PHYSICAL_DEVICE_COMPATIBILITY_SHARED_DEVICE1_DISPLAY_BIT = VK_BIT(6),
1166 } VkPhysicalDeviceCompatibilityFlagBits;
1167
1168 // Shader creation flags
1169 typedef VkFlags VkShaderCreateFlags;
1170
1171 // Event creation flags
1172 typedef VkFlags VkEventCreateFlags;
1173
1174 // Command buffer creation flags
1175 typedef VkFlags VkCmdBufferCreateFlags;
1176
1177 // Command buffer optimization flags
1178 typedef VkFlags VkCmdBufferOptimizeFlags;
1179 typedef enum VkCmdBufferOptimizeFlagBits_
1180 {
1181     VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT                  = VK_BIT(0),
1182     VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT              = VK_BIT(1),
1183     VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT              = VK_BIT(2),
1184     VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT        = VK_BIT(3),
1185 } VkCmdBufferOptimizeFlagBits;
1186
1187 // Pipeline statistics flags
1188 typedef VkFlags VkQueryPipelineStatisticFlags;
1189 typedef enum VkQueryPipelineStatisticFlagBits_ {
1190     VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT             = VK_BIT(0),  // Optional
1191     VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT           = VK_BIT(1),  // Optional
1192     VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT          = VK_BIT(2),  // Optional
1193     VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT          = VK_BIT(3),  // Optional
1194     VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT           = VK_BIT(4),  // Optional
1195     VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT           = VK_BIT(5),  // Optional
1196     VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT            = VK_BIT(6),  // Optional
1197     VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT          = VK_BIT(7),  // Optional
1198     VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT             = VK_BIT(8),  // Optional
1199     VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT         = VK_BIT(9),  // Optional
1200     VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT          = VK_BIT(10), // Optional
1201 } VkQueryPipelineStatisticFlagBits;
1202
1203 // Memory mapping flags
1204 typedef VkFlags VkMemoryMapFlags;
1205
1206 // ------------------------------------------------------------------------------------------------
1207 // Vulkan structures
1208
1209 typedef struct VkOffset2D_
1210 {
1211     int32_t                                     x;
1212     int32_t                                     y;
1213 } VkOffset2D;
1214
1215 typedef struct VkOffset3D_
1216 {
1217     int32_t                                     x;
1218     int32_t                                     y;
1219     int32_t                                     z;
1220 } VkOffset3D;
1221
1222 typedef struct VkExtent2D_
1223 {
1224     int32_t                                     width;
1225     int32_t                                     height;
1226 } VkExtent2D;
1227
1228 typedef struct VkExtent3D_
1229 {
1230     int32_t                                     width;
1231     int32_t                                     height;
1232     int32_t                                     depth;
1233 } VkExtent3D;
1234
1235 typedef struct VkViewport_
1236 {
1237     float                                       originX;
1238     float                                       originY;
1239     float                                       width;
1240     float                                       height;
1241     float                                       minDepth;
1242     float                                       maxDepth;
1243 } VkViewport;
1244
1245 typedef struct VkRect_
1246 {
1247     VkOffset2D                                  offset;
1248     VkExtent2D                                  extent;
1249 } VkRect;
1250
1251 typedef struct VkChannelMapping_
1252 {
1253     VkChannelSwizzle                            r;
1254     VkChannelSwizzle                            g;
1255     VkChannelSwizzle                            b;
1256     VkChannelSwizzle                            a;
1257 } VkChannelMapping;
1258
1259 typedef struct VkPhysicalDeviceProperties_
1260 {
1261     uint32_t                                    apiVersion;
1262     uint32_t                                    driverVersion;
1263     uint32_t                                    vendorId;
1264     uint32_t                                    deviceId;
1265     VkPhysicalDeviceType                        deviceType;
1266     char                                        deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
1267     VkDeviceSize                                maxInlineMemoryUpdateSize;
1268     uint32_t                                    maxBoundDescriptorSets;
1269     uint32_t                                    maxThreadGroupSize;
1270     uint64_t                                    timestampFrequency;
1271     bool32_t                                    multiColorAttachmentClears;
1272     uint32_t                                    maxDescriptorSets;              // at least 2?
1273     uint32_t                                    maxViewports;                   // at least 16?
1274     uint32_t                                    maxColorAttachments;            // at least 8?
1275 } VkPhysicalDeviceProperties;
1276
1277 typedef struct VkPhysicalDevicePerformance_
1278 {
1279     float                                       maxDeviceClock;
1280     float                                       aluPerClock;
1281     float                                       texPerClock;
1282     float                                       primsPerClock;
1283     float                                       pixelsPerClock;
1284 } VkPhysicalDevicePerformance;
1285
1286 typedef struct VkPhysicalDeviceCompatibilityInfo_
1287 {
1288     VkPhysicalDeviceCompatibilityFlags          compatibilityFlags;
1289 } VkPhysicalDeviceCompatibilityInfo;
1290
1291 typedef struct VkExtensionProperties_
1292 {
1293     char                                        extName[VK_MAX_EXTENSION_NAME];     // extension name
1294     uint32_t                                    version;                            // version of the extension specification
1295 } VkExtensionProperties;
1296
1297 typedef struct VkApplicationInfo_
1298 {
1299     VkStructureType                             sType;              // Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO
1300     const void*                                 pNext;              // Next structure in chain
1301     const char*                                 pAppName;
1302     uint32_t                                    appVersion;
1303     const char*                                 pEngineName;
1304     uint32_t                                    engineVersion;
1305     uint32_t                                    apiVersion;
1306 } VkApplicationInfo;
1307
1308 typedef void* (VKAPI *PFN_vkAllocFunction)(
1309     void*                                       pUserData,
1310     size_t                                      size,
1311     size_t                                      alignment,
1312     VkSystemAllocType                           allocType);
1313
1314 typedef void (VKAPI *PFN_vkFreeFunction)(
1315     void*                                       pUserData,
1316     void*                                       pMem);
1317
1318 typedef struct VkAllocCallbacks_
1319 {
1320     void*                                       pUserData;
1321     PFN_vkAllocFunction                         pfnAlloc;
1322     PFN_vkFreeFunction                          pfnFree;
1323 } VkAllocCallbacks;
1324
1325 typedef struct VkDeviceQueueCreateInfo_
1326 {
1327     uint32_t                                    queueNodeIndex;
1328     uint32_t                                    queueCount;
1329 } VkDeviceQueueCreateInfo;
1330
1331 typedef struct VkDeviceCreateInfo_
1332 {
1333     VkStructureType                             sType;                      // Should be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
1334     const void*                                 pNext;                      // Pointer to next structure
1335     uint32_t                                    queueRecordCount;
1336     const VkDeviceQueueCreateInfo*              pRequestedQueues;
1337     uint32_t                                    extensionCount;
1338     const char*const*                           ppEnabledExtensionNames;
1339     VkDeviceCreateFlags                         flags;                      // Device creation flags
1340 } VkDeviceCreateInfo;
1341
1342 typedef struct VkInstanceCreateInfo_
1343 {
1344     VkStructureType                             sType;                      // Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
1345     const void*                                 pNext;                      // Pointer to next structure
1346     const VkApplicationInfo*                    pAppInfo;
1347     const VkAllocCallbacks*                     pAllocCb;
1348     uint32_t                                    extensionCount;
1349     const char*const*                           ppEnabledExtensionNames;    // layer or extension name to be enabled
1350 } VkInstanceCreateInfo;
1351
1352 // can be added to VkDeviceCreateInfo via pNext
1353 typedef struct VkLayerCreateInfo_
1354 {
1355     VkStructureType                             sType;                      // Should be VK_STRUCTURE_TYPE_LAYER_CREATE_INFO
1356     const void*                                 pNext;                      // Pointer to next structure
1357     uint32_t                                    layerCount;
1358     const char *const*                          ppActiveLayerNames;         // layer name from the layer's vkEnumerateLayers())
1359 } VkLayerCreateInfo;
1360
1361 typedef struct VkPhysicalDeviceQueueProperties_
1362 {
1363     VkQueueFlags                                queueFlags;                 // Queue flags
1364     uint32_t                                    queueCount;
1365     uint32_t                                    maxAtomicCounters;
1366     bool32_t                                    supportsTimestamps;
1367     uint32_t                                    maxMemReferences;           // Tells how many memory references can be active for the given queue
1368 } VkPhysicalDeviceQueueProperties;
1369
1370 typedef struct VkPhysicalDeviceMemoryProperties_
1371 {
1372     bool32_t                                    supportsMigration;
1373     bool32_t                                    supportsPinning;
1374 } VkPhysicalDeviceMemoryProperties;
1375
1376 typedef struct VkMemoryAllocInfo_
1377 {
1378     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
1379     const void*                                 pNext;                      // Pointer to next structure
1380     VkDeviceSize                                allocationSize;             // Size of memory allocation
1381     VkMemoryPropertyFlags                       memProps;                   // Memory property flags
1382     VkMemoryPriority                            memPriority;
1383 } VkMemoryAllocInfo;
1384
1385 typedef struct VkMemoryOpenInfo_
1386 {
1387     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_OPEN_INFO
1388     const void*                                 pNext;                      // Pointer to next structure
1389     VkDeviceMemory                              sharedMem;
1390 } VkMemoryOpenInfo;
1391
1392 typedef struct VkPeerMemoryOpenInfo_
1393 {
1394     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO
1395     const void*                                 pNext;                      // Pointer to next structure
1396     VkDeviceMemory                              originalMem;
1397 } VkPeerMemoryOpenInfo;
1398
1399 typedef struct VkMemoryRequirements_
1400 {
1401     VkDeviceSize                                size;                       // Specified in bytes
1402     VkDeviceSize                                alignment;                  // Specified in bytes
1403     VkDeviceSize                                granularity;                // Granularity on which vkQueueBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size)
1404     VkMemoryPropertyFlags                       memPropsAllowed;            // Allowed memory property flags
1405     VkMemoryPropertyFlags                       memPropsRequired;           // Required memory property flags
1406
1407 } VkMemoryRequirements;
1408
1409 typedef struct VkFormatProperties_
1410 {
1411     VkFormatFeatureFlags                        linearTilingFeatures;       // Format features in case of linear tiling
1412     VkFormatFeatureFlags                        optimalTilingFeatures;      // Format features in case of optimal tiling
1413 } VkFormatProperties;
1414
1415 typedef struct VkBufferViewAttachInfo_
1416 {
1417     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO
1418     const void*                                 pNext;                      // Pointer to next structure
1419     VkBufferView                                view;
1420 } VkBufferViewAttachInfo;
1421
1422 typedef struct VkImageViewAttachInfo_
1423 {
1424     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
1425     const void*                                 pNext;                      // Pointer to next structure
1426     VkImageView                                 view;
1427     VkImageLayout                               layout;
1428 } VkImageViewAttachInfo;
1429
1430 typedef struct VkUpdateSamplers_
1431 {
1432     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLERS
1433     const void*                                 pNext;                      // Pointer to next structure
1434     uint32_t                                    binding;                    // Binding of the sampler (array)
1435     uint32_t                                    arrayIndex;                 // First element of the array to update or zero otherwise
1436     uint32_t                                    count;                      // Number of elements to update
1437     const VkSampler*                            pSamplers;
1438 } VkUpdateSamplers;
1439
1440 typedef struct VkSamplerImageViewInfo_
1441 {
1442     VkSampler                                   sampler;
1443     const VkImageViewAttachInfo*                pImageView;
1444 } VkSamplerImageViewInfo;
1445
1446 typedef struct VkUpdateSamplerTextures_
1447 {
1448     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES
1449     const void*                                 pNext;                      // Pointer to next structure
1450     uint32_t                                    binding;                    // Binding of the combined texture sampler (array)
1451     uint32_t                                    arrayIndex;                 // First element of the array to update or zero otherwise
1452     uint32_t                                    count;                      // Number of elements to update
1453     const VkSamplerImageViewInfo*               pSamplerImageViews;
1454 } VkUpdateSamplerTextures;
1455
1456 typedef struct VkUpdateImages_
1457 {
1458     VkStructureType                             sType;                     // Must be VK_STRUCTURE_TYPE_UPDATE_IMAGES
1459     const void*                                 pNext;                     // Pointer to next structure
1460     VkDescriptorType                            descriptorType;
1461     uint32_t                                    binding;                   // Binding of the image (array)
1462     uint32_t                                    arrayIndex;                // First element of the array to update or zero otherwise
1463     uint32_t                                    count;                     // Number of elements to update
1464     const VkImageViewAttachInfo*                pImageViews;
1465 } VkUpdateImages;
1466
1467 typedef struct VkUpdateBuffers_
1468 {
1469     VkStructureType                             sType;                    // Must be VK_STRUCTURE_TYPE_UPDATE_BUFFERS
1470     const void*                                 pNext;                    // Pointer to next structure
1471     VkDescriptorType                            descriptorType;
1472     uint32_t                                    binding;                  // Binding of the buffer (array)
1473     uint32_t                                    arrayIndex;               // First element of the array to update or zero otherwise
1474     uint32_t                                    count;                    // Number of elements to update
1475     const VkBufferViewAttachInfo*               pBufferViews;
1476 } VkUpdateBuffers;
1477
1478 typedef struct VkUpdateAsCopy_
1479 {
1480     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_UPDATE_AS_COPY
1481     const void*                                 pNext;                      // Pointer to next structure
1482     VkDescriptorType                            descriptorType;
1483     VkDescriptorSet                             descriptorSet;
1484     uint32_t                                    binding;
1485     uint32_t                                    arrayElement;
1486     uint32_t                                    count;
1487 } VkUpdateAsCopy;
1488
1489 typedef struct VkBufferCreateInfo_
1490 {
1491     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
1492     const void*                                 pNext;                      // Pointer to next structure.
1493     VkDeviceSize                                size;                       // Specified in bytes
1494     VkBufferUsageFlags                          usage;                      // Buffer usage flags
1495     VkBufferCreateFlags                         flags;                      // Buffer creation flags
1496 } VkBufferCreateInfo;
1497
1498 typedef struct VkBufferViewCreateInfo_
1499 {
1500     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
1501     const void*                                 pNext;                      // Pointer to next structure.
1502     VkBuffer                                    buffer;
1503     VkBufferViewType                            viewType;
1504     VkFormat                                    format;                     // Optionally specifies format of elements
1505     VkDeviceSize                                offset;                     // Specified in bytes
1506     VkDeviceSize                                range;                      // View size specified in bytes
1507 } VkBufferViewCreateInfo;
1508
1509 typedef struct VkImageSubresource_
1510 {
1511     VkImageAspect                               aspect;
1512     uint32_t                                    mipLevel;
1513     uint32_t                                    arraySlice;
1514 } VkImageSubresource;
1515
1516 typedef struct VkImageSubresourceRange_
1517 {
1518     VkImageAspect                               aspect;
1519     uint32_t                                    baseMipLevel;
1520     uint32_t                                    mipLevels;
1521     uint32_t                                    baseArraySlice;
1522     uint32_t                                    arraySize;
1523 } VkImageSubresourceRange;
1524
1525 typedef struct VkMemoryBarrier_
1526 {
1527     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_MEMORY_BARRIER
1528     const void*                                 pNext;                      // Pointer to next structure.
1529
1530     VkMemoryOutputFlags                         outputMask;                 // Outputs the barrier should sync
1531     VkMemoryInputFlags                          inputMask;                  // Inputs the barrier should sync to
1532 } VkMemoryBarrier;
1533
1534 typedef struct VkBufferMemoryBarrier_
1535 {
1536     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
1537     const void*                                 pNext;                      // Pointer to next structure.
1538
1539     VkMemoryOutputFlags                         outputMask;                 // Outputs the barrier should sync
1540     VkMemoryInputFlags                          inputMask;                  // Inputs the barrier should sync to
1541
1542     VkBuffer                                    buffer;                     // Buffer to sync
1543
1544     VkDeviceSize                                offset;                     // Offset within the buffer to sync
1545     VkDeviceSize                                size;                       // Amount of bytes to sync
1546 } VkBufferMemoryBarrier;
1547
1548 typedef struct VkImageMemoryBarrier_
1549 {
1550     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
1551     const void*                                 pNext;                      // Pointer to next structure.
1552
1553     VkMemoryOutputFlags                         outputMask;                 // Outputs the barrier should sync
1554     VkMemoryInputFlags                          inputMask;                  // Inputs the barrier should sync to
1555
1556     VkImageLayout                               oldLayout;                  // Current layout of the image
1557     VkImageLayout                               newLayout;                  // New layout to transition the image to
1558
1559     VkImage                                     image;                      // Image to sync
1560
1561     VkImageSubresourceRange                     subresourceRange;           // Subresource range to sync
1562 } VkImageMemoryBarrier;
1563
1564 typedef struct VkImageCreateInfo_
1565 {
1566     VkStructureType                             sType;                      // Must be VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
1567     const void*                                 pNext;                      // Pointer to next structure.
1568     VkImageType                                 imageType;
1569     VkFormat                                    format;
1570     VkExtent3D                                  extent;
1571     uint32_t                                    mipLevels;
1572     uint32_t                                    arraySize;
1573     uint32_t                                    samples;
1574     VkImageTiling                               tiling;
1575     VkImageUsageFlags                           usage;                      // Image usage flags
1576     VkImageCreateFlags                          flags;                      // Image creation flags
1577 } VkImageCreateInfo;
1578
1579 typedef struct VkPeerImageOpenInfo_
1580 {
1581     VkImage                                     originalImage;
1582 } VkPeerImageOpenInfo;
1583
1584 typedef struct VkSubresourceLayout_
1585 {
1586     VkDeviceSize                                offset;                 // Specified in bytes
1587     VkDeviceSize                                size;                   // Specified in bytes
1588     VkDeviceSize                                rowPitch;               // Specified in bytes
1589     VkDeviceSize                                depthPitch;             // Specified in bytes
1590 } VkSubresourceLayout;
1591
1592 typedef struct VkImageViewCreateInfo_
1593 {
1594     VkStructureType                             sType;                  // Must be VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
1595     const void*                                 pNext;                  // Pointer to next structure
1596     VkImage                                     image;
1597     VkImageViewType                             viewType;
1598     VkFormat                                    format;
1599     VkChannelMapping                            channels;
1600     VkImageSubresourceRange                     subresourceRange;
1601     float                                       minLod;
1602 } VkImageViewCreateInfo;
1603
1604 typedef struct VkColorAttachmentViewCreateInfo_
1605 {
1606     VkStructureType                             sType;                  // Must be VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1607     const void*                                 pNext;                  // Pointer to next structure
1608     VkImage                                     image;
1609     VkFormat                                    format;
1610     uint32_t                                    mipLevel;
1611     uint32_t                                    baseArraySlice;
1612     uint32_t                                    arraySize;
1613     VkImage                                     msaaResolveImage;
1614     VkImageSubresourceRange                     msaaResolveSubResource;
1615 } VkColorAttachmentViewCreateInfo;
1616
1617 typedef struct VkDepthStencilViewCreateInfo_
1618 {
1619     VkStructureType                             sType;                  // Must be VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO
1620     const void*                                 pNext;                  // Pointer to next structure
1621     VkImage                                     image;
1622     uint32_t                                    mipLevel;
1623     uint32_t                                    baseArraySlice;
1624     uint32_t                                    arraySize;
1625     VkImage                                     msaaResolveImage;
1626     VkImageSubresourceRange                     msaaResolveSubResource;
1627     VkDepthStencilViewCreateFlags               flags;                  // Depth stencil attachment view flags
1628 } VkDepthStencilViewCreateInfo;
1629
1630 typedef struct VkColorAttachmentBindInfo_
1631 {
1632     VkColorAttachmentView                       view;
1633     VkImageLayout                               layout;
1634 } VkColorAttachmentBindInfo;
1635
1636 typedef struct VkDepthStencilBindInfo_
1637 {
1638     VkDepthStencilView                          view;
1639     VkImageLayout                               layout;
1640 } VkDepthStencilBindInfo;
1641
1642 typedef struct VkBufferCopy_
1643 {
1644     VkDeviceSize                                srcOffset;              // Specified in bytes
1645     VkDeviceSize                                destOffset;             // Specified in bytes
1646     VkDeviceSize                                copySize;               // Specified in bytes
1647 } VkBufferCopy;
1648
1649 typedef struct VkImageMemoryBindInfo_
1650 {
1651     VkImageSubresource                          subresource;
1652     VkOffset3D                                  offset;
1653     VkExtent3D                                  extent;
1654 } VkImageMemoryBindInfo;
1655
1656 typedef struct VkImageCopy_
1657 {
1658     VkImageSubresource                          srcSubresource;
1659     VkOffset3D                                  srcOffset;             // Specified in pixels for both compressed and uncompressed images
1660     VkImageSubresource                          destSubresource;
1661     VkOffset3D                                  destOffset;            // Specified in pixels for both compressed and uncompressed images
1662     VkExtent3D                                  extent;                // Specified in pixels for both compressed and uncompressed images
1663 } VkImageCopy;
1664
1665 typedef struct VkImageBlit_
1666 {
1667     VkImageSubresource                          srcSubresource;
1668     VkOffset3D                                  srcOffset;              // Specified in pixels for both compressed and uncompressed images
1669     VkExtent3D                                  srcExtent;              // Specified in pixels for both compressed and uncompressed images
1670     VkImageSubresource                          destSubresource;
1671     VkOffset3D                                  destOffset;             // Specified in pixels for both compressed and uncompressed images
1672     VkExtent3D                                  destExtent;             // Specified in pixels for both compressed and uncompressed images
1673 } VkImageBlit;
1674
1675 typedef struct VkBufferImageCopy_
1676 {
1677     VkDeviceSize                                bufferOffset;           // Specified in bytes
1678     VkImageSubresource                          imageSubresource;
1679     VkOffset3D                                  imageOffset;            // Specified in pixels for both compressed and uncompressed images
1680     VkExtent3D                                  imageExtent;            // Specified in pixels for both compressed and uncompressed images
1681 } VkBufferImageCopy;
1682
1683 typedef struct VkImageResolve_
1684 {
1685     VkImageSubresource                          srcSubresource;
1686     VkOffset3D                                  srcOffset;
1687     VkImageSubresource                          destSubresource;
1688     VkOffset3D                                  destOffset;
1689     VkExtent3D                                  extent;
1690 } VkImageResolve;
1691
1692 typedef struct VkShaderCreateInfo_
1693 {
1694     VkStructureType                             sType;              // Must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO
1695     const void*                                 pNext;              // Pointer to next structure
1696     size_t                                      codeSize;           // Specified in bytes
1697     const void*                                 pCode;
1698     VkShaderCreateFlags                         flags;              // Reserved
1699 } VkShaderCreateInfo;
1700
1701 typedef struct VkDescriptorSetLayoutBinding_
1702 {
1703     VkDescriptorType                            descriptorType;     // Type of the descriptors in this binding
1704     uint32_t                                    count;              // Number of descriptors in this binding
1705     VkShaderStageFlags                          stageFlags;         // Shader stages this binding is visible to
1706     const VkSampler*                            pImmutableSamplers; // Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains <count> number of elements)
1707 } VkDescriptorSetLayoutBinding;
1708
1709 typedef struct VkDescriptorSetLayoutCreateInfo_
1710 {
1711     VkStructureType                             sType;              // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
1712     const void*                                 pNext;              // Pointer to next structure
1713     uint32_t                                    count;              // Number of bindings in the descriptor set layout
1714     const VkDescriptorSetLayoutBinding*         pBinding;           // Array of descriptor set layout bindings
1715 } VkDescriptorSetLayoutCreateInfo;
1716
1717 typedef struct VkDescriptorTypeCount_
1718 {
1719     VkDescriptorType                            type;
1720     uint32_t                                    count;
1721 } VkDescriptorTypeCount;
1722
1723 typedef struct VkDescriptorPoolCreateInfo_
1724 {
1725     VkStructureType                             sType;              // Must be VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
1726     const void*                                 pNext;              // Pointer to next structure
1727     uint32_t                                    count;
1728     const VkDescriptorTypeCount*                pTypeCount;
1729 } VkDescriptorPoolCreateInfo;
1730
1731 typedef struct VkLinkConstBuffer_
1732 {
1733     uint32_t                                    bufferId;
1734     size_t                                      bufferSize;
1735     const void*                                 pBufferData;
1736 } VkLinkConstBuffer;
1737
1738 typedef struct VkSpecializationMapEntry_
1739 {
1740     uint32_t                                    constantId;         // The SpecConstant ID specified in the BIL
1741     uint32_t                                    offset;             // Offset of the value in the data block
1742 } VkSpecializationMapEntry;
1743
1744 typedef struct VkSpecializationInfo_
1745 {
1746     uint32_t                                    mapEntryCount;
1747     const VkSpecializationMapEntry*             pMap;               // mapEntryCount entries
1748     const void*                                 pData;
1749 } VkSpecializationInfo;
1750
1751 typedef struct VkPipelineShader_
1752 {
1753     VkShaderStage                               stage;
1754     VkShader                                    shader;
1755     uint32_t                                    linkConstBufferCount;
1756     const VkLinkConstBuffer*                    pLinkConstBufferInfo;
1757     const VkSpecializationInfo*                 pSpecializationInfo;
1758 } VkPipelineShader;
1759
1760 typedef struct VkComputePipelineCreateInfo_
1761 {
1762     VkStructureType                             sType;          // Must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
1763     const void*                                 pNext;          // Pointer to next structure
1764     VkPipelineShader                            cs;
1765     VkPipelineCreateFlags                       flags;          // Pipeline creation flags
1766     VkPipelineLayout                            layout;         // Interface layout of the pipeline
1767 } VkComputePipelineCreateInfo;
1768
1769 typedef struct VkVertexInputBindingDescription_
1770 {
1771     uint32_t                                    binding;        // Vertex buffer binding id
1772     uint32_t                                    strideInBytes;  // Distance between vertices in bytes (0 = no advancement)
1773
1774     VkVertexInputStepRate                       stepRate;       // Rate at which binding is incremented
1775 } VkVertexInputBindingDescription;
1776
1777 typedef struct VkVertexInputAttributeDescription_
1778 {
1779     uint32_t                                    location;       // location of the shader vertex attrib
1780     uint32_t                                    binding;        // Vertex buffer binding id
1781
1782     VkFormat                                    format;         // format of source data
1783
1784     uint32_t                                    offsetInBytes;  // Offset of first element in bytes from base of vertex
1785 } VkVertexInputAttributeDescription;
1786
1787 typedef struct VkPipelineVertexInputCreateInfo_
1788 {
1789     VkStructureType                             sType;          // Should be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO
1790     const void*                                 pNext;          // Pointer to next structure
1791
1792     uint32_t                                    bindingCount;   // number of bindings
1793     const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
1794
1795     uint32_t                                    attributeCount; // number of attributes
1796     const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
1797 } VkPipelineVertexInputCreateInfo;
1798
1799 typedef struct VkPipelineIaStateCreateInfo_
1800 {
1801     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
1802     const void*                                 pNext;      // Pointer to next structure
1803     VkPrimitiveTopology                         topology;
1804     bool32_t                                    disableVertexReuse;         // optional
1805     bool32_t                                    primitiveRestartEnable;
1806     uint32_t                                    primitiveRestartIndex;      // optional (GL45)
1807 } VkPipelineIaStateCreateInfo;
1808
1809 typedef struct VkPipelineTessStateCreateInfo_
1810 {
1811     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
1812     const void*                                 pNext;      // Pointer to next structure
1813     uint32_t                                    patchControlPoints;
1814 } VkPipelineTessStateCreateInfo;
1815
1816 typedef struct VkPipelineVpStateCreateInfo_
1817 {
1818     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO
1819     const void*                                 pNext;      // Pointer to next structure
1820     uint32_t                                    viewportCount;
1821     VkCoordinateOrigin                          clipOrigin;                 // optional (GL45)
1822     VkDepthMode                                 depthMode;                  // optional (GL45)
1823 } VkPipelineVpStateCreateInfo;
1824
1825 typedef struct VkPipelineRsStateCreateInfo_
1826 {
1827     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
1828     const void*                                 pNext;      // Pointer to next structure
1829     bool32_t                                    depthClipEnable;
1830     bool32_t                                    rasterizerDiscardEnable;
1831     bool32_t                                    programPointSize;           // optional (GL45)
1832     VkCoordinateOrigin                          pointOrigin;                // optional (GL45)
1833     VkProvokingVertex                           provokingVertex;            // optional (GL45)
1834     VkFillMode                                  fillMode;                   // optional (GL45)
1835     VkCullMode                                  cullMode;
1836     VkFrontFace                                 frontFace;
1837 } VkPipelineRsStateCreateInfo;
1838
1839 typedef struct VkPipelineMsStateCreateInfo_
1840 {
1841     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO
1842     const void*                                 pNext;      // Pointer to next structure
1843     uint32_t                                    samples;
1844     bool32_t                                    multisampleEnable;          // optional (GL45)
1845     bool32_t                                    sampleShadingEnable;        // optional (GL45)
1846     float                                       minSampleShading;           // optional (GL45)
1847     VkSampleMask                                sampleMask;
1848 } VkPipelineMsStateCreateInfo;
1849
1850 typedef struct VkPipelineCbAttachmentState_
1851 {
1852     bool32_t                                    blendEnable;
1853     VkFormat                                    format;
1854     VkBlend                                     srcBlendColor;
1855     VkBlend                                     destBlendColor;
1856     VkBlendOp                                   blendOpColor;
1857     VkBlend                                     srcBlendAlpha;
1858     VkBlend                                     destBlendAlpha;
1859     VkBlendOp                                   blendOpAlpha;
1860     VkChannelFlags                              channelWriteMask;
1861 } VkPipelineCbAttachmentState;
1862
1863 typedef struct VkPipelineCbStateCreateInfo_
1864 {
1865     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
1866     const void*                                 pNext;      // Pointer to next structure
1867     bool32_t                                    alphaToCoverageEnable;
1868     bool32_t                                    logicOpEnable;
1869     VkLogicOp                                   logicOp;
1870     uint32_t                                    attachmentCount;    // # of pAttachments
1871     const VkPipelineCbAttachmentState*          pAttachments;
1872 } VkPipelineCbStateCreateInfo;
1873
1874 typedef struct VkStencilOpState_
1875 {
1876     VkStencilOp                                 stencilFailOp;
1877     VkStencilOp                                 stencilPassOp;
1878     VkStencilOp                                 stencilDepthFailOp;
1879     VkCompareOp                                 stencilCompareOp;
1880 } VkStencilOpState;
1881
1882 typedef struct VkPipelineDsStateCreateInfo_
1883 {
1884     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO
1885     const void*                                 pNext;      // Pointer to next structure
1886     VkFormat                                    format;
1887     bool32_t                                    depthTestEnable;
1888     bool32_t                                    depthWriteEnable;
1889     VkCompareOp                                 depthCompareOp;
1890     bool32_t                                    depthBoundsEnable;          // optional (depth_bounds_test)
1891     bool32_t                                    stencilTestEnable;
1892     VkStencilOpState                            front;
1893     VkStencilOpState                            back;
1894 } VkPipelineDsStateCreateInfo;
1895
1896 typedef struct VkPipelineShaderStageCreateInfo_
1897 {
1898     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
1899     const void*                                 pNext;      // Pointer to next structure
1900     VkPipelineShader                            shader;
1901 } VkPipelineShaderStageCreateInfo;
1902
1903 typedef struct VkGraphicsPipelineCreateInfo_
1904 {
1905     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
1906     const void*                                 pNext;      // Pointer to next structure
1907     VkPipelineCreateFlags                       flags;      // Pipeline creation flags
1908     VkPipelineLayout                            layout;     // Interface layout of the pipeline
1909 } VkGraphicsPipelineCreateInfo;
1910
1911 typedef struct VkPipelineLayoutCreateInfo_
1912 {
1913     VkStructureType                             sType;              // Must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
1914     const void*                                 pNext;              // Pointer to next structure
1915
1916     uint32_t                                    descriptorSetCount; // Number of descriptor sets interfaced by the pipeline
1917     const VkDescriptorSetLayout*                pSetLayouts;        // Array of <setCount> number of descriptor set layout objects defining the layout of the
1918 } VkPipelineLayoutCreateInfo;
1919
1920 typedef struct VkSamplerCreateInfo_
1921 {
1922     VkStructureType                             sType;          // Must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
1923     const void*                                 pNext;          // Pointer to next structure
1924     VkTexFilter                                 magFilter;      // Filter mode for magnification
1925     VkTexFilter                                 minFilter;      // Filter mode for minifiation
1926     VkTexMipmapMode                             mipMode;        // Mipmap selection mode
1927     VkTexAddress                                addressU;
1928     VkTexAddress                                addressV;
1929     VkTexAddress                                addressW;
1930     float                                       mipLodBias;
1931     uint32_t                                    maxAnisotropy;
1932     VkCompareOp                                 compareOp;
1933     float                                       minLod;
1934     float                                       maxLod;
1935     VkBorderColor                               borderColor;
1936 } VkSamplerCreateInfo;
1937
1938 typedef struct VkDynamicVpStateCreateInfo_
1939 {
1940     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO
1941     const void*                                 pNext;      // Pointer to next structure
1942     uint32_t                                    viewportAndScissorCount;  // number of entries in pViewports and pScissors
1943     const VkViewport*                           pViewports;
1944     const VkRect*                               pScissors;
1945 } VkDynamicVpStateCreateInfo;
1946
1947 typedef struct VkDynamicRsStateCreateInfo_
1948 {
1949     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO
1950     const void*                                 pNext;      // Pointer to next structure
1951     float                                       depthBias;
1952     float                                       depthBiasClamp;
1953     float                                       slopeScaledDepthBias;
1954     float                                       pointSize;          // optional (GL45) - Size of points
1955     float                                       pointFadeThreshold; // optional (GL45) - Size of point fade threshold
1956     float                                       lineWidth;          // optional (GL45) - Width of lines
1957 } VkDynamicRsStateCreateInfo;
1958
1959 typedef struct VkDynamicCbStateCreateInfo_
1960 {
1961     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO
1962     const void*                                 pNext;      // Pointer to next structure
1963     float                                       blendConst[4];
1964 } VkDynamicCbStateCreateInfo;
1965
1966 typedef struct VkDynamicDsStateCreateInfo_
1967 {
1968     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO
1969     const void*                                 pNext;      // Pointer to next structure
1970     float                                       minDepth;               // optional (depth_bounds_test)
1971     float                                       maxDepth;               // optional (depth_bounds_test)
1972     uint32_t                                    stencilReadMask;
1973     uint32_t                                    stencilWriteMask;
1974     uint32_t                                    stencilFrontRef;
1975     uint32_t                                    stencilBackRef;
1976 } VkDynamicDsStateCreateInfo;
1977
1978 typedef struct VkCmdBufferCreateInfo_
1979 {
1980     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
1981     const void*                                 pNext;      // Pointer to next structure
1982     uint32_t                                    queueNodeIndex;
1983     VkCmdBufferCreateFlags                      flags;      // Command buffer creation flags
1984 } VkCmdBufferCreateInfo;
1985
1986 typedef struct VkCmdBufferBeginInfo_
1987 {
1988     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO
1989     const void*                                 pNext;      // Pointer to next structure
1990
1991     VkCmdBufferOptimizeFlags                    flags;      // Command buffer optimization flags
1992 } VkCmdBufferBeginInfo;
1993
1994 typedef struct VkRenderPassBegin_
1995 {
1996     VkRenderPass                                renderPass;
1997     VkFramebuffer                               framebuffer;
1998 } VkRenderPassBegin;
1999
2000 typedef struct VkCmdBufferGraphicsBeginInfo_
2001 {
2002     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO
2003     const void*                                 pNext;      // Pointer to next structure
2004
2005     VkRenderPassBegin                           renderPassContinue;  // Only needed when a render pass is split across two command buffers
2006 } VkCmdBufferGraphicsBeginInfo;
2007
2008 // Union allowing specification of floating point or raw color data. Actual value selected is based on image being cleared.
2009 typedef union VkClearColorValue_
2010 {
2011     float                                       floatColor[4];
2012     uint32_t                                    rawColor[4];
2013 } VkClearColorValue;
2014
2015 typedef struct VkClearColor_
2016 {
2017     VkClearColorValue                           color;
2018     bool32_t                                    useRawValue;
2019 } VkClearColor;
2020
2021 typedef struct VkRenderPassCreateInfo_
2022 {
2023     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
2024     const void*                                 pNext;      // Pointer to next structure
2025
2026     VkRect                                      renderArea;
2027     uint32_t                                    colorAttachmentCount;
2028     VkExtent2D                                  extent;
2029     uint32_t                                    sampleCount;
2030     uint32_t                                    layers;
2031     const VkFormat*                             pColorFormats;
2032     const VkImageLayout*                        pColorLayouts;
2033     const VkAttachmentLoadOp*                   pColorLoadOps;
2034     const VkAttachmentStoreOp*                  pColorStoreOps;
2035     const VkClearColor*                         pColorLoadClearValues;
2036     VkFormat                                    depthStencilFormat;
2037     VkImageLayout                               depthStencilLayout;
2038     VkAttachmentLoadOp                          depthLoadOp;
2039     float                                       depthLoadClearValue;
2040     VkAttachmentStoreOp                         depthStoreOp;
2041     VkAttachmentLoadOp                          stencilLoadOp;
2042     uint32_t                                    stencilLoadClearValue;
2043     VkAttachmentStoreOp                         stencilStoreOp;
2044 } VkRenderPassCreateInfo;
2045
2046 typedef struct VkEventCreateInfo_
2047 {
2048     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
2049     const void*                                 pNext;      // Pointer to next structure
2050     VkEventCreateFlags                          flags;      // Event creation flags
2051 } VkEventCreateInfo;
2052
2053 typedef struct VkFenceCreateInfo_
2054 {
2055     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
2056     const void*                                 pNext;      // Pointer to next structure
2057     VkFenceCreateFlags                          flags;      // Fence creation flags
2058 } VkFenceCreateInfo;
2059
2060 typedef struct VkSemaphoreCreateInfo_
2061 {
2062     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
2063     const void*                                 pNext;      // Pointer to next structure
2064     uint32_t                                    initialCount;
2065     VkSemaphoreCreateFlags                      flags;      // Semaphore creation flags
2066 } VkSemaphoreCreateInfo;
2067
2068 typedef struct VkSemaphoreOpenInfo_
2069 {
2070     VkStructureType                             sType;      // Must be VK_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO
2071     const void*                                 pNext;      // Pointer to next structure
2072     VkSemaphore                                 sharedSemaphore;
2073 } VkSemaphoreOpenInfo;
2074
2075 typedef struct VkQueryPoolCreateInfo_
2076 {
2077     VkStructureType                             sType;              // Must be VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
2078     const void*                                 pNext;              // Pointer to next structure
2079     VkQueryType                                 queryType;
2080     uint32_t                                    slots;
2081     VkQueryPipelineStatisticFlags               pipelineStatistics; // Optional
2082 } VkQueryPoolCreateInfo;
2083
2084 typedef struct VkFramebufferCreateInfo_
2085 {
2086     VkStructureType                             sType;  // Must be VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
2087     const void*                                 pNext;  // Pointer to next structure
2088
2089     uint32_t                                    colorAttachmentCount;
2090     const VkColorAttachmentBindInfo*            pColorAttachments;
2091     const VkDepthStencilBindInfo*               pDepthStencilAttachment;
2092
2093     uint32_t                                    sampleCount;
2094     uint32_t                                    width;
2095     uint32_t                                    height;
2096     uint32_t                                    layers;
2097 } VkFramebufferCreateInfo;
2098
2099 typedef struct VkDrawIndirectCmd_
2100 {
2101     uint32_t                                    vertexCount;
2102     uint32_t                                    instanceCount;
2103     uint32_t                                    firstVertex;
2104     uint32_t                                    firstInstance;
2105 } VkDrawIndirectCmd;
2106
2107 typedef struct VkDrawIndexedIndirectCmd_
2108 {
2109     uint32_t                                    indexCount;
2110     uint32_t                                    instanceCount;
2111     uint32_t                                    firstIndex;
2112     int32_t                                     vertexOffset;
2113     uint32_t                                    firstInstance;
2114 } VkDrawIndexedIndirectCmd;
2115
2116 typedef struct VkDispatchIndirectCmd_
2117 {
2118     uint32_t                                    x;
2119     uint32_t                                    y;
2120     uint32_t                                    z;
2121 } VkDispatchIndirectCmd;
2122
2123 // ------------------------------------------------------------------------------------------------
2124 // API functions
2125 typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
2126 typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
2127 typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
2128 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceInfo)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, size_t* pDataSize, void* pData);
2129 typedef void *   (VKAPI *PFN_vkGetProcAddr)(VkPhysicalDevice physicalDevice, const char * pName);
2130 typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
2131 typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
2132 typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionInfo)(VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData);
2133 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionInfo)(VkPhysicalDevice physicalDevice, VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData);
2134 typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalDevice physicalDevice, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved);
2135 typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue);
2136 typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
2137 typedef VkResult (VKAPI *PFN_vkQueueAddMemReferences)(VkQueue queue, uint32_t count, const VkDeviceMemory* pMems);
2138 typedef VkResult (VKAPI *PFN_vkQueueRemoveMemReferences)(VkQueue queue, uint32_t count, const VkDeviceMemory* pMems);
2139 typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
2140 typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
2141 typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
2142 typedef VkResult (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem);
2143 typedef VkResult (VKAPI *PFN_vkSetMemoryPriority)(VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority);
2144 typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
2145 typedef VkResult (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
2146 typedef VkResult (VKAPI *PFN_vkFlushMappedMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size);
2147 typedef VkResult (VKAPI *PFN_vkPinSystemMemory)(VkDevice device, const void* pSysMem, size_t memSize, VkDeviceMemory* pMem);
2148 typedef VkResult (VKAPI *PFN_vkGetMultiDeviceCompatibility)(VkPhysicalDevice physicalDevice0, VkPhysicalDevice physicalDevice1, VkPhysicalDeviceCompatibilityInfo* pInfo);
2149 typedef VkResult (VKAPI *PFN_vkOpenSharedMemory)(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem);
2150 typedef VkResult (VKAPI *PFN_vkOpenSharedSemaphore)(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore);
2151 typedef VkResult (VKAPI *PFN_vkOpenPeerMemory)(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem);
2152 typedef VkResult (VKAPI *PFN_vkOpenPeerImage)(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem);
2153 typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkDevice device, VkObjectType objType, VkObject object);
2154 typedef VkResult (VKAPI *PFN_vkGetObjectInfo)(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData);
2155 typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemory)(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset);
2156 typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemoryRange)(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
2157 typedef VkResult (VKAPI *PFN_vkQueueBindImageMemoryRange)(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
2158 typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
2159 typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, VkFence* pFences);
2160 typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
2161 typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout);
2162 typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
2163 typedef VkResult (VKAPI *PFN_vkQueueSignalSemaphore)(VkQueue queue, VkSemaphore semaphore);
2164 typedef VkResult (VKAPI *PFN_vkQueueWaitSemaphore)(VkQueue queue, VkSemaphore semaphore);
2165 typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
2166 typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
2167 typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
2168 typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
2169 typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
2170 typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags);
2171 typedef VkResult (VKAPI *PFN_vkGetFormatInfo)(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData);
2172 typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
2173 typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
2174 typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
2175 typedef VkResult (VKAPI *PFN_vkGetImageSubresourceInfo)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData);
2176 typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
2177 typedef VkResult (VKAPI *PFN_vkCreateColorAttachmentView)(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView);
2178 typedef VkResult (VKAPI *PFN_vkCreateDepthStencilView)(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView);
2179 typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
2180 typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipeline)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline);
2181 typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelineDerivative)(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline);
2182 typedef VkResult (VKAPI *PFN_vkCreateComputePipeline)(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline);
2183 typedef VkResult (VKAPI *PFN_vkStorePipeline)(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData);
2184 typedef VkResult (VKAPI *PFN_vkLoadPipeline)(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline);
2185 typedef VkResult (VKAPI *PFN_vkLoadPipelineDerivative)(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline);
2186 typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
2187 typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
2188 typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
2189 typedef VkResult (VKAPI *PFN_vkBeginDescriptorPoolUpdate)(VkDevice device, VkDescriptorUpdateMode updateMode);
2190 typedef VkResult (VKAPI *PFN_vkEndDescriptorPoolUpdate)(VkDevice device, VkCmdBuffer cmd);
2191 typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
2192 typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
2193 typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount);
2194 typedef void     (VKAPI *PFN_vkClearDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
2195 typedef void     (VKAPI *PFN_vkUpdateDescriptors)(VkDevice device, VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray);
2196 typedef VkResult (VKAPI *PFN_vkCreateDynamicViewportState)(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState);
2197 typedef VkResult (VKAPI *PFN_vkCreateDynamicRasterState)(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState);
2198 typedef VkResult (VKAPI *PFN_vkCreateDynamicColorBlendState)(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState);
2199 typedef VkResult (VKAPI *PFN_vkCreateDynamicDepthStencilState)(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState);
2200 typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
2201 typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
2202 typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
2203 typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer);
2204 typedef void     (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
2205 typedef void     (VKAPI *PFN_vkCmdBindDynamicStateObject)(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state);
2206 typedef void     (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
2207 typedef void     (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
2208 typedef void     (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
2209 typedef void     (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
2210 typedef void     (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
2211 typedef void     (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
2212 typedef void     (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
2213 typedef void     (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
2214 typedef void     (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
2215 typedef void     (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
2216 typedef void     (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
2217 typedef void     (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions);
2218 typedef void     (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
2219 typedef void     (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
2220 typedef void     (VKAPI *PFN_vkCmdCloneImageData)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout);
2221 typedef void     (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
2222 typedef void     (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
2223 typedef void     (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, VkClearColor color, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
2224 typedef void     (VKAPI *PFN_vkCmdClearDepthStencil)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
2225 typedef void     (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
2226 typedef void     (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent);
2227 typedef void     (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent);
2228 typedef void     (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers);
2229 typedef void     (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers);
2230 typedef void     (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
2231 typedef void     (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
2232 typedef void     (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
2233 typedef void     (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset);
2234 typedef void     (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
2235 typedef void     (VKAPI *PFN_vkCmdInitAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData);
2236 typedef void     (VKAPI *PFN_vkCmdLoadAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset);
2237 typedef void     (VKAPI *PFN_vkCmdSaveAtomicCounters)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkDeviceSize destOffset);
2238 typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
2239 typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
2240 typedef void     (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin);
2241 typedef void     (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer, VkRenderPass renderPass);
2242
2243 #ifdef VK_PROTOTYPES
2244
2245 // Device initialization
2246
2247 VkResult VKAPI vkCreateInstance(
2248     const VkInstanceCreateInfo*                 pCreateInfo,
2249     VkInstance*                                 pInstance);
2250
2251 VkResult VKAPI vkDestroyInstance(
2252     VkInstance                                  instance);
2253
2254 VkResult VKAPI vkEnumeratePhysicalDevices(
2255     VkInstance                                  instance,
2256     uint32_t*                                   pPhysicalDeviceCount,
2257     VkPhysicalDevice*                           pPhysicalDevices);
2258
2259 VkResult VKAPI vkGetPhysicalDeviceInfo(
2260     VkPhysicalDevice                            physicalDevice,
2261     VkPhysicalDeviceInfoType                    infoType,
2262     size_t*                                     pDataSize,
2263     void*                                       pData);
2264
2265 void * VKAPI vkGetProcAddr(
2266     VkPhysicalDevice                            physicalDevice,
2267     const char*                                 pName);
2268
2269 // Device functions
2270
2271 VkResult VKAPI vkCreateDevice(
2272     VkPhysicalDevice                            physicalDevice,
2273     const VkDeviceCreateInfo*                   pCreateInfo,
2274     VkDevice*                                   pDevice);
2275
2276 VkResult VKAPI vkDestroyDevice(
2277     VkDevice                                    device);
2278
2279 // Extension discovery functions
2280
2281 VkResult VKAPI vkGetGlobalExtensionInfo(
2282     VkExtensionInfoType                         infoType,
2283     uint32_t                                    extensionIndex,
2284     size_t*                                     pDataSize,
2285     void*                                       pData);
2286
2287 VkResult VKAPI vkGetPhysicalDeviceExtensionInfo(
2288     VkPhysicalDevice                            physicalDevice,
2289     VkExtensionInfoType                         infoType,
2290     uint32_t                                    extensionIndex,
2291     size_t*                                     pDataSize,
2292     void*                                       pData);
2293
2294 // Layer discovery functions
2295
2296 VkResult VKAPI vkEnumerateLayers(
2297     VkPhysicalDevice                            physicalDevice,
2298     size_t                                      maxStringSize,
2299     size_t*                                     pLayerCount,
2300     char* const*                                pOutLayers,
2301     void*                                       pReserved);
2302
2303 // Queue functions
2304
2305 VkResult VKAPI vkGetDeviceQueue(
2306     VkDevice                                    device,
2307     uint32_t                                    queueNodeIndex,
2308     uint32_t                                    queueIndex,
2309     VkQueue*                                    pQueue);
2310
2311 VkResult VKAPI vkQueueSubmit(
2312     VkQueue                                     queue,
2313     uint32_t                                    cmdBufferCount,
2314     const VkCmdBuffer*                          pCmdBuffers,
2315     VkFence                                     fence);
2316
2317 VkResult VKAPI vkQueueAddMemReferences(
2318     VkQueue                                     queue,
2319     uint32_t                                    count,
2320     const VkDeviceMemory*                       pMems);
2321
2322 VkResult VKAPI vkQueueRemoveMemReferences(
2323     VkQueue                                     queue,
2324     uint32_t                                    count,
2325     const VkDeviceMemory*                       pMems);
2326
2327 VkResult VKAPI vkQueueWaitIdle(
2328     VkQueue                                     queue);
2329
2330 VkResult VKAPI vkDeviceWaitIdle(
2331     VkDevice                                    device);
2332
2333 // Memory functions
2334
2335 VkResult VKAPI vkAllocMemory(
2336     VkDevice                                    device,
2337     const VkMemoryAllocInfo*                    pAllocInfo,
2338     VkDeviceMemory*                             pMem);
2339
2340 VkResult VKAPI vkFreeMemory(
2341     VkDevice                                    device,
2342     VkDeviceMemory                              mem);
2343
2344 VkResult VKAPI vkSetMemoryPriority(
2345     VkDevice                                    device,
2346     VkDeviceMemory                              mem,
2347     VkMemoryPriority                            priority);
2348
2349 VkResult VKAPI vkMapMemory(
2350     VkDevice                                    device,
2351     VkDeviceMemory                              mem,
2352     VkDeviceSize                                offset,
2353     VkDeviceSize                                size,
2354     VkMemoryMapFlags                            flags,
2355     void**                                      ppData);
2356
2357 VkResult VKAPI vkUnmapMemory(
2358     VkDevice                                    device,
2359     VkDeviceMemory                              mem);
2360
2361 VkResult VKAPI vkFlushMappedMemory(
2362     VkDevice                                    device,
2363     VkDeviceMemory                              mem,
2364     VkDeviceSize                                offset,
2365     VkDeviceSize                                size);
2366
2367 VkResult VKAPI vkPinSystemMemory(
2368     VkDevice                                    device,
2369     const void*                                 pSysMem,
2370     size_t                                      memSize,
2371     VkDeviceMemory*                             pMem);
2372
2373 // Multi-device functions
2374
2375 VkResult VKAPI vkGetMultiDeviceCompatibility(
2376     VkPhysicalDevice                            physicalDevice0,
2377     VkPhysicalDevice                            physicalDevice1,
2378     VkPhysicalDeviceCompatibilityInfo*          pInfo);
2379
2380 VkResult VKAPI vkOpenSharedMemory(
2381     VkDevice                                    device,
2382     const VkMemoryOpenInfo*                     pOpenInfo,
2383     VkDeviceMemory*                             pMem);
2384
2385 VkResult VKAPI vkOpenSharedSemaphore(
2386     VkDevice                                    device,
2387     const VkSemaphoreOpenInfo*                  pOpenInfo,
2388     VkSemaphore*                                pSemaphore);
2389
2390 VkResult VKAPI vkOpenPeerMemory(
2391     VkDevice                                    device,
2392     const VkPeerMemoryOpenInfo*                 pOpenInfo,
2393     VkDeviceMemory*                             pMem);
2394
2395 VkResult VKAPI vkOpenPeerImage(
2396     VkDevice                                    device,
2397     const VkPeerImageOpenInfo*                  pOpenInfo,
2398     VkImage*                                    pImage,
2399     VkDeviceMemory*                             pMem);
2400
2401 // Generic API object functions
2402
2403 VkResult VKAPI vkDestroyObject(
2404     VkDevice                                    device,
2405     VkObjectType                                objType,
2406     VkObject                                    object);
2407
2408 VkResult VKAPI vkGetObjectInfo(
2409     VkDevice                                    device,
2410     VkObjectType                                objType,
2411     VkObject                                    object,
2412     VkObjectInfoType                            infoType,
2413     size_t*                                     pDataSize,
2414     void*                                       pData);
2415
2416 // Memory management API functions
2417
2418 VkResult VKAPI vkQueueBindObjectMemory(
2419     VkQueue                                     queue,
2420     VkObjectType                                objType,
2421     VkObject                                    object,
2422     uint32_t                                    allocationIdx,
2423     VkDeviceMemory                              mem,
2424     VkDeviceSize                                memOffset);
2425
2426 VkResult VKAPI vkQueueBindObjectMemoryRange(
2427     VkQueue                                     queue,
2428     VkObjectType                                objType,
2429     VkObject                                    object,
2430     uint32_t                                    allocationIdx,
2431     VkDeviceSize                                rangeOffset,
2432     VkDeviceSize                                rangeSize,
2433     VkDeviceMemory                              mem,
2434     VkDeviceSize                                memOffset);
2435
2436 VkResult VKAPI vkQueueBindImageMemoryRange(
2437     VkQueue                                     queue,
2438     VkImage                                     image,
2439     uint32_t                                    allocationIdx,
2440     const VkImageMemoryBindInfo*                pBindInfo,
2441     VkDeviceMemory                              mem,
2442     VkDeviceSize                                memOffset);
2443
2444 // Fence functions
2445
2446 VkResult VKAPI vkCreateFence(
2447     VkDevice                                    device,
2448     const VkFenceCreateInfo*                    pCreateInfo,
2449     VkFence*                                    pFence);
2450
2451 VkResult VKAPI vkResetFences(
2452     VkDevice                                    device,
2453     uint32_t                                    fenceCount,
2454     VkFence*                                    pFences);
2455
2456 VkResult VKAPI vkGetFenceStatus(
2457     VkDevice                                    device,
2458     VkFence                                     fence);
2459
2460 VkResult VKAPI vkWaitForFences(
2461     VkDevice                                    device,
2462     uint32_t                                    fenceCount,
2463     const VkFence*                              pFences,
2464     bool32_t                                    waitAll,
2465     uint64_t                                    timeout); // timeout in nanoseconds
2466
2467 // Queue semaphore functions
2468
2469 VkResult VKAPI vkCreateSemaphore(
2470     VkDevice                                    device,
2471     const VkSemaphoreCreateInfo*                pCreateInfo,
2472     VkSemaphore*                                pSemaphore);
2473
2474 VkResult VKAPI vkQueueSignalSemaphore(
2475     VkQueue                                     queue,
2476     VkSemaphore                                 semaphore);
2477
2478 VkResult VKAPI vkQueueWaitSemaphore(
2479     VkQueue                                     queue,
2480     VkSemaphore                                 semaphore);
2481
2482 // Event functions
2483
2484 VkResult VKAPI vkCreateEvent(
2485     VkDevice                                    device,
2486     const VkEventCreateInfo*                    pCreateInfo,
2487     VkEvent*                                    pEvent);
2488
2489 VkResult VKAPI vkGetEventStatus(
2490     VkDevice                                    device,
2491     VkEvent                                     event);
2492
2493 VkResult VKAPI vkSetEvent(
2494     VkDevice                                    device,
2495     VkEvent                                     event);
2496
2497 VkResult VKAPI vkResetEvent(
2498     VkDevice                                    device,
2499     VkEvent                                     event);
2500
2501 // Query functions
2502
2503 VkResult VKAPI vkCreateQueryPool(
2504     VkDevice                                    device,
2505     const VkQueryPoolCreateInfo*                pCreateInfo,
2506     VkQueryPool*                                pQueryPool);
2507
2508 VkResult VKAPI vkGetQueryPoolResults(
2509     VkDevice                                    device,
2510     VkQueryPool                                 queryPool,
2511     uint32_t                                    startQuery,
2512     uint32_t                                    queryCount,
2513     size_t*                                     pDataSize,
2514     void*                                       pData,
2515     VkQueryResultFlags                          flags);
2516
2517 // Format capabilities
2518
2519 VkResult VKAPI vkGetFormatInfo(
2520     VkDevice                                    device,
2521     VkFormat                                    format,
2522     VkFormatInfoType                            infoType,
2523     size_t*                                     pDataSize,
2524     void*                                       pData);
2525
2526 // Buffer functions
2527
2528 VkResult VKAPI vkCreateBuffer(
2529     VkDevice                                    device,
2530     const VkBufferCreateInfo*                   pCreateInfo,
2531     VkBuffer*                                   pBuffer);
2532
2533 // Buffer view functions
2534
2535 VkResult VKAPI vkCreateBufferView(
2536     VkDevice                                    device,
2537     const VkBufferViewCreateInfo*               pCreateInfo,
2538     VkBufferView*                               pView);
2539
2540 // Image functions
2541
2542 VkResult VKAPI vkCreateImage(
2543     VkDevice                                    device,
2544     const VkImageCreateInfo*                    pCreateInfo,
2545     VkImage*                                    pImage);
2546
2547 VkResult VKAPI vkGetImageSubresourceInfo(
2548     VkDevice                                    device,
2549     VkImage                                     image,
2550     const VkImageSubresource*                   pSubresource,
2551     VkSubresourceInfoType                       infoType,
2552     size_t*                                     pDataSize,
2553     void*                                       pData);
2554
2555 // Image view functions
2556
2557 VkResult VKAPI vkCreateImageView(
2558     VkDevice                                    device,
2559     const VkImageViewCreateInfo*                pCreateInfo,
2560     VkImageView*                                pView);
2561
2562 VkResult VKAPI vkCreateColorAttachmentView(
2563     VkDevice                                    device,
2564     const VkColorAttachmentViewCreateInfo*      pCreateInfo,
2565     VkColorAttachmentView*                      pView);
2566
2567 VkResult VKAPI vkCreateDepthStencilView(
2568     VkDevice                                    device,
2569     const VkDepthStencilViewCreateInfo*         pCreateInfo,
2570     VkDepthStencilView*                         pView);
2571
2572 // Shader functions
2573
2574 VkResult VKAPI vkCreateShader(
2575     VkDevice                                    device,
2576     const VkShaderCreateInfo*                   pCreateInfo,
2577     VkShader*                                   pShader);
2578
2579 // Pipeline functions
2580
2581 VkResult VKAPI vkCreateGraphicsPipeline(
2582     VkDevice                                    device,
2583     const VkGraphicsPipelineCreateInfo*         pCreateInfo,
2584     VkPipeline*                                 pPipeline);
2585
2586 VkResult VKAPI vkCreateGraphicsPipelineDerivative(
2587     VkDevice                                    device,
2588     const VkGraphicsPipelineCreateInfo*         pCreateInfo,
2589     VkPipeline                                  basePipeline,
2590     VkPipeline*                                 pPipeline);
2591
2592 VkResult VKAPI vkCreateComputePipeline(
2593     VkDevice                                    device,
2594     const VkComputePipelineCreateInfo*          pCreateInfo,
2595     VkPipeline*                                 pPipeline);
2596
2597 VkResult VKAPI vkStorePipeline(
2598     VkDevice                                    device,
2599     VkPipeline                                  pipeline,
2600     size_t*                                     pDataSize,
2601     void*                                       pData);
2602
2603 VkResult VKAPI vkLoadPipeline(
2604     VkDevice                                    device,
2605     size_t                                      dataSize,
2606     const void*                                 pData,
2607     VkPipeline*                                 pPipeline);
2608
2609 VkResult VKAPI vkLoadPipelineDerivative(
2610     VkDevice                                    device,
2611     size_t                                      dataSize,
2612     const void*                                 pData,
2613     VkPipeline                                  basePipeline,
2614     VkPipeline*                                 pPipeline);
2615
2616 // Pipeline layout functions
2617
2618 VkResult VKAPI vkCreatePipelineLayout(
2619     VkDevice                                    device,
2620     const VkPipelineLayoutCreateInfo*           pCreateInfo,
2621     VkPipelineLayout*                           pPipelineLayout);
2622
2623 // Sampler functions
2624
2625 VkResult VKAPI vkCreateSampler(
2626     VkDevice                                    device,
2627     const VkSamplerCreateInfo*                  pCreateInfo,
2628     VkSampler*                                  pSampler);
2629
2630 // Descriptor set functions
2631
2632 VkResult VKAPI vkCreateDescriptorSetLayout(
2633     VkDevice                                    device,
2634     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
2635     VkDescriptorSetLayout*                      pSetLayout);
2636
2637 VkResult VKAPI vkBeginDescriptorPoolUpdate(
2638     VkDevice                                    device,
2639     VkDescriptorUpdateMode                      updateMode);
2640
2641 VkResult VKAPI vkEndDescriptorPoolUpdate(
2642     VkDevice                                    device,
2643     VkCmdBuffer                                 cmd);
2644
2645 VkResult VKAPI vkCreateDescriptorPool(
2646     VkDevice                                    device,
2647     VkDescriptorPoolUsage                       poolUsage,
2648     uint32_t                                    maxSets,
2649     const VkDescriptorPoolCreateInfo*           pCreateInfo,
2650     VkDescriptorPool*                           pDescriptorPool);
2651
2652 VkResult VKAPI vkResetDescriptorPool(
2653     VkDevice                                    device,
2654     VkDescriptorPool                            descriptorPool);
2655
2656 VkResult VKAPI vkAllocDescriptorSets(
2657     VkDevice                                    device,
2658     VkDescriptorPool                            descriptorPool,
2659     VkDescriptorSetUsage                        setUsage,
2660     uint32_t                                    count,
2661     const VkDescriptorSetLayout*                pSetLayouts,
2662     VkDescriptorSet*                            pDescriptorSets,
2663     uint32_t*                                   pCount);
2664
2665 void VKAPI vkClearDescriptorSets(
2666     VkDevice                                    device,
2667     VkDescriptorPool                            descriptorPool,
2668     uint32_t                                    count,
2669     const VkDescriptorSet*                      pDescriptorSets);
2670
2671 void VKAPI vkUpdateDescriptors(
2672     VkDevice                                    device,
2673     VkDescriptorSet                             descriptorSet,
2674     uint32_t                                    updateCount,
2675     const void**                                ppUpdateArray);
2676
2677 // State object functions
2678
2679 VkResult VKAPI vkCreateDynamicViewportState(
2680     VkDevice                                    device,
2681     const VkDynamicVpStateCreateInfo*           pCreateInfo,
2682     VkDynamicVpState*                           pState);
2683
2684 VkResult VKAPI vkCreateDynamicRasterState(
2685     VkDevice                                    device,
2686     const VkDynamicRsStateCreateInfo*           pCreateInfo,
2687     VkDynamicRsState*                           pState);
2688
2689 VkResult VKAPI vkCreateDynamicColorBlendState(
2690     VkDevice                                    device,
2691     const VkDynamicCbStateCreateInfo*           pCreateInfo,
2692     VkDynamicCbState*                           pState);
2693
2694 VkResult VKAPI vkCreateDynamicDepthStencilState(
2695     VkDevice                                    device,
2696     const VkDynamicDsStateCreateInfo*           pCreateInfo,
2697     VkDynamicDsState*                           pState);
2698
2699 // Command buffer functions
2700
2701 VkResult VKAPI vkCreateCommandBuffer(
2702     VkDevice                                    device,
2703     const VkCmdBufferCreateInfo*                pCreateInfo,
2704     VkCmdBuffer*                                pCmdBuffer);
2705
2706 VkResult VKAPI vkBeginCommandBuffer(
2707     VkCmdBuffer                                 cmdBuffer,
2708     const VkCmdBufferBeginInfo*                 pBeginInfo);
2709
2710 VkResult VKAPI vkEndCommandBuffer(
2711     VkCmdBuffer                                 cmdBuffer);
2712
2713 VkResult VKAPI vkResetCommandBuffer(
2714     VkCmdBuffer                                 cmdBuffer);
2715
2716 // Command buffer building functions
2717
2718 void VKAPI vkCmdBindPipeline(
2719     VkCmdBuffer                                 cmdBuffer,
2720     VkPipelineBindPoint                         pipelineBindPoint,
2721     VkPipeline                                  pipeline);
2722
2723 void VKAPI vkCmdBindDynamicStateObject(
2724     VkCmdBuffer                                 cmdBuffer,
2725     VkStateBindPoint                            stateBindPoint,
2726     VkDynamicStateObject                        dynamicState);
2727
2728 void VKAPI vkCmdBindDescriptorSets(
2729     VkCmdBuffer                                 cmdBuffer,
2730     VkPipelineBindPoint                         pipelineBindPoint,
2731     uint32_t                                    firstSet,
2732     uint32_t                                    setCount,
2733     const VkDescriptorSet*                      pDescriptorSets,
2734     uint32_t                                    dynamicOffsetCount,
2735     const uint32_t*                             pDynamicOffsets);
2736
2737 void VKAPI vkCmdBindIndexBuffer(
2738     VkCmdBuffer                                 cmdBuffer,
2739     VkBuffer                                    buffer,
2740     VkDeviceSize                                offset,
2741     VkIndexType                                 indexType);
2742
2743 void VKAPI vkCmdBindVertexBuffers(
2744     VkCmdBuffer                                 cmdBuffer,
2745     uint32_t                                    startBinding,
2746     uint32_t                                    bindingCount,
2747     const VkBuffer*                             pBuffers,
2748     const VkDeviceSize*                         pOffsets);
2749
2750 void VKAPI vkCmdDraw(
2751     VkCmdBuffer                                 cmdBuffer,
2752     uint32_t                                    firstVertex,
2753     uint32_t                                    vertexCount,
2754     uint32_t                                    firstInstance,
2755     uint32_t                                    instanceCount);
2756
2757 void VKAPI vkCmdDrawIndexed(
2758     VkCmdBuffer                                 cmdBuffer,
2759     uint32_t                                    firstIndex,
2760     uint32_t                                    indexCount,
2761     int32_t                                     vertexOffset,
2762     uint32_t                                    firstInstance,
2763     uint32_t                                    instanceCount);
2764
2765 void VKAPI vkCmdDrawIndirect(
2766     VkCmdBuffer                                 cmdBuffer,
2767     VkBuffer                                    buffer,
2768     VkDeviceSize                                offset,
2769     uint32_t                                    count,
2770     uint32_t                                    stride);
2771
2772 void VKAPI vkCmdDrawIndexedIndirect(
2773     VkCmdBuffer                                 cmdBuffer,
2774     VkBuffer                                    buffer,
2775     VkDeviceSize                                offset,
2776     uint32_t                                    count,
2777     uint32_t                                    stride);
2778
2779 void VKAPI vkCmdDispatch(
2780     VkCmdBuffer                                 cmdBuffer,
2781     uint32_t                                    x,
2782     uint32_t                                    y,
2783     uint32_t                                    z);
2784
2785 void VKAPI vkCmdDispatchIndirect(
2786     VkCmdBuffer                                 cmdBuffer,
2787     VkBuffer                                    buffer,
2788     VkDeviceSize                                offset);
2789
2790 void VKAPI vkCmdCopyBuffer(
2791     VkCmdBuffer                                 cmdBuffer,
2792     VkBuffer                                    srcBuffer,
2793     VkBuffer                                    destBuffer,
2794     uint32_t                                    regionCount,
2795     const VkBufferCopy*                         pRegions);
2796
2797 void VKAPI vkCmdCopyImage(
2798     VkCmdBuffer                                 cmdBuffer,
2799     VkImage                                     srcImage,
2800     VkImageLayout                               srcImageLayout,
2801     VkImage                                     destImage,
2802     VkImageLayout                               destImageLayout,
2803     uint32_t                                    regionCount,
2804     const VkImageCopy*                          pRegions);
2805
2806 void VKAPI vkCmdBlitImage(
2807     VkCmdBuffer                                 cmdBuffer,
2808     VkImage                                     srcImage,
2809     VkImageLayout                               srcImageLayout,
2810     VkImage                                     destImage,
2811     VkImageLayout                               destImageLayout,
2812     uint32_t                                    regionCount,
2813     const VkImageBlit*                          pRegions);
2814
2815 void VKAPI vkCmdCopyBufferToImage(
2816     VkCmdBuffer                                 cmdBuffer,
2817     VkBuffer                                    srcBuffer,
2818     VkImage                                     destImage,
2819     VkImageLayout                               destImageLayout,
2820     uint32_t                                    regionCount,
2821     const VkBufferImageCopy*                    pRegions);
2822
2823 void VKAPI vkCmdCopyImageToBuffer(
2824     VkCmdBuffer                                 cmdBuffer,
2825     VkImage                                     srcImage,
2826     VkImageLayout                               srcImageLayout,
2827     VkBuffer                                    destBuffer,
2828     uint32_t                                    regionCount,
2829     const VkBufferImageCopy*                    pRegions);
2830
2831 void VKAPI vkCmdCloneImageData(
2832     VkCmdBuffer                                 cmdBuffer,
2833     VkImage                                     srcImage,
2834     VkImageLayout                               srcImageLayout,
2835     VkImage                                     destImage,
2836     VkImageLayout                               destImageLayout);
2837
2838 void VKAPI vkCmdUpdateBuffer(
2839     VkCmdBuffer                                 cmdBuffer,
2840     VkBuffer                                    destBuffer,
2841     VkDeviceSize                                destOffset,
2842     VkDeviceSize                                dataSize,
2843     const uint32_t*                             pData);
2844
2845 void VKAPI vkCmdFillBuffer(
2846     VkCmdBuffer                                 cmdBuffer,
2847     VkBuffer                                    destBuffer,
2848     VkDeviceSize                                destOffset,
2849     VkDeviceSize                                fillSize,
2850     uint32_t                                    data);
2851
2852 void VKAPI vkCmdClearColorImage(
2853     VkCmdBuffer                                 cmdBuffer,
2854     VkImage                                     image,
2855     VkImageLayout                               imageLayout,
2856     const VkClearColor*                         color,
2857     uint32_t                                    rangeCount,
2858     const VkImageSubresourceRange*              pRanges);
2859
2860 void VKAPI vkCmdClearDepthStencil(
2861     VkCmdBuffer                                 cmdBuffer,
2862     VkImage                                     image,
2863     VkImageLayout                               imageLayout,
2864     float                                       depth,
2865     uint32_t                                    stencil,
2866     uint32_t                                    rangeCount,
2867     const VkImageSubresourceRange*              pRanges);
2868
2869 void VKAPI vkCmdResolveImage(
2870     VkCmdBuffer                                 cmdBuffer,
2871     VkImage                                     srcImage,
2872     VkImageLayout                               srcImageLayout,
2873     VkImage                                     destImage,
2874     VkImageLayout                               destImageLayout,
2875     uint32_t                                    regionCount,
2876     const VkImageResolve*                       pRegions);
2877
2878 void VKAPI vkCmdSetEvent(
2879     VkCmdBuffer                                 cmdBuffer,
2880     VkEvent                                     event,
2881     VkPipeEvent                                 pipeEvent);
2882
2883 void VKAPI vkCmdResetEvent(
2884     VkCmdBuffer                                 cmdBuffer,
2885     VkEvent                                     event,
2886     VkPipeEvent                                 pipeEvent);
2887
2888 void VKAPI vkCmdWaitEvents(
2889     VkCmdBuffer                                 cmdBuffer,
2890     VkWaitEvent                                 waitEvent,
2891     uint32_t                                    eventCount,
2892     const VkEvent*                              pEvents,
2893     uint32_t                                    memBarrierCount,
2894     const void**                                ppMemBarriers);
2895
2896 void VKAPI vkCmdPipelineBarrier(
2897     VkCmdBuffer                                 cmdBuffer,
2898     VkWaitEvent                                 waitEvent,
2899     uint32_t                                    pipeEventCount,
2900     const VkPipeEvent*                          pPipeEvents,
2901     uint32_t                                    memBarrierCount,
2902     const void**                                ppMemBarriers);
2903
2904 void VKAPI vkCmdBeginQuery(
2905     VkCmdBuffer                                 cmdBuffer,
2906     VkQueryPool                                 queryPool,
2907     uint32_t                                    slot,
2908     VkQueryControlFlags                         flags);
2909
2910 void VKAPI vkCmdEndQuery(
2911     VkCmdBuffer                                 cmdBuffer,
2912     VkQueryPool                                 queryPool,
2913     uint32_t                                    slot);
2914
2915 void VKAPI vkCmdResetQueryPool(
2916     VkCmdBuffer                                 cmdBuffer,
2917     VkQueryPool                                 queryPool,
2918     uint32_t                                    startQuery,
2919     uint32_t                                    queryCount);
2920
2921 void VKAPI vkCmdWriteTimestamp(
2922     VkCmdBuffer                                 cmdBuffer,
2923     VkTimestampType                             timestampType,
2924     VkBuffer                                    destBuffer,
2925     VkDeviceSize                                destOffset);
2926
2927 void VKAPI vkCmdCopyQueryPoolResults(
2928     VkCmdBuffer                                 cmdBuffer,
2929     VkQueryPool                                 queryPool,
2930     uint32_t                                    startQuery,
2931     uint32_t                                    queryCount,
2932     VkBuffer                                    destBuffer,
2933     VkDeviceSize                                destOffset,
2934     VkDeviceSize                                destStride,
2935     VkQueryResultFlags                          flags);
2936
2937 void VKAPI vkCmdInitAtomicCounters(
2938     VkCmdBuffer                                 cmdBuffer,
2939     VkPipelineBindPoint                         pipelineBindPoint,
2940     uint32_t                                    startCounter,
2941     uint32_t                                    counterCount,
2942     const uint32_t*                             pData);
2943
2944 void VKAPI vkCmdLoadAtomicCounters(
2945     VkCmdBuffer                                 cmdBuffer,
2946     VkPipelineBindPoint                         pipelineBindPoint,
2947     uint32_t                                    startCounter,
2948     uint32_t                                    counterCount,
2949     VkBuffer                                    srcBuffer,
2950     VkDeviceSize                                srcOffset);
2951
2952 void VKAPI vkCmdSaveAtomicCounters(
2953     VkCmdBuffer                                 cmdBuffer,
2954     VkPipelineBindPoint                         pipelineBindPoint,
2955     uint32_t                                    startCounter,
2956     uint32_t                                    counterCount,
2957     VkBuffer                                    destBuffer,
2958     VkDeviceSize                                destOffset);
2959
2960 VkResult VKAPI vkCreateFramebuffer(
2961     VkDevice                                    device,
2962     const VkFramebufferCreateInfo*              pCreateInfo,
2963     VkFramebuffer*                              pFramebuffer);
2964
2965 VkResult VKAPI vkCreateRenderPass(
2966     VkDevice                                    device,
2967     const VkRenderPassCreateInfo*               pCreateInfo,
2968     VkRenderPass*                               pRenderPass);
2969
2970 void VKAPI vkCmdBeginRenderPass(
2971     VkCmdBuffer                                 cmdBuffer,
2972     const VkRenderPassBegin*                    pRenderPassBegin);
2973
2974 void VKAPI vkCmdEndRenderPass(
2975     VkCmdBuffer                                 cmdBuffer,
2976     VkRenderPass                                renderPass);
2977
2978 #endif // VK_PROTOTYPES
2979
2980 #ifdef __cplusplus
2981 } // extern "C"
2982 #endif // __cplusplus
2983
2984 #endif // __VULKAN_H__